package jnpf.elnService.formula;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.BooleanNode;
import com.fasterxml.jackson.databind.node.DecimalNode;
import com.fasterxml.jackson.databind.node.JsonNodeFactory;
import com.fasterxml.jackson.databind.node.NullNode;
import com.fasterxml.jackson.databind.node.TextNode;
import jnpf.elnEntity.formula.ElnFormulaForms;
import jnpf.elnEntity.formula.ElnFormulaVos;
import jnpf.elnFormula.FormulaDiagnostic;
import jnpf.elnFormula.FormulaLimits;
import jnpf.elnService.formula.impl.FormulaPreviewServiceImpl;
import jnpf.elnService.formula.impl.FormulaValidationServiceImpl;
import org.junit.Before;
import org.junit.Test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

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

public class FormulaPreviewServiceTest {

    private FormulaPreviewService service;

    @Before
    public void setUp() {
        service = new FormulaPreviewServiceImpl(new FormulaValidationServiceImpl());
    }

    @Test
    public void exposesFixedFunctionCatalogAndFullValidation() {
        assertEquals(37, service.functions().size());
        assertEquals("ABS", service.functions().get(0).getCode());
        assertEquals("DECIMAL", service.functions().get(0).getReturnType());
        assertEquals("DYNAMIC", service.functions().get(5).getReturnType());
        assertEquals("DYNAMIC", service.functions().get(6).getReturnType());
        assertEquals("BOOLEAN", service.functions().get(7).getReturnType());
        assertEquals("LOOKUP_LINEAR", service.functions().get(17).getCode());
        assertEquals("DECIMAL", service.functions().get(17).getReturnType());

        ElnFormulaForms.Validate form = validateForm("amount + 1", "DECIMAL",
                slot("amount", "金额", "DECIMAL", true));
        FormulaValidationService.ValidationResult result = service.validate(form);

        assertFalse(result.hasErrors());
        assertEquals("\\text{金额} + 1", result.getLatex());
    }

    @Test
    public void dependsOnlyOnValidationAndInMemoryFormulaEngine() {
        for (Field field : FormulaPreviewServiceImpl.class.getDeclaredFields()) {
            assertNotPersistenceOrAuditDependency(field.getType());
        }
        for (Constructor<?> constructor : FormulaPreviewServiceImpl.class.getDeclaredConstructors()) {
            for (Class<?> parameterType : constructor.getParameterTypes()) {
                assertNotPersistenceOrAuditDependency(parameterType);
            }
        }
    }

    @Test
    public void validationAndPreviewDoNotMutateOrRetainRequestData() {
        ElnFormulaForms.Validate validation = validateForm(
                "amount + 1", "DECIMAL", slot("amount", "金额", "DECIMAL", true));
        String validationExpression = validation.getBiaodashi();
        List<ElnFormulaForms.Parameter> validationParameters = validation.getParameters();
        JsonNode validationSlots = snapshotSlots(validationParameters);

        service.validate(validation);

        assertEquals(validationExpression, validation.getBiaodashi());
        assertSame(validationParameters, validation.getParameters());
        assertEquals(validationSlots, snapshotSlots(validation.getParameters()));

        ElnFormulaForms.Preview preview = previewForm(
                "amount + SUM(values)", "DECIMAL",
                slot("amount", "金额", "DECIMAL", true),
                slot("values", "结果集", "DECIMAL_LIST", true));
        preview.getInputs().put("amount", new TextNode("1.25"));
        ArrayNode values = JsonNodeFactory.instance.arrayNode();
        values.add(new BigDecimal("1"));
        values.add(new BigDecimal("2"));
        preview.getInputs().put("values", values);
        String previewExpression = preview.getBiaodashi();
        List<ElnFormulaForms.Parameter> previewParameters = preview.getParameters();
        JsonNode previewSlots = snapshotSlots(previewParameters);
        Map<String, JsonNode> previewInputs = preview.getInputs();
        Map<String, JsonNode> inputSnapshot = copyInputs(previewInputs);

        assertEquals(new BigDecimal("4.25"), service.preview(preview).getRawResult());

        assertEquals(previewExpression, preview.getBiaodashi());
        assertSame(previewParameters, preview.getParameters());
        assertEquals(previewSlots, snapshotSlots(preview.getParameters()));
        assertSame(previewInputs, preview.getInputs());
        assertEquals(inputSnapshot, preview.getInputs());

        ElnFormulaForms.Preview next = previewForm(
                "amount + SUM(values)", "DECIMAL",
                slot("amount", "金额", "DECIMAL", true),
                slot("values", "结果集", "DECIMAL_LIST", true));
        next.getInputs().put("amount", new TextNode("7"));
        ArrayNode nextValues = JsonNodeFactory.instance.arrayNode();
        nextValues.add(new BigDecimal("3"));
        next.getInputs().put("values", nextValues);

        assertEquals(new BigDecimal("10"), service.preview(next).getRawResult());
        assertEquals(inputSnapshot, preview.getInputs());
    }

    @Test
    public void previewsStrictInputsAndAppliesConfiguredRounding() {
        ElnFormulaForms.Preview form = previewForm(
                "amount + SUM(values)", "DECIMAL",
                slot("amount", "金额", "DECIMAL", true),
                slot("values", "结果集", "DECIMAL_LIST", true));
        form.setXiuyueXiaoshuWei(2);
        form.setXiuyueMoshi("HALF_UP");
        form.getInputs().put("amount", new TextNode("1.005"));
        ArrayNode values = JsonNodeFactory.instance.arrayNode();
        values.add(new BigDecimal("1.11"));
        values.add("2.22");
        form.getInputs().put("values", values);

        ElnFormulaVos.Preview result = service.preview(form);

        assertEquals("SUCCESS", result.getStatus());
        assertEquals(new BigDecimal("4.335"), result.getRawResult());
        assertEquals(new BigDecimal("4.34"), result.getRoundedResult());
        assertTrue(result.getDiagnostics().isEmpty());
        assertTrue(result.getLatex().contains("金额"));
    }

    @Test
    public void acceptsOnlyExactTextAndBooleanJsonTypes() {
        ElnFormulaForms.Preview text = previewForm("label", "TEXT",
                slot("label", "标签", "TEXT", true));
        text.getInputs().put("label", new TextNode("合格"));
        assertEquals("合格", service.preview(text).getRawResult());

        ElnFormulaForms.Preview bool = previewForm("flag", "BOOLEAN",
                slot("flag", "标志", "BOOLEAN", true));
        bool.getInputs().put("flag", BooleanNode.TRUE);
        assertEquals(Boolean.TRUE, service.preview(bool).getRawResult());

        text.getInputs().put("label", BooleanNode.TRUE);
        assertError(service.preview(text), "INVALID_INPUT_TYPE");
        bool.getInputs().put("flag", new TextNode("true"));
        assertError(service.preview(bool), "INVALID_INPUT_TYPE");
    }

    @Test
    public void rejectsUnknownScientificNonFiniteAndOversizedInputs() {
        ElnFormulaForms.Preview decimal = previewForm("amount", "DECIMAL",
                slot("amount", "金额", "DECIMAL", true));
        decimal.getInputs().put("other", DecimalNode.valueOf(BigDecimal.ONE));
        assertError(service.preview(decimal), "UNKNOWN_INPUT");

        decimal.getInputs().clear();
        decimal.getInputs().put("amount", new TextNode("1e3"));
        assertError(service.preview(decimal), "INVALID_DECIMAL_INPUT");

        decimal.getInputs().put("amount", JsonNodeFactory.instance.numberNode(Double.NaN));
        assertError(service.preview(decimal), "INVALID_DECIMAL_INPUT");

        decimal.getInputs().put("amount", JsonNodeFactory.instance.numberNode(Double.POSITIVE_INFINITY));
        assertError(service.preview(decimal), "INVALID_DECIMAL_INPUT");

        ElnFormulaForms.Preview list = previewForm("SUM(values)", "DECIMAL",
                slot("values", "结果集", "DECIMAL_LIST", true));
        ArrayNode values = JsonNodeFactory.instance.arrayNode();
        for (int i = 0; i < 1001; i++) {
            values.add(i);
        }
        list.getInputs().put("values", values);
        assertError(service.preview(list), "LIST_ITEM_LIMIT_EXCEEDED");
    }

    @Test
    public void rejectsScientificJsonNumberAfterRequestDeserialization() throws Exception {
        String json = "{\"biaodashi\":\"amount\",\"jieguoLeixing\":\"DECIMAL\","
                + "\"parameters\":[{\"canshuBianma\":\"amount\","
                + "\"canshuMingcheng\":\"金额\",\"shujuLeixing\":\"DECIMAL\","
                + "\"shifouBitian\":1}],\"inputs\":{\"amount\":1e3}}";

        ElnFormulaForms.Preview form = new ObjectMapper()
                .readValue(json, ElnFormulaForms.Preview.class);

        assertError(service.preview(form), "INVALID_DECIMAL_INPUT");
    }

    @Test
    public void rejectsScientificListItemsAfterRequestDeserialization() throws Exception {
        String json = "{\"biaodashi\":\"SUM(values)\",\"jieguoLeixing\":\"DECIMAL\","
                + "\"parameters\":[{\"canshuBianma\":\"values\","
                + "\"canshuMingcheng\":\"结果集\",\"shujuLeixing\":\"DECIMAL_LIST\","
                + "\"shifouBitian\":1}],\"inputs\":{\"values\":[1,1e3,\"2e2\"]}}";

        ElnFormulaForms.Preview form = new ObjectMapper()
                .readValue(json, ElnFormulaForms.Preview.class);

        assertError(service.preview(form), "INVALID_DECIMAL_INPUT");

        ElnFormulaForms.Preview stringItem = new ObjectMapper().readValue(
                json.replace("[1,1e3,\"2e2\"]", "[1,\"2e2\"]"),
                ElnFormulaForms.Preview.class);
        assertError(service.preview(stringItem), "INVALID_DECIMAL_INPUT");
    }

    @Test
    public void rejectsNegativeExponentJsonNumbersAfterRequestDeserialization() throws Exception {
        String scalarJson = "{\"biaodashi\":\"amount\",\"jieguoLeixing\":\"DECIMAL\","
                + "\"parameters\":[{\"canshuBianma\":\"amount\","
                + "\"canshuMingcheng\":\"金额\",\"shujuLeixing\":\"DECIMAL\","
                + "\"shifouBitian\":1}],\"inputs\":{\"amount\":1E-3}}";
        String listJson = "{\"biaodashi\":\"SUM(values)\",\"jieguoLeixing\":\"DECIMAL\","
                + "\"parameters\":[{\"canshuBianma\":\"values\","
                + "\"canshuMingcheng\":\"结果集\",\"shujuLeixing\":\"DECIMAL_LIST\","
                + "\"shifouBitian\":1}],\"inputs\":{\"values\":[1,1E-3]}}";

        ObjectMapper mapper = new ObjectMapper();
        assertError(service.preview(mapper.readValue(scalarJson, ElnFormulaForms.Preview.class)),
                "INVALID_DECIMAL_INPUT");
        assertError(service.preview(mapper.readValue(listJson, ElnFormulaForms.Preview.class)),
                "INVALID_DECIMAL_INPUT");
    }

    @Test
    public void acceptsPlainJsonNumbersAndStringsAfterRequestDeserialization() throws Exception {
        String json = "{\"biaodashi\":\"amount + SUM(values)\","
                + "\"jieguoLeixing\":\"DECIMAL\",\"parameters\":["
                + "{\"canshuBianma\":\"amount\",\"canshuMingcheng\":\"金额\","
                + "\"shujuLeixing\":\"DECIMAL\",\"shifouBitian\":1},"
                + "{\"canshuBianma\":\"values\",\"canshuMingcheng\":\"结果集\","
                + "\"shujuLeixing\":\"DECIMAL_LIST\",\"shifouBitian\":1}],"
                + "\"inputs\":{\"amount\":1.25,\"values\":[1,2.5,\"3.25\"]}}";

        ElnFormulaForms.Preview form = new ObjectMapper()
                .readValue(json, ElnFormulaForms.Preview.class);

        assertEquals(new BigDecimal("8.00"), service.preview(form).getRawResult());

        ElnFormulaForms.Preview plainSmall = new ObjectMapper().readValue(
                json.replace("1.25", "0.001"), ElnFormulaForms.Preview.class);
        assertEquals(new BigDecimal("6.751"), service.preview(plainSmall).getRawResult());
    }

    @Test
    public void acceptsLargeFinitePlainJsonNumberLikeEquivalentString() throws Exception {
        String digits = repeat('9', 309);
        String prefix = "{\"biaodashi\":\"amount\",\"jieguoLeixing\":\"DECIMAL\","
                + "\"parameters\":[{\"canshuBianma\":\"amount\","
                + "\"canshuMingcheng\":\"金额\",\"shujuLeixing\":\"DECIMAL\","
                + "\"shifouBitian\":1}],\"inputs\":{\"amount\":";
        ObjectMapper mapper = new ObjectMapper();
        ElnFormulaVos.Preview numberResult = service.preview(mapper.readValue(
                prefix + digits + "}}", ElnFormulaForms.Preview.class));
        ElnFormulaVos.Preview stringResult = service.preview(mapper.readValue(
                prefix + "\"" + digits + "\"}}", ElnFormulaForms.Preview.class));

        assertEquals("SUCCESS", numberResult.getStatus());
        assertEquals("SUCCESS", stringResult.getStatus());
        assertEquals(stringResult.getRawResult(), numberResult.getRawResult());
    }

    @Test
    public void rejectsDecimalLexemesLongerThanExpressionLimit() {
        String digits = repeat('7', FormulaLimits.DEFAULTS.getMaxExpressionLength() + 1);
        ElnFormulaForms.Preview scalar = previewForm("amount", "DECIMAL",
                slot("amount", "金额", "DECIMAL", true));

        scalar.getInputs().put("amount", new TextNode(digits));
        assertError(service.preview(scalar), "DECIMAL_INPUT_TOO_LONG");

        scalar.getInputs().put("amount", DecimalNode.valueOf(new BigDecimal(digits)));
        assertError(service.preview(scalar), "DECIMAL_INPUT_TOO_LONG");

        ElnFormulaForms.Preview list = previewForm("SUM(values)", "DECIMAL",
                slot("values", "结果集", "DECIMAL_LIST", true));
        ArrayNode values = JsonNodeFactory.instance.arrayNode();
        values.add(digits);
        list.getInputs().put("values", values);
        assertError(service.preview(list), "DECIMAL_INPUT_TOO_LONG");
    }

    @Test
    public void doesNotTurnJsonNumberIntoTextDuringRequestDeserialization() throws Exception {
        String json = "{\"biaodashi\":\"label\",\"jieguoLeixing\":\"TEXT\","
                + "\"parameters\":[{\"canshuBianma\":\"label\","
                + "\"canshuMingcheng\":\"标签\",\"shujuLeixing\":\"TEXT\","
                + "\"shifouBitian\":1}],\"inputs\":{\"label\":1.25}}";

        ElnFormulaForms.Preview form = new ObjectMapper()
                .readValue(json, ElnFormulaForms.Preview.class);

        assertError(service.preview(form), "INVALID_INPUT_TYPE");
    }

    @Test
    public void reportsRequiredNullAndBlankInputsAsMissing() {
        ElnFormulaForms.Preview form = previewForm("amount", "DECIMAL",
                slot("amount", "金额", "DECIMAL", true));
        assertMissing(service.preview(form), "amount");

        form.getInputs().put("amount", NullNode.instance);
        assertMissing(service.preview(form), "amount");

        form.getInputs().put("amount", new TextNode(""));
        assertMissing(service.preview(form), "amount");
    }

    @Test
    public void optionalMissingInputCanBeHandledByCoalesceOrShortCircuit() {
        ElnFormulaForms.Preview coalesce = previewForm("COALESCE(amount, 2)", "DECIMAL",
                slot("amount", "金额", "DECIMAL", false));
        assertEquals(new BigDecimal("2"), service.preview(coalesce).getRawResult());

        ElnFormulaForms.Preview branch = previewForm("IF(false, amount, 3)", "DECIMAL",
                slot("amount", "金额", "DECIMAL", false));
        assertEquals(new BigDecimal("3"), service.preview(branch).getRawResult());
    }

    @Test
    public void reportsOptionalNullWhenEvaluatedOrReturned() {
        ElnFormulaForms.Preview evaluated = previewForm("amount + 1", "DECIMAL",
                slot("amount", "金额", "DECIMAL", false));
        assertMissing(service.preview(evaluated), "amount");

        ElnFormulaForms.Preview returned = previewForm("COALESCE(amount)", "DECIMAL",
                slot("amount", "金额", "DECIMAL", false));
        assertMissing(service.preview(returned), "结果为空");
    }

    @Test
    public void reportsOnlyActuallyAccessedOptionalMissingInputs() {
        ElnFormulaForms.Preview form = previewForm("amount + 1", "DECIMAL",
                slot("amount", "金额", "DECIMAL", false),
                slot("unused", "未使用", "DECIMAL", false));

        ElnFormulaVos.Preview result = service.preview(form);

        assertEquals("MISSING_INPUT", result.getStatus());
        int missingDiagnostics = 0;
        for (ElnFormulaVos.Diagnostic diagnostic : result.getDiagnostics()) {
            if ("MISSING_INPUT".equals(diagnostic.getCode())) {
                missingDiagnostics++;
                assertTrue(diagnostic.getMessage().contains("amount"));
                assertFalse(diagnostic.getMessage().contains("unused"));
            }
        }
        assertEquals(1, missingDiagnostics);
    }

    @Test
    public void reportsOnlyRightMissingInputWhenLeftCoalesceHasFallback() {
        ElnFormulaForms.Preview form = previewForm("COALESCE(a, 1) + b", "DECIMAL",
                slot("a", "参数 A", "DECIMAL", false),
                slot("b", "参数 B", "DECIMAL", false));
        assertOnlyMissing(service.preview(form), "b", "a");
    }

    @Test
    public void reportsOnlyLeftMissingInputWhenRightCoalesceHasFallback() {
        ElnFormulaForms.Preview form = previewForm("a + COALESCE(b, 1)", "DECIMAL",
                slot("a", "参数 A", "DECIMAL", false),
                slot("b", "参数 B", "DECIMAL", false));
        assertOnlyMissing(service.preview(form), "a", "b");
    }

    @Test
    public void rejectsInvalidRequiredFlagsDuringValidation() {
        for (Integer flag : Arrays.asList(null, 2, -1)) {
            ElnFormulaForms.Parameter parameter = slot("amount", "金额", "DECIMAL", true);
            parameter.setShifouBitian(flag);
            FormulaValidationService.ValidationResult result = service.validate(
                    validateForm("amount + 1", "DECIMAL", parameter));

            assertValidationDiagnostic(result, "INVALID_PARAMETER_REQUIRED_FLAG");
            assertNull(result.getLatex());
        }
    }

    @Test
    public void rejectsInvalidRequiredFlagsBeforePreviewEvaluation() {
        for (Integer flag : Arrays.asList(null, 2, -1)) {
            ElnFormulaForms.Parameter parameter = slot("amount", "金额", "DECIMAL", true);
            parameter.setShifouBitian(flag);
            ElnFormulaForms.Preview form = previewForm(
                    "COALESCE(amount, 2)", "DECIMAL", parameter);

            ElnFormulaVos.Preview result = service.preview(form);
            assertError(result, "INVALID_PARAMETER_REQUIRED_FLAG");
            assertNull(result.getLatex());
        }
    }

    @Test
    public void stopsAtFullValidationBeforeInspectingInputs() {
        ElnFormulaForms.Preview form = previewForm("unknown +", "DECIMAL");
        form.getInputs().put("unexpected", DecimalNode.valueOf(BigDecimal.ONE));

        ElnFormulaVos.Preview result = service.preview(form);

        assertEquals("ERROR", result.getStatus());
        assertDiagnostic(result.getDiagnostics(), "SYNTAX_ERROR");
        assertFalse(hasDiagnostic(result.getDiagnostics(), "UNKNOWN_INPUT"));
        assertNull(result.getRawResult());
        assertNull(result.getRoundedResult());
    }

    private static ElnFormulaForms.Validate validateForm(String expression, String resultType,
                                                          ElnFormulaForms.Parameter... slots) {
        ElnFormulaForms.Validate form = new ElnFormulaForms.Validate();
        setRule(form, expression, resultType, slots);
        return form;
    }

    private static ElnFormulaForms.Preview previewForm(String expression, String resultType,
                                                        ElnFormulaForms.Parameter... slots) {
        ElnFormulaForms.Preview form = new ElnFormulaForms.Preview();
        setRule(form, expression, resultType, slots);
        form.setInputs(new LinkedHashMap<String, JsonNode>());
        return form;
    }

    private static void setRule(ElnFormulaForms.VersionRule form, String expression,
                                String resultType, ElnFormulaForms.Parameter... slots) {
        form.setBiaodashi(expression);
        form.setJieguoLeixing(resultType);
        form.setParameters(Arrays.asList(slots));
    }

    private static ElnFormulaForms.Parameter slot(String code, String name, String type,
                                                   boolean required) {
        ElnFormulaForms.Parameter slot = new ElnFormulaForms.Parameter();
        slot.setCanshuBianma(code);
        slot.setCanshuMingcheng(name);
        slot.setShujuLeixing(type);
        slot.setShifouBitian(required ? 1 : 0);
        return slot;
    }

    private static JsonNode snapshotSlots(List<ElnFormulaForms.Parameter> slots) {
        return new ObjectMapper().valueToTree(slots);
    }

    private static Map<String, JsonNode> copyInputs(Map<String, JsonNode> inputs) {
        Map<String, JsonNode> copy = new LinkedHashMap<>();
        for (Map.Entry<String, JsonNode> entry : inputs.entrySet()) {
            copy.put(entry.getKey(), entry.getValue() == null ? null : entry.getValue().deepCopy());
        }
        return copy;
    }

    private static String repeat(char value, int count) {
        char[] values = new char[count];
        Arrays.fill(values, value);
        return new String(values);
    }

    private static void assertNotPersistenceOrAuditDependency(Class<?> type) {
        String typeName = type.getName();
        assertFalse("不允许持久化或审计依赖: " + typeName,
                typeName.contains("elnMapper")
                        || typeName.contains("BaseMapper")
                        || typeName.contains("AuditClient")
                        || typeName.contains("CatalogService"));
    }

    private static void assertError(ElnFormulaVos.Preview result, String diagnosticCode) {
        assertEquals("ERROR", result.getStatus());
        assertNull(result.getRawResult());
        assertNull(result.getRoundedResult());
        assertDiagnostic(result.getDiagnostics(), diagnosticCode);
    }

    private static void assertMissing(ElnFormulaVos.Preview result, String expectedText) {
        assertEquals("MISSING_INPUT", result.getStatus());
        assertNull(result.getRawResult());
        assertNull(result.getRoundedResult());
        for (ElnFormulaVos.Diagnostic diagnostic : result.getDiagnostics()) {
            if (diagnostic.getMessage().contains(expectedText)) {
                return;
            }
        }
        throw new AssertionError("缺少包含文本的诊断: " + expectedText);
    }

    private static void assertOnlyMissing(ElnFormulaVos.Preview result, String expectedCode,
                                          String unexpectedCode) {
        assertEquals("MISSING_INPUT", result.getStatus());
        int missingDiagnostics = 0;
        for (ElnFormulaVos.Diagnostic diagnostic : result.getDiagnostics()) {
            if ("MISSING_INPUT".equals(diagnostic.getCode())) {
                missingDiagnostics++;
                assertTrue(diagnostic.getMessage().contains(expectedCode));
                assertFalse(diagnostic.getMessage().contains(unexpectedCode));
            }
        }
        assertEquals(1, missingDiagnostics);
    }

    private static void assertDiagnostic(List<ElnFormulaVos.Diagnostic> diagnostics, String code) {
        assertTrue("缺少诊断 " + code, hasDiagnostic(diagnostics, code));
    }

    private static void assertValidationDiagnostic(
            FormulaValidationService.ValidationResult result, String code) {
        for (FormulaDiagnostic diagnostic : result.getDiagnostics()) {
            if (code.equals(diagnostic.getCode())) {
                return;
            }
        }
        throw new AssertionError("缺少诊断 " + code);
    }

    private static boolean hasDiagnostic(List<ElnFormulaVos.Diagnostic> diagnostics, String code) {
        for (ElnFormulaVos.Diagnostic diagnostic : diagnostics) {
            if (code.equals(diagnostic.getCode())) {
                return true;
            }
        }
        return false;
    }
}