package jnpf.elnController;

import com.baomidou.mybatisplus.core.metadata.IPage;
import io.swagger.v3.oas.annotations.tags.Tag;
import jnpf.base.ActionResult;
import jnpf.base.vo.PageListVO;
import jnpf.base.vo.PaginationVO;
import jnpf.elnEntity.formula.ElnFormulaForms;
import jnpf.elnEntity.formula.ElnFormulaVos;
import jnpf.elnFormula.FormulaFunction;
import jnpf.elnService.formula.ElnFormulaCatalogService;
import jnpf.elnService.formula.FormulaPreviewService;
import jnpf.elnService.formula.FormulaValidationService;
import lombok.RequiredArgsConstructor;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@Tag(name = "ELN公式目录")
@RestController
@RequestMapping("/formulaCatalog")
@RequiredArgsConstructor
public class ElnFormulaCatalogController {

    private final ElnFormulaCatalogService catalogService;
    private final FormulaPreviewService previewService;

    @GetMapping
    public ActionResult<PageListVO<ElnFormulaVos.ListItem>> list(ElnFormulaForms.Query query) {
        if (query == null || query.getCurrentPage() < 1 || query.getPageSize() < 1) {
            return ActionResult.fail("分页参数必须大于 0");
        }
        query.setKeyword(trim(query.getKeyword()));
        query.setBizEnabled(trim(query.getBizEnabled()));
        IPage<ElnFormulaVos.ListItem> page = catalogService.page(query);
        PageListVO<ElnFormulaVos.ListItem> result = new PageListVO<>();
        result.setList(page.getRecords());
        PaginationVO pagination = new PaginationVO();
        pagination.setCurrentPage(page.getCurrent());
        pagination.setPageSize(page.getSize());
        pagination.setTotal(Math.toIntExact(page.getTotal()));
        result.setPagination(pagination);
        return ActionResult.success(result);
    }

    @PostMapping
    public ActionResult<ElnFormulaVos.Detail> create(
            @RequestBody(required = false) ElnFormulaForms.Create form) {
        if (form == null) {
            return ActionResult.fail("公式信息不能为空");
        }
        trimDefinition(form);
        trimRule(form);
        return ActionResult.success(catalogService.create(form));
    }

    @PostMapping("/drafts")
    public ActionResult<ElnFormulaVos.Detail> createDraft(
            @RequestBody(required = false) ElnFormulaForms.CreateDraft form) {
        if (form == null) {
            return ActionResult.fail("公式草稿信息不能为空");
        }
        trimDefinition(form);
        trimParameters(form.getParameters());
        return ActionResult.success(catalogService.createDraft(form));
    }

    @GetMapping("/{id}")
    public ActionResult<ElnFormulaVos.Detail> detail(@PathVariable("id") String id) {
        if (!StringUtils.hasText(id)) {
            return ActionResult.fail("公式 id 不能为空");
        }
        return ActionResult.success(catalogService.detail(id.trim()));
    }

    @GetMapping("/{id}/templateReferences")
    public ActionResult<PageListVO<ElnFormulaVos.ReferenceSummary>> templateReferences(
            @PathVariable("id") String id, ElnFormulaForms.ReferenceQuery query) {
        if (!StringUtils.hasText(id) || query == null
                || query.getCurrentPage() < 1 || query.getPageSize() < 1) {
            return ActionResult.fail("公式 id 不能为空且分页参数必须大于 0");
        }
        query.setKeyword(trim(query.getKeyword()));
        IPage<ElnFormulaVos.ReferenceSummary> page =
                catalogService.pageTemplateReferences(id.trim(), query);
        PageListVO<ElnFormulaVos.ReferenceSummary> result = new PageListVO<>();
        result.setList(page.getRecords());
        PaginationVO pagination = new PaginationVO();
        pagination.setCurrentPage(page.getCurrent());
        pagination.setPageSize(page.getSize());
        pagination.setTotal(Math.toIntExact(page.getTotal()));
        result.setPagination(pagination);
        return ActionResult.success(result);
    }

    @PutMapping("/{id}")
    public ActionResult<ElnFormulaVos.Detail> updateDefinition(
            @PathVariable("id") String id,
            @RequestBody(required = false) ElnFormulaForms.UpdateDefinition form) {
        if (!StringUtils.hasText(id) || form == null) {
            return ActionResult.fail("公式 id 和公式信息不能为空");
        }
        trimDefinition(form);
        return ActionResult.success(catalogService.updateDefinition(id.trim(), form));
    }

    @GetMapping("/functions")
    public ActionResult<List<FormulaFunction>> functions() {
        return ActionResult.success(previewService.functions());
    }

    @PostMapping("/validate")
    public ActionResult<FormulaValidationService.ValidationResult> validate(
            @RequestBody(required = false) ElnFormulaForms.Validate form) {
        if (form == null) {
            return ActionResult.fail("公式校验内容不能为空");
        }
        trimRule(form);
        return ActionResult.success(previewService.validate(form));
    }

    @PostMapping("/preview")
    public ActionResult<ElnFormulaVos.Preview> preview(
            @RequestBody(required = false) ElnFormulaForms.Preview form) {
        if (form == null) {
            return ActionResult.fail("公式试算内容不能为空");
        }
        trimRule(form);
        return ActionResult.success(previewService.preview(form));
    }

    @PostMapping("/{id}/versions")
    public ActionResult<ElnFormulaVos.Version> createVersion(
            @PathVariable("id") String id,
            @RequestBody(required = false) ElnFormulaForms.CreateVersion form) {
        if (!StringUtils.hasText(id) || form == null) {
            return ActionResult.fail("公式 id 和版本信息不能为空");
        }
        form.setSourceVersionId(trim(form.getSourceVersionId()));
        return ActionResult.success(catalogService.createVersion(id.trim(), form));
    }

    @PutMapping("/versions/{versionId}")
    public ActionResult<ElnFormulaVos.Version> updateVersion(
            @PathVariable("versionId") String versionId,
            @RequestBody(required = false) ElnFormulaForms.UpdateVersion form) {
        if (!StringUtils.hasText(versionId) || form == null) {
            return ActionResult.fail("公式版本 id 和版本信息不能为空");
        }
        trimRule(form);
        return ActionResult.success(catalogService.updateDraft(versionId.trim(), form));
    }

    @PostMapping("/versions/{versionId}/preRelease")
    public ActionResult<Void> preRelease(@PathVariable("versionId") String versionId) {
        if (!StringUtils.hasText(versionId)) {
            return ActionResult.fail("公式版本 id 不能为空");
        }
        catalogService.preRelease(versionId.trim());
        return ActionResult.success();
    }

    @PostMapping("/versions/{versionId}/publish")
    public ActionResult<Void> publish(@PathVariable("versionId") String versionId) {
        if (!StringUtils.hasText(versionId)) {
            return ActionResult.fail("公式版本 id 不能为空");
        }
        catalogService.publish(versionId.trim());
        return ActionResult.success();
    }

    @PostMapping("/versions/{versionId}/cancel")
    public ActionResult<Void> cancel(
            @PathVariable("versionId") String versionId,
            @RequestBody(required = false) ElnFormulaForms.Reason form) {
        if (!StringUtils.hasText(versionId) || !hasReason(form)) {
            return ActionResult.fail("公式版本 id 和操作原因不能为空");
        }
        catalogService.cancel(versionId.trim(), form.getReason().trim());
        return ActionResult.success();
    }

    @PostMapping("/{id}/currentVersion")
    public ActionResult<Void> switchCurrent(
            @PathVariable("id") String id,
            @RequestBody(required = false) ElnFormulaForms.SwitchCurrent form) {
        if (!StringUtils.hasText(id) || form == null || !StringUtils.hasText(form.getVersionId())
                || !StringUtils.hasText(form.getReason())) {
            return ActionResult.fail("公式 id、版本 id 和操作原因不能为空");
        }
        catalogService.switchCurrent(id.trim(), form.getVersionId().trim(), form.getReason().trim());
        return ActionResult.success();
    }

    @PostMapping("/{id}/enable")
    public ActionResult<Void> enable(@PathVariable("id") String id,
                                     @RequestBody(required = false) ElnFormulaForms.Reason form) {
        return changeEnabled(id, form, true);
    }

    @PostMapping("/{id}/disable")
    public ActionResult<Void> disable(@PathVariable("id") String id,
                                      @RequestBody(required = false) ElnFormulaForms.Reason form) {
        return changeEnabled(id, form, false);
    }

    private ActionResult<Void> changeEnabled(String id, ElnFormulaForms.Reason form, boolean enabled) {
        if (!StringUtils.hasText(id) || !hasReason(form)) {
            return ActionResult.fail("公式 id 和操作原因不能为空");
        }
        if (enabled) {
            catalogService.enable(id.trim(), form.getReason().trim());
        } else {
            catalogService.disable(id.trim(), form.getReason().trim());
        }
        return ActionResult.success();
    }

    private static void trimDefinition(ElnFormulaForms.Create form) {
        form.setGongshiMingcheng(trim(form.getGongshiMingcheng()));
        form.setYewuYongtu(trim(form.getYewuYongtu()));
        form.setBeizhu(trim(form.getBeizhu()));
    }

    private static void trimDefinition(ElnFormulaForms.UpdateDefinition form) {
        form.setGongshiMingcheng(trim(form.getGongshiMingcheng()));
        form.setYewuYongtu(trim(form.getYewuYongtu()));
        form.setBeizhu(trim(form.getBeizhu()));
    }

    private static void trimDefinition(ElnFormulaForms.CreateDraft form) {
        form.setGongshiMingcheng(trim(form.getGongshiMingcheng()));
        form.setYewuYongtu(trim(form.getYewuYongtu()));
        form.setBeizhu(trim(form.getBeizhu()));
    }

    private static void trimRule(ElnFormulaForms.VersionRule form) {
        form.setBiaodashi(trim(form.getBiaodashi()));
        form.setJieguoLeixing(trim(form.getJieguoLeixing()));
        form.setXiuyueMoshi(trim(form.getXiuyueMoshi()));
        trimParameters(form.getParameters());
    }

    private static void trimParameters(List<ElnFormulaForms.Parameter> parameters) {
        if (parameters == null) return;
        for (ElnFormulaForms.Parameter parameter : parameters) {
            if (parameter == null) {
                continue;
            }
            parameter.setId(trim(parameter.getId()));
            parameter.setCanshuBianma(trim(parameter.getCanshuBianma()));
            parameter.setCanshuMingcheng(trim(parameter.getCanshuMingcheng()));
            parameter.setShujuLeixing(trim(parameter.getShujuLeixing()));
            parameter.setDanwei(trim(parameter.getDanwei()));
        }
    }

    private static boolean hasReason(ElnFormulaForms.Reason form) {
        return form != null && StringUtils.hasText(form.getReason());
    }

    private static String trim(String value) {
        return value == null ? null : value.trim();
    }
}