package gudusoft.gsqlparser.lineage.v2;

import gudusoft.gsqlparser.lineage.v2.json.CanonicalJson;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * The SQL-LR data files this library ships: the lineage document schema, the core registry, the
 * qualification profiles, the dependency snapshots and the identifier rule sets, at their
 * {@code lineage-spec/} paths under {@value #BASE}.
 *
 * <p>A jar cannot list a directory, so {@code resources.sha256} (in {@code sha256sum} format) lists every
 * file with its SHA-256 digest. A file is served only when it is listed, and only when its bytes have that
 * digest. Each file is parsed once with {@link CanonicalJson#parse(byte[])} into an unmodifiable value
 * that every caller shares.</p>
 *
 * @since 4.2.17
 */
public final class SqllrResources {

    /** The classpath directory of the shipped files. */
    public static final String BASE = "/gudusoft/gsqlparser/lineage/v2/";

    /** The index file, relative to {@link #BASE}. */
    public static final String INDEX = "resources.sha256";

    public static final String LINEAGE_DOCUMENT_SCHEMA = "schema/0.1/lineage-document.schema.json";
    public static final String CORE_REGISTRY = "registry/core-registry.json";
    public static final String QUALIFICATION_PROFILES = "registry/qualification-profiles.json";

    private static final Map<String, Object> PARSED = new ConcurrentHashMap<String, Object>();

    private SqllrResources() {
    }

    /** Every shipped file (path relative to {@link #BASE}) with its lowercase hexadecimal SHA-256. */
    public static Map<String, String> index() {
        return Index.ENTRIES;
    }

    private static final class Index {
        static final Map<String, String> ENTRIES = load();

        private static Map<String, String> load() {
            String text = new String(read(INDEX), StandardCharsets.UTF_8);
            Map<String, String> entries = new LinkedHashMap<String, String>();
            for (String line : text.split("\n")) {
                if (line.trim().isEmpty()) {
                    continue;
                }
                int space = line.indexOf("  ");
                if (space != 64) {
                    throw new IllegalStateException("malformed line in " + INDEX + ": " + line);
                }
                entries.put(line.substring(space + 2).trim(), line.substring(0, space));
            }
            return Collections.unmodifiableMap(entries);
        }
    }

    /**
     * The bytes of a shipped file.
     *
     * @param path a path of {@link #index()}, such as {@code registry/core-registry.json}
     * @throws IllegalArgumentException when the file is not listed
     * @throws IllegalStateException    when the file is missing or its digest differs from the index
     */
    public static byte[] bytes(String path) {
        String expected = index().get(path);
        if (expected == null) {
            throw new IllegalArgumentException("not a shipped SQL-LR resource: " + path);
        }
        byte[] data = read(path);
        String actual = sha256Hex(data);
        if (!actual.equals(expected)) {
            throw new IllegalStateException("SQL-LR resource " + path + " has sha256 " + actual + ", the index says "
                    + expected);
        }
        return data;
    }

    /** A shipped file parsed under the input rules of {@code canonical-json-v1}; shared, do not modify. */
    public static Object json(String path) {
        Object value = PARSED.get(path);
        if (value != null) {
            return value;
        }
        synchronized (PARSED) {
            value = PARSED.get(path);
            if (value == null) {
                value = CanonicalJson.immutableCopy(CanonicalJson.parse(bytes(path)));
                PARSED.put(path, value);
            }
            return value;
        }
    }

    /** {@code schema/0.1/lineage-document.schema.json}. */
    public static Object lineageDocumentSchema() {
        return json(LINEAGE_DOCUMENT_SCHEMA);
    }

    /** {@code registry/core-registry.json}. */
    public static Object coreRegistry() {
        return json(CORE_REGISTRY);
    }

    /** {@code registry/qualification-profiles.json}. */
    public static Object qualificationProfiles() {
        return json(QUALIFICATION_PROFILES);
    }

    /** The identifier rule set {@code identifier-rules/<dialect>/rules-<version>.json}. */
    public static Object identifierRules(String dialect, int ruleSetVersion) {
        return json("identifier-rules/" + dialect + "/rules-" + ruleSetVersion + ".json");
    }

    /** The lowercase hexadecimal SHA-256 of {@code data}. */
    public static String sha256Hex(byte[] data) {
        byte[] digest;
        try {
            digest = MessageDigest.getInstance("SHA-256").digest(data);
        } catch (NoSuchAlgorithmException e) {
            throw new IllegalStateException(e);
        }
        StringBuilder out = new StringBuilder(64);
        for (byte b : digest) {
            out.append(Character.forDigit((b >> 4) & 0xf, 16)).append(Character.forDigit(b & 0xf, 16));
        }
        return out.toString();
    }

    private static byte[] read(String path) {
        InputStream in = SqllrResources.class.getResourceAsStream(BASE + path);
        if (in == null) {
            throw new IllegalStateException("missing SQL-LR resource " + BASE + path);
        }
        try {
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            byte[] buffer = new byte[8192];
            int n;
            while ((n = in.read(buffer)) >= 0) {
                out.write(buffer, 0, n);
            }
            return out.toByteArray();
        } catch (IOException e) {
            throw new IllegalStateException("cannot read SQL-LR resource " + BASE + path, e);
        } finally {
            try {
                in.close();
            } catch (IOException ignored) {
                // nothing to do
            }
        }
    }
}