package jnpf.elnFormula;

import jnpf.util.JsonUtil;
import org.junit.Test;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.math.RoundingMode;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.fail;

public class FormulaSystemExamplesTest {

    private final FormulaParser parser = new FormulaParser();
    private final FormulaFunctionRegistry functions = new FormulaFunctionRegistry();
    private final FormulaTypeChecker typeChecker = new FormulaTypeChecker(functions);
    private final FormulaEvaluator evaluator = new FormulaEvaluator(functions);

    @Test
    public void evaluatesSystemExamplesAndStableFailures() throws Exception {
        List<Example> examples = loadExamples();
        assertEquals(25, examples.size());

        for (Example example : examples) {
            try {
                FormulaAst.Node ast = parser.parse(example.expression);
                Map<String, FormulaType> slots = slotTypes(example.slots);
                typeChecker.check(ast, slots);
                FormulaValue raw = evaluator.evaluate(ast, inputValues(example.inputs, slots));
                FormulaValue rounded = example.roundScale == null ? raw
                        : evaluator.round(raw, example.roundScale,
                        RoundingMode.valueOf(example.roundMode));
                if (example.errorCode != null) {
                    fail(example.name + " expected error " + example.errorCode);
                }
                assertEquals(example.name, example.expectedRaw, raw.toPlainString());
                assertEquals(example.name, example.expectedRounded == null
                        ? example.expectedRaw : example.expectedRounded, rounded.toPlainString());
            } catch (FormulaParser.ParseException ex) {
                assertError(example, ex.getCode());
            } catch (FormulaException ex) {
                assertError(example, ex.getCode());
            }
        }
    }

    @Test
    public void exposesStableFunctionCatalog() {
        assertEquals(asList("ABS", "POW", "SQRT", "MIN", "MAX", "IF", "COALESCE", "IS_BLANK",
                        "SUM", "MEAN", "STDDEV_S", "RSD", "ROUND", "ROUND_UP", "ROUND_DOWN",
                        "CONVERT", "LOOKUP_EXACT", "LOOKUP_LINEAR",
                        "LN", "LOG10", "LOG", "EXP", "NTH_ROOT",
                        "COUNT", "MEDIAN", "STDDEV_P", "VAR_S", "VAR_P", "GEOMEAN",
                        "WEIGHTED_MEAN", "SLOPE", "INTERCEPT", "CORREL", "LINEAR_PREDICT",
                        "ROUND_HALF_EVEN", "ROUND_SIG", "ROUND_SIG_HALF_EVEN"),
                functions.codes());
        for (FormulaFunction function : functions.catalog()) {
            assertNotNull(function.getChineseName());
            assertNotNull(function.getCategory());
            assertNotNull(function.getSignature());
            assertNotNull(function.getDescription());
            assertNotNull(function.getExample());
        }
    }

    private static void assertError(Example example, String actualCode) {
        if (example.errorCode == null) {
            fail(example.name + " unexpected error " + actualCode);
        }
        assertEquals(example.name, example.errorCode, actualCode);
    }

    private static Map<String, FormulaType> slotTypes(Map<String, String> values) {
        Map<String, FormulaType> result = new LinkedHashMap<>();
        for (Map.Entry<String, String> entry : values.entrySet()) {
            result.put(entry.getKey(), FormulaType.valueOf(entry.getValue()));
        }
        return result;
    }

    private static Map<String, FormulaValue> inputValues(Map<String, Object> values,
                                                          Map<String, FormulaType> slots) {
        Map<String, FormulaValue> result = new LinkedHashMap<>();
        for (Map.Entry<String, Object> entry : values.entrySet()) {
            FormulaType type = slots.get(entry.getKey());
            Object value = entry.getValue();
            if (value == null) {
                result.put(entry.getKey(), FormulaValue.nullValue());
            } else if (type == FormulaType.DECIMAL) {
                result.put(entry.getKey(), FormulaValue.decimal(value.toString()));
            } else if (type == FormulaType.DECIMAL_LIST) {
                List<FormulaValue> items = new ArrayList<>();
                for (Object item : (List<?>) value) {
                    items.add(FormulaValue.decimal(item.toString()));
                }
                result.put(entry.getKey(), FormulaValue.decimalList(items));
            } else if (type == FormulaType.BOOLEAN) {
                result.put(entry.getKey(), FormulaValue.bool(Boolean.parseBoolean(value.toString())));
            } else {
                result.put(entry.getKey(), FormulaValue.text(value.toString()));
            }
        }
        return result;
    }

    private static List<Example> loadExamples() throws IOException {
        InputStream input = FormulaSystemExamplesTest.class.getResourceAsStream(
                "/formula/system-examples.json");
        assertNotNull(input);
        try {
            ByteArrayOutputStream output = new ByteArrayOutputStream();
            byte[] buffer = new byte[4096];
            int read;
            while ((read = input.read(buffer)) >= 0) {
                output.write(buffer, 0, read);
            }
            return JsonUtil.getJsonToList(new String(output.toByteArray(), StandardCharsets.UTF_8),
                    Example.class);
        } finally {
            input.close();
        }
    }

    private static List<String> asList(String... values) {
        List<String> result = new ArrayList<>();
        Collections.addAll(result, values);
        return result;
    }

    public static class Example {
        public String name;
        public String expression;
        public Map<String, String> slots = new LinkedHashMap<>();
        public Map<String, Object> inputs = new LinkedHashMap<>();
        public Integer roundScale;
        public String roundMode;
        public String expectedRaw;
        public String expectedRounded;
        public String errorCode;
    }
}