package jnpf.elnService.formula.impl;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.node.DoubleNode;
import com.fasterxml.jackson.databind.node.FloatNode;
import jnpf.elnEntity.formula.ElnFormulaForms;
import jnpf.elnEntity.formula.ElnFormulaVos;
import jnpf.elnFormula.FormulaAst;
import jnpf.elnFormula.FormulaDiagnostic;
import jnpf.elnFormula.FormulaEvaluator;
import jnpf.elnFormula.FormulaException;
import jnpf.elnFormula.FormulaFunction;
import jnpf.elnFormula.FormulaFunctionRegistry;
import jnpf.elnFormula.FormulaLimits;
import jnpf.elnFormula.FormulaParser;
import jnpf.elnFormula.FormulaType;
import jnpf.elnFormula.FormulaValue;
import jnpf.elnService.formula.FormulaPreviewService;
import jnpf.elnService.formula.FormulaValidationService;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Pattern;

@Service
public class FormulaPreviewServiceImpl implements FormulaPreviewService {

    private static final Pattern DECIMAL = Pattern.compile("[+-]?[0-9]+(?:\\.[0-9]+)?");

    private final FormulaValidationService validationService;
    private final FormulaFunctionRegistry functions;
    private final FormulaParser parser;
    private final FormulaEvaluator evaluator;

    public FormulaPreviewServiceImpl(FormulaValidationService validationService) {
        this.validationService = validationService;
        this.functions = new FormulaFunctionRegistry();
        this.parser = new FormulaParser();
        this.evaluator = new FormulaEvaluator(functions);
    }

    @Override
    public List<FormulaFunction> functions() {
        return functions.catalog();
    }

    @Override
    public FormulaValidationService.ValidationResult validate(ElnFormulaForms.Validate form) {
        return validateRule(form);
    }

    @Override
    public ElnFormulaVos.Preview preview(ElnFormulaForms.Preview form) {
        FormulaValidationService.ValidationResult validation = validateRule(form);
        if (validation.hasErrors()) {
            return result("ERROR", null, null, validation.getDiagnostics(), validation.getLatex());
        }

        List<FormulaDiagnostic> diagnostics = new ArrayList<>(validation.getDiagnostics());
        Map<String, JsonNode> inputs = form.getInputs() == null
                ? Collections.<String, JsonNode>emptyMap() : form.getInputs();
        Set<String> declaredCodes = new LinkedHashSet<>();
        for (ElnFormulaForms.Parameter parameter : form.getParameters()) {
            declaredCodes.add(parameter.getCanshuBianma());
        }
        for (String inputCode : inputs.keySet()) {
            if (!declaredCodes.contains(inputCode)) {
                diagnostics.add(error("UNKNOWN_INPUT", "未知参数输入: " + inputCode, -1, -1));
            }
        }
        if (hasErrors(diagnostics)) {
            return result("ERROR", null, null, diagnostics, validation.getLatex());
        }

        Map<String, FormulaValue> values = new LinkedHashMap<>();
        for (ElnFormulaForms.Parameter parameter : form.getParameters()) {
            String code = parameter.getCanshuBianma();
            JsonNode input = inputs.get(code);
            if (!inputs.containsKey(code) || isMissing(input)) {
                if (parameter.getShifouBitian() == null || parameter.getShifouBitian() == 1) {
                    diagnostics.add(error("MISSING_INPUT", "缺少必填参数值: " + code, -1, -1));
                } else {
                    values.put(code, FormulaValue.nullValue(code));
                }
                continue;
            }
            try {
                values.put(code, convert(input, formulaType(parameter.getShujuLeixing()), code));
            } catch (InputException ex) {
                diagnostics.add(error(ex.code, ex.getMessage(), -1, -1));
            }
        }
        if (hasErrors(diagnostics)) {
            String status = hasOnlyMissingErrors(diagnostics) ? "MISSING_INPUT" : "ERROR";
            return result(status, null, null, diagnostics, validation.getLatex());
        }

        FormulaValue raw;
        try {
            FormulaAst.Node ast = parser.parse(form.getBiaodashi());
            raw = evaluator.evaluate(ast, values);
        } catch (FormulaException ex) {
            diagnostics.add(error(ex.getCode(), ex.getMessage(),
                    ex.getStartOffset(), ex.getEndOffset()));
            String status = "MISSING_INPUT".equals(ex.getCode()) ? "MISSING_INPUT" : "ERROR";
            return result(status, null, null, diagnostics, validation.getLatex());
        }
        if (raw.isNull()) {
            diagnostics.add(error("MISSING_INPUT", "公式结果为空", -1, -1));
            return result("MISSING_INPUT", null, null, diagnostics, validation.getLatex());
        }

        FormulaValue rounded = raw;
        if (form.getXiuyueXiaoshuWei() != null) {
            rounded = evaluator.round(raw, form.getXiuyueXiaoshuWei(),
                    RoundingMode.valueOf(form.getXiuyueMoshi()));
        }
        return result("SUCCESS", value(raw), value(rounded), diagnostics, validation.getLatex());
    }

    private FormulaValidationService.ValidationResult validateRule(
            ElnFormulaForms.VersionRule form) {
        FormulaValidationService.ValidationResult validation = form == null
                ? validationService.validate(null)
                : validationService.validate(toValidationRequest(form));
        if (form == null || form.getParameters() == null) {
            return validation;
        }
        List<FormulaDiagnostic> diagnostics = new ArrayList<>(validation.getDiagnostics());
        for (ElnFormulaForms.Parameter parameter : form.getParameters()) {
            if (parameter == null) {
                continue;
            }
            Integer required = parameter.getShifouBitian();
            if (required == null || (required != 0 && required != 1)) {
                diagnostics.add(error("INVALID_PARAMETER_REQUIRED_FLAG",
                        "参数必填标志只能是 0 或 1: " + parameter.getCanshuBianma(), -1, -1));
            }
        }
        String latex = hasErrors(diagnostics) ? null : validation.getLatex();
        if (diagnostics.size() == validation.getDiagnostics().size()
                && latex == validation.getLatex()) {
            return validation;
        }
        return new FormulaValidationService.ValidationResult(diagnostics,
                latex, validation.getInferredType());
    }

    private static FormulaValidationService.FormulaValidationRequest toValidationRequest(
            ElnFormulaForms.VersionRule form) {
        List<FormulaValidationService.ParameterSlot> slots = null;
        if (form.getParameters() != null) {
            slots = new ArrayList<>();
            for (ElnFormulaForms.Parameter parameter : form.getParameters()) {
                if (parameter == null) {
                    slots.add(null);
                } else {
                    slots.add(new FormulaValidationService.ParameterSlot(
                            parameter.getCanshuBianma(), parameter.getCanshuMingcheng(),
                            formulaType(parameter.getShujuLeixing())));
                }
            }
        }
        return new FormulaValidationService.FormulaValidationRequest(
                form.getBiaodashi(), slots, formulaType(form.getJieguoLeixing()),
                form.getXiuyueXiaoshuWei(), form.getXiuyueMoshi());
    }

    private static FormulaType formulaType(String value) {
        if (value == null) {
            return null;
        }
        try {
            return FormulaType.valueOf(value);
        } catch (IllegalArgumentException ex) {
            return null;
        }
    }

    private static boolean isMissing(JsonNode input) {
        return input == null || input.isNull()
                || (input.isTextual() && input.textValue().isEmpty());
    }

    private static FormulaValue convert(JsonNode input, FormulaType type, String code) {
        if (type == FormulaType.DECIMAL) {
            return FormulaValue.decimal(decimal(input, code));
        }
        if (type == FormulaType.DECIMAL_LIST) {
            if (!input.isArray()) {
                throw inputError("INVALID_INPUT_TYPE", code, "必须是数值数组");
            }
            if (input.size() > FormulaLimits.DEFAULTS.getMaxListItems()) {
                throw inputError("LIST_ITEM_LIMIT_EXCEEDED", code, "数值列表最多 1000 项");
            }
            List<FormulaValue> values = new ArrayList<>(input.size());
            for (JsonNode item : input) {
                values.add(FormulaValue.decimal(decimal(item, code)));
            }
            return FormulaValue.decimalList(values);
        }
        if (type == FormulaType.TEXT) {
            if (!input.isTextual()) {
                throw inputError("INVALID_INPUT_TYPE", code, "必须是文本");
            }
            return FormulaValue.text(input.textValue());
        }
        if (type == FormulaType.BOOLEAN) {
            if (!input.isBoolean()) {
                throw inputError("INVALID_INPUT_TYPE", code, "必须是布尔值");
            }
            return FormulaValue.bool(input.booleanValue());
        }
        throw inputError("INVALID_INPUT_TYPE", code, "参数类型不支持试算");
    }

    private static BigDecimal decimal(JsonNode input, String code) {
        String source;
        if (input.isNumber()) {
            if (input instanceof FloatNode || input instanceof DoubleNode) {
                double value = input.doubleValue();
                if (Double.isNaN(value) || Double.isInfinite(value)) {
                    throw inputError("INVALID_DECIMAL_INPUT", code, "不是有限十进制数");
                }
            }
            source = input instanceof ElnFormulaForms.InputDecimalNode
                    ? ((ElnFormulaForms.InputDecimalNode) input).getSource()
                    : input.toString();
        } else if (input.isTextual()) {
            source = input.textValue();
        } else {
            throw inputError("INVALID_INPUT_TYPE", code, "必须是十进制数或十进制字符串");
        }
        if (source.length() > FormulaLimits.DEFAULTS.getMaxExpressionLength()) {
            throw inputError("DECIMAL_INPUT_TOO_LONG", code, "十进制数长度超过限制");
        }
        if (!DECIMAL.matcher(source).matches()) {
            throw inputError("INVALID_DECIMAL_INPUT", code, "十进制格式不正确");
        }
        return new BigDecimal(source);
    }

    private static Object value(FormulaValue value) {
        if (value.getType() == FormulaType.DECIMAL) {
            return value.getDecimal();
        }
        if (value.getType() == FormulaType.TEXT) {
            return value.getText();
        }
        if (value.getType() == FormulaType.BOOLEAN) {
            return value.getBoolean();
        }
        return null;
    }

    private static ElnFormulaVos.Preview result(String status, Object raw, Object rounded,
                                                 List<FormulaDiagnostic> diagnostics,
                                                 String latex) {
        ElnFormulaVos.Preview result = new ElnFormulaVos.Preview();
        result.setStatus(status);
        result.setRawResult(raw);
        result.setRoundedResult(rounded);
        result.setLatex(latex);
        for (FormulaDiagnostic diagnostic : diagnostics) {
            ElnFormulaVos.Diagnostic item = new ElnFormulaVos.Diagnostic();
            item.setSeverity(diagnostic.getSeverity().name());
            item.setCode(diagnostic.getCode());
            item.setMessage(diagnostic.getMessage());
            item.setStart(diagnostic.getStart());
            item.setEnd(diagnostic.getEnd());
            result.getDiagnostics().add(item);
        }
        return result;
    }

    private static FormulaDiagnostic error(String code, String message, int start, int end) {
        return new FormulaDiagnostic(FormulaDiagnostic.Severity.ERROR, code, message, start, end);
    }

    private static boolean hasErrors(List<FormulaDiagnostic> diagnostics) {
        for (FormulaDiagnostic diagnostic : diagnostics) {
            if (diagnostic.getSeverity() == FormulaDiagnostic.Severity.ERROR) {
                return true;
            }
        }
        return false;
    }

    private static boolean hasOnlyMissingErrors(List<FormulaDiagnostic> diagnostics) {
        for (FormulaDiagnostic diagnostic : diagnostics) {
            if (diagnostic.getSeverity() == FormulaDiagnostic.Severity.ERROR
                    && !"MISSING_INPUT".equals(diagnostic.getCode())) {
                return false;
            }
        }
        return true;
    }

    private static InputException inputError(String code, String slotCode, String message) {
        return new InputException(code, "参数 " + slotCode + " " + message);
    }

    private static final class InputException extends RuntimeException {
        private final String code;

        private InputException(String code, String message) {
            super(message);
            this.code = code;
        }
    }
}