package gudusoft.gsqlparser.lineage.v2.producer;

import java.nio.ByteBuffer;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.CodingErrorAction;
import java.nio.charset.StandardCharsets;

import gudusoft.gsqlparser.lineage.v2.SqllrResources;

/**
 * One source unit given to the SQL-LR producer: its identity and its text (specification Section 7.8).
 *
 * <ul>
 *   <li>{@code NAMED}: the caller names the unit by {@code namespace} + {@code logicalName} (for example a repository
 *   and a path relative to it). This is the portable identity; the content digest only identifies the version.</li>
 *   <li>{@code CONTENT_ADDRESSED}: the caller declares that within {@code contextDomain} equal content is one
 *   unit (for example entries of a query log).</li>
 *   <li>{@code LOCAL}: everything else, such as an unnamed file; valid only within the document. A producer never
 *   makes an unnamed file content-addressed by itself.</li>
 * </ul>
 *
 * <p>The text is analysed exactly as decoded: no character is replaced, a byte order mark is removed and declared
 * ({@code BOM_STRIPPED}), and line endings are kept ({@code PRESERVED}). Two inputs with equal text remain two
 * units. Immutable.</p>
 *
 * @since 4.2.17
 */
public final class SqllrInput {

    public static final String NAMED = "NAMED";
    public static final String CONTENT_ADDRESSED = "CONTENT_ADDRESSED";
    public static final String LOCAL = "LOCAL";

    private final String identityKind;
    private final String namespace;
    private final String logicalName;
    private final String contextDomain;
    private final String text;
    private final byte[] rawBytes;
    private final String bom;

    private SqllrInput(String identityKind, String namespace, String logicalName, String contextDomain, String text,
            byte[] rawBytes, String bom) {
        this.identityKind = identityKind;
        this.namespace = namespace;
        this.logicalName = logicalName;
        this.contextDomain = contextDomain;
        this.text = text;
        this.rawBytes = rawBytes;
        this.bom = bom;
    }

    /**
     * A named unit from already-decoded text that is the whole content of the source, with no byte order mark
     * ({@code NO_BOM}); no raw-bytes digest is published. Use {@link #named(String, String, String, String)} when
     * the caller removed a byte order mark while decoding.
     */
    public static SqllrInput named(String namespace, String logicalName, String text) {
        return named(namespace, logicalName, text, "NO_BOM");
    }

    /**
     * A named unit from already-decoded text, declaring how a byte order mark was handled: {@code NO_BOM} (the raw
     * bytes had none) or {@code BOM_STRIPPED} (the caller removed one; it is not part of the text).
     */
    public static SqllrInput named(String namespace, String logicalName, String text, String bom) {
        checkNamespace(namespace);
        checkLogicalName(logicalName);
        return new SqllrInput(NAMED, namespace, logicalName, null, checkText(text), null, checkBom(bom));
    }

    /** A named unit from UTF-8 bytes; a leading byte order mark is removed and declared. */
    public static SqllrInput named(String namespace, String logicalName, byte[] utf8) {
        checkNamespace(namespace);
        checkLogicalName(logicalName);
        return fromBytes(NAMED, namespace, logicalName, null, utf8);
    }

    /** A content-addressed unit: the caller declares that equal content within the domain is one unit. */
    public static SqllrInput contentAddressed(String contextDomain, String text) {
        checkName("contextDomain", contextDomain);
        return new SqllrInput(CONTENT_ADDRESSED, null, null, contextDomain, checkText(text), null, "NO_BOM");
    }

    /** A unit with no identity beyond the document; the text is the whole content, with no byte order mark. */
    public static SqllrInput local(String text) {
        return new SqllrInput(LOCAL, null, null, null, checkText(text), null, "NO_BOM");
    }

    /** A unit with no identity beyond the document, declaring the byte order mark handling. */
    public static SqllrInput local(String text, String bom) {
        return new SqllrInput(LOCAL, null, null, null, checkText(text), null, checkBom(bom));
    }

    /** A unit with no identity beyond the document, from UTF-8 bytes. */
    public static SqllrInput local(byte[] utf8) {
        return fromBytes(LOCAL, null, null, null, utf8);
    }

    private static SqllrInput fromBytes(String kind, String namespace, String logicalName, String domain, byte[] utf8) {
        if (utf8 == null) {
            throw new IllegalArgumentException("no bytes");
        }
        byte[] raw = utf8.clone();
        int start = 0;
        String bom = "NO_BOM";
        if (raw.length >= 3 && (raw[0] & 0xFF) == 0xEF && (raw[1] & 0xFF) == 0xBB && (raw[2] & 0xFF) == 0xBF) {
            start = 3;
            bom = "BOM_STRIPPED";
        }
        String text;
        try {
            text = StandardCharsets.UTF_8.newDecoder().onMalformedInput(CodingErrorAction.REPORT)
                    .onUnmappableCharacter(CodingErrorAction.REPORT)
                    .decode(ByteBuffer.wrap(raw, start, raw.length - start)).toString();
        } catch (CharacterCodingException e) {
            throw new SqllrProducerException("PRODUCER_INVALID_INPUT", "the input is not valid UTF-8", e);
        }
        return new SqllrInput(kind, namespace, logicalName, domain, text, raw, bom);
    }

    private static String checkText(String text) {
        if (text == null) {
            throw new IllegalArgumentException("no text");
        }
        for (int i = 0; i < text.length(); i++) {
            char c = text.charAt(i);
            if (Character.isHighSurrogate(c) && i + 1 < text.length() && Character.isLowSurrogate(text.charAt(i + 1))) {
                i++;
            } else if (Character.isSurrogate(c)) {
                throw new SqllrProducerException("PRODUCER_INVALID_INPUT", "text has an unpaired surrogate at " + i);
            }
        }
        if (!text.isEmpty() && text.charAt(0) == '') {
            throw new SqllrProducerException("PRODUCER_INVALID_INPUT",
                    "decoded text starts with U+FEFF; give the raw bytes so the byte order mark is declared");
        }
        return text;
    }

    private static String checkBom(String bom) {
        if (!"NO_BOM".equals(bom) && !"BOM_STRIPPED".equals(bom)) {
            throw new SqllrProducerException("PRODUCER_INVALID_INPUT", "bom must be NO_BOM or BOM_STRIPPED, not " + bom);
        }
        return bom;
    }

    /**
     * A namespace names a repository or similar logical source, never a place on a disk (specification Section
     * 7.8): an absolute path, a drive, a backslash or a {@code file:} URI is refused.
     */
    static void checkNamespace(String namespace) {
        checkName("namespace", namespace);
        if (isLocalLocator(namespace)) {
            throw new SqllrProducerException("PRODUCER_INVALID_INPUT", "namespace must be a logical name, not a local "
                    + "path: " + namespace);
        }
    }

    private static boolean isLocalLocator(String value) {
        String lower = value.toLowerCase(java.util.Locale.ROOT);
        return value.startsWith("/") || value.startsWith("~") || value.indexOf('\\') >= 0
                || (value.length() >= 2 && value.charAt(1) == ':' && Character.isLetter(value.charAt(0)))
                || lower.startsWith("file:");
    }

    private static void checkName(String what, String value) {
        if (value == null || value.isEmpty()) {
            throw new SqllrProducerException("PRODUCER_INVALID_INPUT", what + " is empty");
        }
    }

    /**
     * The rules the M1 source-text reader applies to a logical name, plus the ones that keep local paths out of
     * an identity: relative, '/'-separated, no empty, '.' or '..' segment, no trailing '/', no backslash, no drive.
     */
    static void checkLogicalName(String name) {
        checkName("logicalName", name);
        if (isLocalLocator(name) || name.endsWith("/") || name.matches("^[A-Za-z][A-Za-z0-9+.-]*:.*")) {
            throw new SqllrProducerException("PRODUCER_INVALID_INPUT", "logicalName must be a relative path: " + name);
        }
        for (String segment : name.split("/", -1)) {
            if (segment.isEmpty() || ".".equals(segment) || "..".equals(segment)) {
                throw new SqllrProducerException("PRODUCER_INVALID_INPUT", "logicalName has an empty, '.' or '..' "
                        + "segment: " + name);
            }
        }
    }

    public String getIdentityKind() {
        return identityKind;
    }

    public String getNamespace() {
        return namespace;
    }

    public String getLogicalName() {
        return logicalName;
    }

    public String getContextDomain() {
        return contextDomain;
    }

    /** The decoded text the analysis reads. */
    public String getText() {
        return text;
    }

    /** {@code NO_BOM} or {@code BOM_STRIPPED}. */
    public String getBom() {
        return bom;
    }

    /** The raw bytes, when given; a copy. */
    public byte[] getRawBytes() {
        return rawBytes == null ? null : rawBytes.clone();
    }

    /** SHA-256 of the raw bytes ({@code RAW_BYTES_SHA256}), or {@code null} when only text was given. */
    public String rawBytesDigest() {
        return rawBytes == null ? null : SqllrResources.sha256Hex(rawBytes);
    }

    /** SHA-256 of the UTF-8 encoding of the decoded text ({@code DECODED_TEXT_SHA256}). */
    public String decodedTextDigest() {
        return SqllrResources.sha256Hex(text.getBytes(StandardCharsets.UTF_8));
    }

    @Override
    public String toString() {
        return identityKind + (namespace != null ? " " + namespace + " " + logicalName : "")
                + (contextDomain != null ? " " + contextDomain : "") + " (" + text.length() + " chars)";
    }

    /** Two inputs are equal only when they are the same object: equal text never merges two units. */
    @Override
    public boolean equals(Object other) {
        return this == other;
    }

    @Override
    public int hashCode() {
        return System.identityHashCode(this);
    }
}