package gudusoft.gsqlparser.lineage2.contract;

import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Locale;

/**
 * Frozen identity-layer hash computation per lineage2-contract.md §3 (normative source:
 * CONTRACT_lineage_role_and_hash_identity.md rev 3, pinned gudu-sqlflow commit
 * b1d5d893149510dc63de400bc2a6aa5d47d35a4a).
 *
 * <p>All hashes: SHA-256 over UTF-8 of pipe-joined normalized fields; output is 64
 * lowercase hex chars. Normalization rules (rev 3): trim every field; null and empty
 * both contribute an empty string ("empty→empty, not NULL"); field positions are
 * preserved when values are empty; names are lowercased, roles/record types uppercased;
 * {@code |} is the frozen P0 separator.
 *
 * <p>Byte-identity against
 * {@code gudu-sqlflow/tools/lineage-contract-fixtures/hash_identity_fixtures.json}
 * is asserted by {@code Lineage2ContractConformanceTest} on every build.
 *
 * <p>Internal API: not part of the public gsqlparser surface.
 */
public final class GuidEncoder {

    private GuidEncoder() {
    }

    /**
     * Canonical edge identity (contract §3.4): workspace + source endpoint + target
     * endpoint + role. Excludes record_type, procedure context, statement index and
     * transformation text by design.
     */
    public static String factGuid(String workspaceId,
                                  String sourceDatabase, String sourceSchema,
                                  String sourceObjectName, String sourceColumnName,
                                  String targetDatabase, String targetSchema,
                                  String targetObjectName, String targetColumnName,
                                  String lineageRole) {
        return sha256Hex(joinPipe(
                lowerTrim(workspaceId),
                lowerTrim(sourceDatabase), lowerTrim(sourceSchema),
                lowerTrim(sourceObjectName), lowerTrim(sourceColumnName),
                lowerTrim(targetDatabase), lowerTrim(targetSchema),
                lowerTrim(targetObjectName), lowerTrim(targetColumnName),
                upperTrim(lineageRole)));
    }

    /**
     * transformation_hash / predicate_hash / expression_hash component: sha256 of the
     * trimmed text, or the empty string (not a hash) when the text is null/empty.
     */
    public static String textHash(String text) {
        String t = trim(text);
        return t.isEmpty() ? "" : sha256Hex(t);
    }

    /** Semantic/effect signature under one fact (contract §4.2). */
    public static String variantGuid(String workspaceId, String factGuid, String lineageRole,
                                     String transformationHash, String predicateHash,
                                     String queryFingerprint) {
        return sha256Hex(joinPipe(
                lowerTrim(workspaceId), trim(factGuid), upperTrim(lineageRole),
                trim(transformationHash), trim(predicateHash), trim(queryFingerprint)));
    }

    /** Evidence instance of a variant (contract §5.2). */
    public static String occurrenceGuid(String workspaceId, String factGuid, String variantGuid,
                                        String recordType, String procedureName, String queryId,
                                        String queryFingerprint, String inputUnitId,
                                        int statementIndex) {
        return sha256Hex(joinPipe(
                lowerTrim(workspaceId), trim(factGuid), trim(variantGuid),
                upperTrim(recordType), lowerTrim(procedureName), trim(queryId),
                trim(queryFingerprint), trim(inputUnitId),
                Integer.toString(statementIndex)));
    }

    /** Mutable-content hash for INCOMING occurrences (contract §7.2). */
    public static String incomingDeltaHash(String predicateText, String transformationText,
                                           String queryFingerprint, String recordStatus) {
        return sha256Hex(joinPipe(
                trim(predicateText), trim(transformationText),
                queryFingerprint == null ? "" : queryFingerprint,
                upperTrim(recordStatus)));
    }

    /** Mutable-content hash for OUTGOING occurrences (contract §7.3). */
    public static String outgoingDeltaHash(String queryFingerprint, Long executionCount,
                                           String firstExecutionAtIso, String lastExecutionAtIso,
                                           String recordStatus) {
        return sha256Hex(joinPipe(
                queryFingerprint == null ? "" : queryFingerprint,
                executionCount == null ? "" : Long.toString(executionCount),
                trim(firstExecutionAtIso), trim(lastExecutionAtIso),
                upperTrim(recordStatus)));
    }

    /** Statement-local transform graph node identity (contract §6.2). */
    public static String transformNodeGuid(String workspaceId, String occurrenceGuid,
                                           int statementIndex, String localScopeId,
                                           String localNodeId, String nodeKind) {
        return sha256Hex(joinPipe(
                lowerTrim(workspaceId), occurrenceGuid, Integer.toString(statementIndex),
                lowerTrim(localScopeId), lowerTrim(localNodeId), upperTrim(nodeKind)));
    }

    /** Statement-local transform graph step identity (contract §6.3). */
    public static String transformStepGuid(String workspaceId, String occurrenceGuid,
                                           int statementIndex, String localScopeId,
                                           int stepIndex, String operationType,
                                           String targetNodeGuid, String expressionHash) {
        return sha256Hex(joinPipe(
                lowerTrim(workspaceId), occurrenceGuid, Integer.toString(statementIndex),
                lowerTrim(localScopeId), Integer.toString(stepIndex), upperTrim(operationType),
                targetNodeGuid, trim(expressionHash)));
    }

    /** SHA-256 of the UTF-8 bytes, 64 lowercase hex chars. */
    public static String sha256Hex(String text) {
        try {
            MessageDigest md = MessageDigest.getInstance("SHA-256");
            byte[] digest = md.digest(text.getBytes(StandardCharsets.UTF_8));
            StringBuilder sb = new StringBuilder(digest.length * 2);
            for (byte b : digest) {
                sb.append(Character.forDigit((b >> 4) & 0xF, 16));
                sb.append(Character.forDigit(b & 0xF, 16));
            }
            return sb.toString();
        } catch (NoSuchAlgorithmException e) {
            throw new IllegalStateException("SHA-256 must be available", e);
        }
    }

    private static String joinPipe(String... fields) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < fields.length; i++) {
            if (i > 0) {
                sb.append('|');
            }
            sb.append(fields[i]);
        }
        return sb.toString();
    }

    private static String trim(String s) {
        return s == null ? "" : s.trim();
    }

    private static String lowerTrim(String s) {
        return trim(s).toLowerCase(Locale.ROOT);
    }

    private static String upperTrim(String s) {
        return trim(s).toUpperCase(Locale.ROOT);
    }
}