package gudusoft.gsqlparser.lineage.v2.validation;

import gudusoft.gsqlparser.lineage.v2.CoreRegistry;
import gudusoft.gsqlparser.lineage.v2.Finding;
import gudusoft.gsqlparser.lineage.v2.SqllrException;
import gudusoft.gsqlparser.lineage.v2.json.CanonicalJson;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Deque;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Validation stage {@code SCHEMA} (specification Section 14.2), as the reference runner implements it
 * ({@code conformance/run.py}, {@code stage_schema}):
 * <ol>
 *   <li>the strict reader of {@code canonical-json-v1} ({@code SCHEMA_INVALID_JSON},
 *       {@code SCHEMA_DUPLICATE_KEY}, {@code SCHEMA_NON_INTEGER_NUMBER});</li>
 *   <li>the version gates: a {@code specVersion} of another major.minor is
 *       {@code VERSION_UNSUPPORTED_SPEC_VERSION}; a {@code header.registryVersion} at or above the supported
 *       range is {@code VERSION_REGISTRY_TOO_NEW};</li>
 *   <li>the JSON Schema: a value outside an enum that names a registry group, and that the group does not
 *       list, is {@code SCHEMA_UNKNOWN_CODE}; any other schema error is {@code SCHEMA_VIOLATION};</li>
 *   <li>the array registry in strict mode: an unregistered array is {@code SCHEMA_VIOLATION}; a SET holding
 *       equal elements or a SEQUENCE with broken ordinals ({@code SEMANTIC_ARRAY_KIND_VIOLATION}) is deferred
 *       to stage {@code SEMANTIC};</li>
 *   <li>canonical order: a SET array out of its registered order is {@code SCHEMA_NOT_CANONICAL}.</li>
 * </ol>
 * The stage reports the findings of the first step that has any.
 *
 * @since 4.2.17
 */
public final class SchemaStage {

    /** The supported specification major.minor. */
    private static final int[] SUPPORTED_SPEC = {0, 1};
    /** The supported registry range: at least the first, below the second. */
    private static final String[] SUPPORTED_REGISTRY = {"0.1.0-draft", "0.2.0"};

    private static final Pattern SEMVER = Pattern.compile(
            "^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)(?:-([0-9A-Za-z.-]+))?$", Pattern.UNIX_LINES);
    private static final Pattern REGISTRY_GROUP = Pattern.compile("Registry group '([A-Za-z]+)'");

    /** The outcome of the stage. */
    public static final class Result {
        private final Object document;
        private final List<Finding> findings;
        private final List<Finding> deferred;

        Result(Object document, List<Finding> findings, List<Finding> deferred) {
            this.document = document;
            this.findings = Collections.unmodifiableList(findings);
            this.deferred = Collections.unmodifiableList(deferred);
        }

        /** The parsed document, or null when the bytes are not JSON the reader accepts. */
        public Object getDocument() {
            return document;
        }

        /** The findings of the stage; empty when the document passes it. */
        public List<Finding> getFindings() {
            return findings;
        }

        /** Findings this stage detected that belong to stage {@code SEMANTIC}. */
        public List<Finding> getDeferred() {
            return deferred;
        }
    }

    private final SchemaValidator validator;
    private final CoreRegistry registry;

    public SchemaStage(SchemaValidator validator, CoreRegistry registry) {
        this.validator = validator;
        this.registry = registry;
    }

    /** The stage with the shipped schema and registry. */
    public static SchemaStage standard() {
        return new SchemaStage(SchemaValidator.lineageDocument(), CoreRegistry.standard());
    }

    public Result run(byte[] data) {
        List<Finding> deferred = new ArrayList<Finding>();
        Object doc;
        try {
            doc = CanonicalJson.parse(data);
        } catch (SqllrException e) {
            return new Result(null, list(new Finding(e.getCode(), "$", e.getDetail())), deferred);
        }
        if (!(doc instanceof Map<?, ?>)) {
            return new Result(doc, list(new Finding("SCHEMA_VIOLATION", "$", "the document is not a JSON object")), deferred);
        }
        Map<?, ?> map = (Map<?, ?>) doc;
        List<Finding> findings = new ArrayList<Finding>();
        Object specVersion = map.get("specVersion");
        if (specVersion instanceof String) {
            List<Object> key = semverKey((String) specVersion);
            if (key != null && (!key.get(0).equals(java.math.BigInteger.valueOf(SUPPORTED_SPEC[0]))
                    || !key.get(1).equals(java.math.BigInteger.valueOf(SUPPORTED_SPEC[1])))) {
                findings.add(new Finding("VERSION_UNSUPPORTED_SPEC_VERSION", "$.specVersion", (String) specVersion));
            }
        }
        Object header = map.get("header");
        Object registryVersion = header instanceof Map<?, ?> ? ((Map<?, ?>) header).get("registryVersion") : null;
        if (registryVersion instanceof String) {
            List<Object> key = semverKey((String) registryVersion);
            if (key != null && SEMVER_ORDER.compare(key, semverKey(SUPPORTED_REGISTRY[1])) >= 0) {
                findings.add(new Finding("VERSION_REGISTRY_TOO_NEW", "$.header.registryVersion", (String) registryVersion));
            }
        }
        if (!findings.isEmpty()) {
            return new Result(doc, findings, deferred);
        }
        List<SchemaValidator.SchemaError> errors = validator.errors(doc);
        if (!errors.isEmpty()) {
            return new Result(doc, list(classify(errors)), deferred);
        }
        Object canonical;
        try {
            canonical = CanonicalJson.canonicalizeDocument(doc, true);
        } catch (SqllrException e) {
            if (CanonicalJson.SEMANTIC_ARRAY_KIND_VIOLATION.equals(e.getCode())) {
                deferred.add(new Finding(e.getCode(), "$", e.getDetail()));
                return new Result(doc, findings, deferred);
            }
            return new Result(doc, list(new Finding(e.getCode(), "$", e.getDetail())), deferred);
        }
        String where = firstDifference(doc, canonical);
        if (where != null) {
            findings.add(new Finding("SCHEMA_NOT_CANONICAL", where, "a SET array is not in its registered canonical order"));
        }
        return new Result(doc, findings, deferred);
    }

    private static List<Finding> list(Finding finding) {
        List<Finding> out = new ArrayList<Finding>();
        out.add(finding);
        return out;
    }

    /**
     * The finding the stage reports for schema errors: {@code SCHEMA_UNKNOWN_CODE} when an enum naming a
     * registry group rejects a string the group lacks (anywhere in the error tree), else {@code SCHEMA_VIOLATION}.
     */
    public Finding classify(List<SchemaValidator.SchemaError> errors) {
        List<Finding> unknown = new ArrayList<Finding>();
        Deque<SchemaValidator.SchemaError> stack = new ArrayDeque<SchemaValidator.SchemaError>(errors);
        while (!stack.isEmpty()) {
            SchemaValidator.SchemaError error = stack.pop();
            stack.addAll(error.getContext());
            if (!"enum".equals(error.getKeyword()) || !(error.getInstance() instanceof String)) {
                continue;
            }
            Object description = error.getSchema().get("description");
            Matcher matcher = description instanceof String ? REGISTRY_GROUP.matcher((String) description) : null;
            if (matcher != null && matcher.find() && !registry.group(matcher.group(1)).contains(error.getInstance())) {
                unknown.add(new Finding("SCHEMA_UNKNOWN_CODE", location(error.getPath()),
                        error.getInstance() + " is not a code of registry group " + matcher.group(1)));
            }
        }
        if (!unknown.isEmpty()) {
            Collections.sort(unknown, new Comparator<Finding>() {
                @Override
                public int compare(Finding a, Finding b) {
                    int c = a.getLocation().compareTo(b.getLocation());
                    return c != 0 ? c : a.getDetail().compareTo(b.getDetail());
                }
            });
            return unknown.get(0);
        }
        SchemaValidator.SchemaError first = errors.get(0);
        for (SchemaValidator.SchemaError error : errors) {
            if (pathOrder(error.getPath(), first.getPath()) < 0) {
                first = error;
            }
        }
        return new Finding("SCHEMA_VIOLATION", location(first.getPath()), first.toString());
    }

    private static int pathOrder(List<Object> a, List<Object> b) {
        for (int i = 0; i < Math.min(a.size(), b.size()); i++) {
            int c = String.valueOf(a.get(i)).compareTo(String.valueOf(b.get(i)));
            if (c != 0) {
                return c;
            }
        }
        return a.size() - b.size();
    }

    private static String location(List<Object> path) {
        StringBuilder out = new StringBuilder("$");
        for (Object step : path) {
            out.append(step instanceof String ? "['" + step + "']" : "[" + step + "]");
        }
        return out.toString();
    }

    /** Semantic Versioning 2.0.0 precedence as a comparable list, or null when the text is not a version. */
    static List<Object> semverKey(String text) {
        Matcher m = SEMVER.matcher(text);
        if (!m.lookingAt()) {
            return null;
        }
        List<Object> key = new ArrayList<Object>();
        for (int i = 1; i <= 3; i++) {
            key.add(new java.math.BigInteger(m.group(i)));
        }
        String pre = m.group(4);
        List<Object> tail = new ArrayList<Object>();
        if (pre == null) {
            tail.add(java.math.BigInteger.ONE);
        } else {
            tail.add(java.math.BigInteger.ZERO);
            for (String part : pre.split("\\.", -1)) {
                if (!part.isEmpty() && part.matches("[0-9]+")) {
                    tail.add(Arrays.<Object>asList(java.math.BigInteger.ZERO, new java.math.BigInteger(part), ""));
                } else {
                    tail.add(Arrays.<Object>asList(java.math.BigInteger.ONE, java.math.BigInteger.ZERO, part));
                }
            }
        }
        key.add(tail);
        return key;
    }

    /** Lexicographic order of the keys above, as Python compares tuples. */
    static final Comparator<Object> SEMVER_ORDER = new Comparator<Object>() {
        @Override
        @SuppressWarnings({"unchecked", "rawtypes"})
        public int compare(Object a, Object b) {
            if (a instanceof List && b instanceof List) {
                List<?> x = (List<?>) a;
                List<?> y = (List<?>) b;
                for (int i = 0; i < Math.min(x.size(), y.size()); i++) {
                    int c = compare(x.get(i), y.get(i));
                    if (c != 0) {
                        return c;
                    }
                }
                return x.size() - y.size();
            }
            return ((Comparable) a).compareTo(b);
        }
    };

    /**
     * Where {@code doc} first differs from its canonical form, or null ({@code run.py}, {@code first_difference}):
     * members in the document's order, the first differing element of an array, and the array itself when the
     * element holds no deeper difference. Members whose canonical bytes are equal hold no difference and are
     * skipped, so the walk follows differing values only.
     */
    static String firstDifference(Object doc, Object canonical) {
        return difference(doc, canonical, "$");
    }

    private static boolean sameBytes(Object a, Object b) {
        return java.util.Arrays.equals(CanonicalJson.jcsBytes(a), CanonicalJson.jcsBytes(b));
    }

    private static String difference(Object a, Object b, String path) {
        if (a instanceof Map<?, ?> && b instanceof Map<?, ?>) {
            for (Map.Entry<?, ?> entry : ((Map<?, ?>) a).entrySet()) {
                Object other = ((Map<?, ?>) b).get(entry.getKey());
                if (sameBytes(entry.getValue(), other)) {
                    continue;
                }
                String found = difference(entry.getValue(), other, path + "." + entry.getKey());
                if (found != null) {
                    return found;
                }
            }
            return null;
        }
        if (a instanceof List<?> && b instanceof List<?>) {
            List<?> x = (List<?>) a;
            List<?> y = (List<?>) b;
            if (x.size() != y.size()) {
                return path;
            }
            for (int i = 0; i < x.size(); i++) {
                if (!sameBytes(x.get(i), y.get(i))) {
                    String here = path + "[" + i + "]";
                    String inner = difference(x.get(i), y.get(i), here);
                    return inner != null && !inner.equals(here) ? inner : path;
                }
            }
            return null;
        }
        return sameBytes(a, b) ? null : path;
    }
}