package jnpf.elnService.formula;

import jnpf.elnFormula.FormulaAst;
import jnpf.elnFormula.FormulaDiagnostic;
import jnpf.elnFormula.FormulaLatexRenderer;
import jnpf.elnFormula.FormulaType;
import jnpf.elnService.formula.FormulaValidationService.FormulaValidationRequest;
import jnpf.elnService.formula.FormulaValidationService.ParameterSlot;
import jnpf.elnService.formula.FormulaValidationService.ValidationResult;
import jnpf.elnService.formula.impl.FormulaValidationServiceImpl;
import org.junit.Test;

import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Collections;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;

public class FormulaValidationServiceTest {

    private final FormulaValidationService service = new FormulaValidationServiceImpl();

    @Test
    public void reportsUnknownParameterWithExactParameterOffsets() {
        ValidationResult result = validate("1 + missing_a1", slots(), FormulaType.DECIMAL);

        assertError(result, "UNKNOWN_PARAMETER", 4, 14);
        assertNull(result.getLatex());
    }

    @Test
    public void reportsUnknownParameterWithUtf16OffsetsAfterEmoji() {
        ValidationResult result = validate("\"😀\" == \"x\" && missing_a1",
                slots(), FormulaType.BOOLEAN);

        assertError(result, "UNKNOWN_PARAMETER", 15, 25);
    }

    @Test
    public void reportsUnusedParameterAsWarningAndStillRendersLatex() {
        ValidationResult result = validate("sample_a1 / 2",
                slots(slot("sample_a1", "样品质量", FormulaType.DECIMAL),
                        slot("unused_a1", "未使用", FormulaType.TEXT)), FormulaType.DECIMAL);

        assertFalse(result.hasErrors());
        assertDiagnostic(result, FormulaDiagnostic.Severity.WARNING,
                "UNUSED_PARAMETER", -1, -1);
        assertEquals("\\frac{\\text{样品质量}}{2}", result.getLatex());
    }

    @Test
    public void rejectsParameterAndFunctionCodeCollisionCaseInsensitively() {
        ValidationResult result = validate("1", slots(slot("abs", "绝对值参数", FormulaType.DECIMAL)),
                FormulaType.DECIMAL);

        assertError(result, "PARAMETER_FUNCTION_NAME_CONFLICT", -1, -1);
        assertNull(result.getLatex());
    }

    @Test
    public void reportsFunctionArgumentCountWithExactCallOffsets() {
        ValidationResult result = validate("ABS(1, 2)", slots(), FormulaType.DECIMAL);

        assertError(result, "FUNCTION_ARGUMENT_COUNT_MISMATCH", 0, 9);
    }

    @Test
    public void reportsBinaryOperandTypeWithExactExpressionOffsets() {
        ValidationResult result = validate("text_a1 + 1",
                slots(slot("text_a1", "文本", FormulaType.TEXT)), FormulaType.DECIMAL);

        assertError(result, "TYPE_MISMATCH", 0, 11);
    }

    @Test
    public void rejectsMismatchedDeclaredResultType() {
        ValidationResult result = validate("1 > 0", slots(), FormulaType.DECIMAL);

        assertError(result, "RESULT_TYPE_MISMATCH", 0, 5);
        assertEquals(FormulaType.BOOLEAN, result.getInferredType());
    }

    @Test
    public void rejectsNonScalarDeclaredResultTypesBeforeParsing() {
        ValidationResult nullResult = validate("1 +", slots(), FormulaType.NULL);
        ValidationResult listResult = validate("1 +", slots(), FormulaType.DECIMAL_LIST);

        assertError(nullResult, "INVALID_RESULT_TYPE", -1, -1);
        assertError(listResult, "INVALID_RESULT_TYPE", -1, -1);
    }

    @Test
    public void validatesRoundingPairScaleModeAndResultApplicability() {
        assertError(service.validate(request("1", slots(), FormulaType.DECIMAL, 2, null)),
                "INVALID_ROUNDING_CONFIGURATION", -1, -1);
        assertError(service.validate(request("1", slots(), FormulaType.DECIMAL, null, "HALF_UP")),
                "INVALID_ROUNDING_CONFIGURATION", -1, -1);
        assertError(service.validate(request("1", slots(), FormulaType.DECIMAL, -1, "HALF_UP")),
                "INVALID_ROUNDING_SCALE", -1, -1);
        assertError(service.validate(request("1", slots(), FormulaType.DECIMAL, 13, "HALF_UP")),
                "INVALID_ROUNDING_SCALE", -1, -1);
        assertError(service.validate(request("1", slots(), FormulaType.DECIMAL, 2, "CEILING")),
                "UNSUPPORTED_ROUNDING_MODE", -1, -1);
        assertError(service.validate(request("\"text\"", slots(), FormulaType.TEXT, 2, "DOWN")),
                "ROUNDING_NOT_ALLOWED", -1, -1);
        assertError(service.validate(request("true", slots(), FormulaType.BOOLEAN, 0, "UP")),
                "ROUNDING_NOT_ALLOWED", -1, -1);

        ValidationResult valid = service.validate(
                request("1 / 2", slots(), FormulaType.DECIMAL, 2, "HALF_EVEN"));
        assertFalse(valid.hasErrors());
        assertEquals("\\frac{1}{2}", valid.getLatex());
    }

    @Test
    public void reportsSyntaxBeforeRoundingRuleErrors() {
        ValidationResult result = service.validate(
                request("1 +", slots(), FormulaType.DECIMAL, 13, "CEILING"));

        assertError(result, "SYNTAX_ERROR", 3, 3);
        assertEquals(1, result.getDiagnostics().size());
    }

    @Test
    public void validatesRequestAndSlotShapeBeforeParsing() {
        assertError(service.validate(null), "INVALID_REQUEST", -1, -1);
        assertError(validate("   ", slots(), FormulaType.DECIMAL),
                "EXPRESSION_REQUIRED", 0, 3);
        assertError(validate("1 +", null, FormulaType.DECIMAL),
                "PARAMETERS_REQUIRED", -1, -1);
        assertError(validate("1 +", slots(slot("ABS", "参数", FormulaType.DECIMAL)),
                FormulaType.DECIMAL), "INVALID_PARAMETER_CODE", -1, -1);
        assertError(validate("1 +", slots(slot("sample_a1", " ", FormulaType.DECIMAL)),
                FormulaType.DECIMAL), "INVALID_PARAMETER_DISPLAY_NAME", -1, -1);
        assertError(validate("1 +", slots(slot("sample_a1", "参数", FormulaType.NULL)),
                FormulaType.DECIMAL), "INVALID_PARAMETER_TYPE", -1, -1);
        assertError(validate("1 +", slots(slot("sample_a1", "参数1", FormulaType.DECIMAL),
                        slot("sample_a1", "参数2", FormulaType.DECIMAL)), FormulaType.DECIMAL),
                "DUPLICATE_PARAMETER", -1, -1);
    }

    @Test
    public void rejectsAllParserReservedCodesBeforeParsing() {
        for (String code : Arrays.asList(
                "true", "false", "null", "new", "class", "import", "package", "this", "super")) {
            assertError(validate("1 +", slots(slot(code, "参数", FormulaType.DECIMAL)),
                    FormulaType.DECIMAL), "RESERVED_PARAMETER_CODE", -1, -1);
        }
    }

    @Test
    public void escapesAllRequiredLatexCharactersInParameterDisplayNames() {
        ValidationResult result = validate("sample_a1",
                slots(slot("sample_a1", "\\{}_%#&", FormulaType.DECIMAL)), FormulaType.DECIMAL);

        assertFalse(result.hasErrors());
        assertEquals("\\text{\\textbackslash{}\\{\\}\\_\\%\\#\\&}", result.getLatex());
    }

    @Test
    public void rendersControlledFunctionsOperatorsPrecedenceAndSafeStrings() {
        ValidationResult result = validate(
                "IF(sample_a1 > 0 && true, POW(sample_a1 + 1, 2), \"<b>{x}_%#&</b>\")",
                slots(slot("sample_a1", "样品", FormulaType.DECIMAL)), FormulaType.DECIMAL);

        assertError(result, "TYPE_MISMATCH", 0, 66);

        ValidationResult text = validate("\"<b>{x}_%#&</b>\"", slots(), FormulaType.TEXT);
        assertFalse(text.hasErrors());
        assertNotNull(text.getLatex());
        assertFalse(text.getLatex().contains("<b>"));
        assertFalse(text.getLatex().contains("</b>"));
        assertTrue(text.getLatex().contains("\\textless{}"));
        assertTrue(text.getLatex().contains("\\{x\\}\\_\\%\\#\\&"));

        ValidationResult arithmetic = validate("1 + 2 * 3 ^ 4", slots(), FormulaType.DECIMAL);
        assertEquals("1 + 2 \\cdot 3^{4}", arithmetic.getLatex());

        ValidationResult function = validate("ABS(-1)", slots(), FormulaType.DECIMAL);
        assertEquals("\\left|-1\\right|", function.getLatex());
    }

    @Test
    public void rendersStandardMathematicalFunctionSymbols() {
        java.util.List<ParameterSlot> scalar = slots(
                slot("sample_a1", "样品", FormulaType.DECIMAL));
        java.util.List<ParameterSlot> list = slots(
                slot("values_a1", "重复测定值", FormulaType.DECIMAL_LIST));

        assertLatex("SQRT(sample_a1)", scalar, "\\sqrt{\\text{样品}}");
        assertLatex("POW(sample_a1 + 1, 2)", scalar,
                "\\left(\\text{样品} + 1\\right)^{2}");
        assertLatex("NTH_ROOT(8, 3)", slots(), "\\sqrt[3]{8}");
        assertLatex("LN(sample_a1)", scalar, "\\ln\\left(\\text{样品}\\right)");
        assertLatex("LOG10(sample_a1)", scalar,
                "\\log_{10}\\left(\\text{样品}\\right)");
        assertLatex("LOG(sample_a1, 2)", scalar,
                "\\log_{2}\\left(\\text{样品}\\right)");
        assertLatex("EXP(sample_a1)", scalar, "e^{\\text{样品}}");
        assertLatex("MIN(1, 2)", slots(), "\\min\\left(1, 2\\right)");
        assertLatex("MAX(1, 2)", slots(), "\\max\\left(1, 2\\right)");
        assertLatex("SUM(values_a1)", list,
                "\\sum\\left(\\text{重复测定值}\\right)");
        assertLatex("MEAN(values_a1)", list, "\\overline{\\text{重复测定值}}");
        assertLatex("STDDEV_S(values_a1)", list,
                "s\\left(\\text{重复测定值}\\right)");
        assertLatex("STDDEV_P(values_a1)", list,
                "\\sigma\\left(\\text{重复测定值}\\right)");
        assertLatex("VAR_S(values_a1)", list,
                "s^{2}\\left(\\text{重复测定值}\\right)");
        assertLatex("VAR_P(values_a1)", list,
                "\\sigma^{2}\\left(\\text{重复测定值}\\right)");
    }

    @Test
    public void preservesGroupingInNestedMathematicalFunctions() {
        java.util.List<ParameterSlot> scalar = slots(
                slot("sample_a1", "样品", FormulaType.DECIMAL));

        assertLatex("POW(sample_a1 + 1, NTH_ROOT(8, 3))", scalar,
                "\\left(\\text{样品} + 1\\right)^{\\sqrt[3]{8}}");
        assertLatex("LOG(EXP(sample_a1), 10)", scalar,
                "\\log_{10}\\left(e^{\\text{样品}}\\right)");
    }

    @Test
    public void preservesLeftNestedEqualityGrouping() {
        ValidationResult equal = validate("(true == false) == false", slots(), FormulaType.BOOLEAN);
        assertEquals("\\left(\\mathrm{true} = \\mathrm{false}\\right) = \\mathrm{false}",
                equal.getLatex());

        ValidationResult mixed = validate("(true != false) == true", slots(), FormulaType.BOOLEAN);
        assertEquals("\\left(\\mathrm{true} \\ne \\mathrm{false}\\right) = \\mathrm{true}",
                mixed.getLatex());
    }

    @Test
    public void neverEmitsDangerousLatexCommandsOrRawHtml() {
        ValidationResult result = validate("payload_a1",
                slots(slot("payload_a1", "\\href{a}{b}<img>", FormulaType.TEXT)), FormulaType.TEXT);

        assertFalse(result.hasErrors());
        assertFalse(result.getLatex().contains("\\href"));
        assertFalse(result.getLatex().contains("\\html"));
        assertFalse(result.getLatex().contains("\\include"));
        assertFalse(result.getLatex().contains("<img>"));
    }

    @Test
    public void rendererRejectsFunctionNamesOutsideRegistry() {
        FormulaAst.FunctionCall call = new FormulaAst.FunctionCall(0, 1,
                "X}\\href{javascript:1}{x}\\operatorname{Y", Collections.<FormulaAst.Node>emptyList());

        assertRendererRejected(call);
    }

    @Test
    public void rendererRejectsUnknownUnaryAndBinaryOperators() {
        FormulaAst.Literal one = new FormulaAst.Literal(
                0, 1, FormulaAst.LiteralKind.DECIMAL, BigDecimal.ONE);

        assertRendererRejected(new FormulaAst.Unary(0, 1, "~", one));
        assertRendererRejected(new FormulaAst.Binary(0, 1, "\\href", one, one));
    }

    @Test
    public void syntaxFailureDoesNotReuseLatexFromPreviousRequest() {
        ValidationResult valid = validate("1 / 2", slots(), FormulaType.DECIMAL);
        assertEquals("\\frac{1}{2}", valid.getLatex());

        ValidationResult invalid = validate("1 +", slots(), FormulaType.DECIMAL);
        assertError(invalid, "SYNTAX_ERROR", 3, 3);
        assertNull(invalid.getLatex());
    }

    private ValidationResult validate(String expression, java.util.List<ParameterSlot> parameters,
                                      FormulaType resultType) {
        return service.validate(request(expression, parameters, resultType, null, null));
    }

    private static FormulaValidationRequest request(String expression,
                                                    java.util.List<ParameterSlot> parameters,
                                                    FormulaType resultType,
                                                    Integer scale, String mode) {
        return new FormulaValidationRequest(expression, parameters, resultType, scale, mode);
    }

    private static ParameterSlot slot(String code, String displayName, FormulaType type) {
        return new ParameterSlot(code, displayName, type);
    }

    private static java.util.List<ParameterSlot> slots(ParameterSlot... values) {
        return values.length == 0 ? Collections.<ParameterSlot>emptyList() : Arrays.asList(values);
    }

    private static void assertError(ValidationResult result, String code, int start, int end) {
        assertTrue("expected error " + code, result.hasErrors());
        assertDiagnostic(result, FormulaDiagnostic.Severity.ERROR, code, start, end);
        assertNull(result.getLatex());
    }

    private static void assertDiagnostic(ValidationResult result,
                                         FormulaDiagnostic.Severity severity,
                                         String code, int start, int end) {
        for (FormulaDiagnostic diagnostic : result.getDiagnostics()) {
            if (diagnostic.getSeverity() == severity && code.equals(diagnostic.getCode())) {
                assertEquals(start, diagnostic.getStart());
                assertEquals(end, diagnostic.getEnd());
                assertNotNull(diagnostic.getMessage());
                return;
            }
        }
        throw new AssertionError("missing diagnostic " + severity + " " + code);
    }

    private static void assertRendererRejected(FormulaAst.Node node) {
        try {
            new FormulaLatexRenderer().render(node, Collections.<String, String>emptyMap());
            throw new AssertionError("expected renderer rejection");
        } catch (IllegalArgumentException expected) {
            assertNotNull(expected.getMessage());
        }
    }

    private void assertLatex(String expression, java.util.List<ParameterSlot> parameters,
                             String expected) {
        ValidationResult result = validate(expression, parameters, FormulaType.DECIMAL);
        String diagnostics = result.getDiagnostics().isEmpty() ? ""
                : result.getDiagnostics().get(0).getCode() + ": "
                + result.getDiagnostics().get(0).getMessage() + " @"
                + result.getDiagnostics().get(0).getStart() + ".."
                + result.getDiagnostics().get(0).getEnd();
        assertFalse(diagnostics, result.hasErrors());
        assertEquals(expected, result.getLatex());
    }
}