package com.zy.system.controller;

import com.core.annotations.ManagerAuth;
import com.core.common.R;
import com.zy.system.entity.LicenseInfos;
import com.zy.system.entity.license.LicenseCheckListener;
import com.zy.system.entity.license.LicenseUploadParam;
import com.zy.system.entity.license.LicenseUtils;
import com.zy.system.entity.license.LicenseVerify;
import com.zy.system.entity.license.LicenseVerifyParam;
import com.zy.system.service.LicenseInfosService;
import com.zy.system.timer.LicenseTimer;
import de.schlichtherle.license.LicenseContent;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import java.text.SimpleDateFormat;
import java.util.Base64;
import java.util.Date;

/**
 * 许可证运行时管理
 */
@RestController
@RequestMapping("/license")
public class LicenseCreatorController {

    @Value("${license.subject}")
    private String licenseSubject;
    @Value("${license.publicAlias}")
    private String publicAlias;
    @Value("${license.storePass}")
    private String storePass;
    @Value("${license.publicKeysStorePath}")
    private String publicKeysStorePath;
    @Autowired
    private LicenseCheckListener licenseCheckListener;
    @Autowired
    private LicenseTimer licenseTimer;
    @Autowired
    private LicenseInfosService licenseInfosService;

    /**
     * 获取请求码。
     */
    @ManagerAuth(value = ManagerAuth.Auth.NONE)
    @RequestMapping(value = "/getRequestCode", produces = {MediaType.APPLICATION_JSON_UTF8_VALUE})
    public R getRequestCode() {
        return R.ok(LicenseUtils.buildRequestCode(licenseSubject));
    }

    /**
     * 获取系统配置。
     */
    @ManagerAuth(value = ManagerAuth.Auth.NONE)
    @RequestMapping(value = "/getServerInfos", produces = {MediaType.APPLICATION_JSON_UTF8_VALUE})
    public Object getServerInfos(@RequestParam(value = "osName", required = false) String osName) {
        return LicenseUtils.getServerInfos();
    }

    /**
     * 获取许可证有效期天数
     */
    @ManagerAuth(value = ManagerAuth.Auth.NONE)
    @RequestMapping(value = "/getLicenseDays", produces = {MediaType.APPLICATION_JSON_UTF8_VALUE})
    public R getLicenseDays() {
        int licenseDays = licenseTimer.getLicenseDays();
        if (!licenseTimer.getSystemSupport()) {
            licenseDays = -1;
        }
        return R.ok(licenseDays);
    }

    @ManagerAuth(value = ManagerAuth.Auth.NONE)
    @RequestMapping(value = "/updateLicense", consumes = MediaType.APPLICATION_JSON_VALUE, produces = {MediaType.APPLICATION_JSON_UTF8_VALUE})
    public R updateLicense(@RequestBody LicenseUploadParam param){
        if (param == null || param.getLicense() == null || param.getLicense().trim().isEmpty()) {
            return R.error("许可证内容不能为空");
        }
        return saveAndActivateLicense(param.getLicense().trim());
    }

    @ManagerAuth(value = ManagerAuth.Auth.NONE)
    @RequestMapping(value = "/updateLicense", consumes = MediaType.MULTIPART_FORM_DATA_VALUE, produces = {MediaType.APPLICATION_JSON_UTF8_VALUE})
    public R updateLicense(@RequestParam("file") MultipartFile[] files) {
        if (files == null || files.length == 0 || files[0] == null || files[0].isEmpty()) {
            return R.error("许可证文件不能为空");
        }
        try {
            String licenseBase64 = Base64.getEncoder().encodeToString(files[0].getBytes());
            return saveAndActivateLicense(licenseBase64);
        } catch (Exception e) {
            return R.error("许可证读取失败");
        }
    }

    @ManagerAuth(value = ManagerAuth.Auth.NONE)
    @RequestMapping(value = "/activate", produces = {MediaType.APPLICATION_JSON_UTF8_VALUE})
    public R activate() {
        licenseTimer.timer();
        if (!licenseTimer.getSystemSupport()) {
            return R.error("许可证激活失败");
        }
        return R.ok();
    }

    @ManagerAuth(value = ManagerAuth.Auth.NONE)
    @RequestMapping(value = "/getProjectName", produces = {MediaType.APPLICATION_JSON_UTF8_VALUE})
    public R getProjectName() {
        return R.ok(licenseSubject);
    }

    private R saveAndActivateLicense(String licenseBase64) {
        LicenseVerifyParam verifyParam = buildVerifyParam();
        LicenseVerify licenseVerify = new LicenseVerify();
        LicenseContent install = licenseVerify.install(verifyParam, licenseBase64);
        if (install == null) {
            return R.error("许可证内容无效");
        }

        LicenseInfos licenseInfos = new LicenseInfos();
        licenseInfos.setLicense(licenseBase64);
        licenseInfos.setLicenseTime(formatLicenseTime(install));
        licenseInfos.setRequestCode(LicenseUtils.buildRequestCode(licenseSubject));
        licenseInfos.setCreateTime(new Date());
        if (!licenseInfosService.insert(licenseInfos)) {
            return R.error("许可证保存失败");
        }

        boolean loadedLicense = licenseCheckListener.loadLicense(false);
        if (!loadedLicense) {
            return R.error("许可证激活失败");
        }
        licenseTimer.verify();
        if (!licenseTimer.getSystemSupport()) {
            return R.error("许可证校验失败");
        }
        return R.ok();
    }

    private LicenseVerifyParam buildVerifyParam() {
        LicenseVerifyParam param = new LicenseVerifyParam();
        param.setSubject(licenseSubject);
        param.setPublicAlias(publicAlias);
        param.setStorePass(storePass);
        param.setPublicKeysStorePath(publicKeysStorePath);
        return param;
    }

    private String formatLicenseTime(LicenseContent install) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return format.format(install.getNotBefore()) + "  -  " + format.format(install.getNotAfter());
    }

}