package gudusoft.gsqlparser.slpc.adapter;

import gudusoft.gsqlparser.TBaseType;
import gudusoft.gsqlparser.dlineage.dataflow.model.xml.column;
import gudusoft.gsqlparser.dlineage.dataflow.model.AuthoritativeLineageEvidence;
import gudusoft.gsqlparser.dlineage.dataflow.model.xml.dataflow;
import gudusoft.gsqlparser.dlineage.dataflow.model.xml.procedure;
import gudusoft.gsqlparser.dlineage.dataflow.model.xml.relationship;
import gudusoft.gsqlparser.dlineage.dataflow.model.xml.table;
import gudusoft.gsqlparser.slpc.model.SlpcObject;

import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * Caller-supplied facts that do not exist in the legacy dataflow POJO.
 * Supplying these values is not SQL reparsing; it makes artifact and identity
 * provenance explicit at the adapter boundary.
 */
public final class LegacyAdapterContext {

    public interface IdentityResolver {
        /** Returns a proven descriptor or null to quarantine the endpoint. */
        ResolvedIdentity resolve(table relation, column field);
    }

    public static final IdentityResolver NO_IDENTITY = new IdentityResolver() {
        @Override public ResolvedIdentity resolve(table relation, column field) { return null; }
    };

    /**
     * Supplies typed operation and ordered-operand evidence produced while the
     * SQL AST is still available. The legacy XML transform text and its set
     * iteration order are deliberately not treated as this evidence.
     */
    public interface TypedTransformResolver {
        /** Returns a proven profile for this legacy relationship, or null. */
        TypedTransform resolve(relationship relation);
    }

    public static final TypedTransformResolver NO_TYPED_TRANSFORM = new TypedTransformResolver() {
        @Override public TypedTransform resolve(relationship relation) { return null; }
    };

    /**
     * Supplies overload identity, formal-parameter binding, and explicit
     * parameter/return flows while the routine AST or catalog signature is
     * still available. Legacy argument names are display evidence only and
     * are never matched to variable names by this adapter.
     */
    public interface RoutineBindingResolver {
        RoutineBinding resolve(procedure routine);
    }

    public static final RoutineBindingResolver NO_ROUTINE_BINDING = new RoutineBindingResolver() {
        @Override public RoutineBinding resolve(procedure routine) { return null; }
    };

    /** Supplies declaration-order composite FK pairs lost by legacy output. */
    public interface CompositeForeignKeyResolver {
        List<ForeignKeyBinding> resolve(dataflow completed);
    }

    public static final CompositeForeignKeyResolver NO_COMPOSITE_FOREIGN_KEY =
            new CompositeForeignKeyResolver() {
                @Override public List<ForeignKeyBinding> resolve(dataflow completed) {
                    return Collections.emptyList();
                }
            };

    private final String sourceKind;
    private final String logicalLocator;
    private final String sqlDialect;
    private final String contentSha256;
    private final String statementKind;
    private final String engineVersion;
    private final IdentityResolver identityResolver;
    private final TypedTransformResolver typedTransformResolver;
    private final RoutineBindingResolver routineBindingResolver;
    private final CompositeForeignKeyResolver compositeForeignKeyResolver;

    private LegacyAdapterContext(Builder builder) {
        this.sourceKind = required(builder.sourceKind, "sourceKind");
        this.logicalLocator = required(builder.logicalLocator, "logicalLocator");
        this.sqlDialect = required(builder.sqlDialect, "sqlDialect");
        this.contentSha256 = required(builder.contentSha256, "contentSha256");
        this.statementKind = required(builder.statementKind, "statementKind");
        this.engineVersion = required(builder.engineVersion, "engineVersion");
        this.identityResolver = builder.identityResolver == null ? NO_IDENTITY : builder.identityResolver;
        this.typedTransformResolver = builder.typedTransformResolver == null
                ? NO_TYPED_TRANSFORM : builder.typedTransformResolver;
        this.routineBindingResolver = builder.routineBindingResolver == null
                ? NO_ROUTINE_BINDING : builder.routineBindingResolver;
        this.compositeForeignKeyResolver = builder.compositeForeignKeyResolver == null
                ? NO_COMPOSITE_FOREIGN_KEY : builder.compositeForeignKeyResolver;
    }

    public static Builder builder() { return new Builder(); }

    /** Convenience factory; the SQL is hashed only and is never parsed by the adapter. */
    public static Builder forInlineSql(String logicalLocator, String dialect, String sql) {
        return builder().sourceKind("INLINE_SQL").logicalLocator(logicalLocator).sqlDialect(dialect)
                .contentSha256(sha256(sql.getBytes(StandardCharsets.UTF_8)));
    }

    public String sourceKind() { return sourceKind; }
    public String logicalLocator() { return logicalLocator; }
    public String sqlDialect() { return sqlDialect; }
    public String contentSha256() { return contentSha256; }
    public String statementKind() { return statementKind; }
    public String engineVersion() { return engineVersion; }
    public IdentityResolver identityResolver() { return identityResolver; }
    public TypedTransformResolver typedTransformResolver() { return typedTransformResolver; }
    public RoutineBindingResolver routineBindingResolver() { return routineBindingResolver; }
    public CompositeForeignKeyResolver compositeForeignKeyResolver() { return compositeForeignKeyResolver; }

    public static final class TypedTransform {
        private final String operationFamily;
        private final String operationCode;
        private final List<TypedOperand> operands;

        public TypedTransform(String operationFamily, String operationCode, List<TypedOperand> operands) {
            this.operationFamily = required(operationFamily, "operationFamily");
            this.operationCode = required(operationCode, "operationCode");
            if (operands == null || operands.isEmpty()) {
                throw new IllegalArgumentException("operands must not be empty");
            }
            this.operands = Collections.unmodifiableList(new ArrayList<TypedOperand>(operands));
        }

        public String operationFamily() { return operationFamily; }
        public String operationCode() { return operationCode; }
        public List<TypedOperand> operands() { return operands; }
    }

    public static final class TypedOperand {
        /** Legacy POJO record ID used only for edge correlation, never a database identifier. */
        private final String sourceId;
        private final String roleCode;

        public TypedOperand(String sourceId, String roleCode) {
            this.sourceId = required(sourceId, "sourceId");
            this.roleCode = required(roleCode, "roleCode");
        }

        public String sourceId() { return sourceId; }
        public String roleCode() { return roleCode; }
    }

    public static final class RoutineBinding {
        private final ResolvedIdentity routineIdentity;
        private final List<RoutineParameterBinding> parameters;
        private final List<RoutineValueFlow> flows;

        public RoutineBinding(ResolvedIdentity routineIdentity, List<RoutineParameterBinding> parameters,
                List<RoutineValueFlow> flows) {
            if (routineIdentity == null) throw new IllegalArgumentException("routineIdentity must not be null");
            this.routineIdentity = routineIdentity;
            this.parameters = immutable(parameters);
            this.flows = immutable(flows);
        }

        public ResolvedIdentity routineIdentity() { return routineIdentity; }
        public List<RoutineParameterBinding> parameters() { return parameters; }
        public List<RoutineValueFlow> flows() { return flows; }
    }

    public static final class RoutineParameterBinding {
        private final String bindingKey;
        private final String legacyArgumentId;
        private final String boundLegacyEndpointId;
        private final String displayName;
        private final String role;
        private final int ordinal;
        private final String declaredType;
        private final ResolvedIdentity identity;

        public RoutineParameterBinding(String bindingKey, String legacyArgumentId, String boundLegacyEndpointId,
                String displayName, String role, int ordinal, String declaredType, ResolvedIdentity identity) {
            this.bindingKey = required(bindingKey, "bindingKey");
            this.legacyArgumentId = optional(legacyArgumentId);
            this.boundLegacyEndpointId = optional(boundLegacyEndpointId);
            this.displayName = required(displayName, "displayName");
            this.role = required(role, "role");
            if (ordinal < 1) throw new IllegalArgumentException("ordinal must be positive");
            this.ordinal = ordinal;
            this.declaredType = optional(declaredType);
            if (identity == null) throw new IllegalArgumentException("identity must not be null");
            this.identity = identity;
        }

        public String bindingKey() { return bindingKey; }
        public String legacyArgumentId() { return legacyArgumentId; }
        public String boundLegacyEndpointId() { return boundLegacyEndpointId; }
        public String displayName() { return displayName; }
        public String role() { return role; }
        public int ordinal() { return ordinal; }
        public String declaredType() { return declaredType; }
        public ResolvedIdentity identity() { return identity; }
    }

    public static final class RoutineValueRef {
        private final String parameterBindingKey;
        private final String legacyEndpointId;

        private RoutineValueRef(String parameterBindingKey, String legacyEndpointId) {
            this.parameterBindingKey = optional(parameterBindingKey);
            this.legacyEndpointId = optional(legacyEndpointId);
            if ((this.parameterBindingKey == null) == (this.legacyEndpointId == null)) {
                throw new IllegalArgumentException("exactly one routine value reference kind is required");
            }
        }

        public static RoutineValueRef parameter(String bindingKey) {
            return new RoutineValueRef(required(bindingKey, "bindingKey"), null);
        }

        public static RoutineValueRef legacyEndpoint(String legacyEndpointId) {
            return new RoutineValueRef(null, required(legacyEndpointId, "legacyEndpointId"));
        }

        public String parameterBindingKey() { return parameterBindingKey; }
        public String legacyEndpointId() { return legacyEndpointId; }
    }

    public static final class RoutineValueFlow {
        private final RoutineValueRef source;
        private final RoutineValueRef target;
        private final String role;
        private final String operationKind;
        private final String operationInputKind;

        public RoutineValueFlow(RoutineValueRef source, RoutineValueRef target, String role,
                String operationKind, String operationInputKind) {
            if (source == null || target == null) throw new IllegalArgumentException("routine flow endpoints are required");
            this.source = source;
            this.target = target;
            this.role = required(role, "role");
            this.operationKind = required(operationKind, "operationKind");
            this.operationInputKind = required(operationInputKind, "operationInputKind");
        }

        public RoutineValueRef source() { return source; }
        public RoutineValueRef target() { return target; }
        public String role() { return role; }
        public String operationKind() { return operationKind; }
        public String operationInputKind() { return operationInputKind; }
    }

    public static final class ForeignKeyBinding {
        private final List<String> evidenceRelationshipIds;
        private final List<ForeignKeyPair> keyPairs;

        public ForeignKeyBinding(List<String> evidenceRelationshipIds, List<ForeignKeyPair> keyPairs) {
            this.evidenceRelationshipIds = immutableRequired(evidenceRelationshipIds, "evidenceRelationshipIds");
            this.keyPairs = immutableRequired(keyPairs, "keyPairs");
        }

        public List<String> evidenceRelationshipIds() { return evidenceRelationshipIds; }
        public List<ForeignKeyPair> keyPairs() { return keyPairs; }
    }

    public static final class ForeignKeyPair {
        private final String foreignKeyFieldLegacyId;
        private final String referencedFieldLegacyId;

        public ForeignKeyPair(String foreignKeyFieldLegacyId, String referencedFieldLegacyId) {
            this.foreignKeyFieldLegacyId = required(foreignKeyFieldLegacyId, "foreignKeyFieldLegacyId");
            this.referencedFieldLegacyId = required(referencedFieldLegacyId, "referencedFieldLegacyId");
        }

        public String foreignKeyFieldLegacyId() { return foreignKeyFieldLegacyId; }
        public String referencedFieldLegacyId() { return referencedFieldLegacyId; }
    }

    public static final class ResolvedIdentity {
        private final SlpcObject identity;
        private final String resolutionStatus;
        private final String publicationState;

        public ResolvedIdentity(SlpcObject identity, String resolutionStatus, String publicationState) {
            if (identity == null) throw new IllegalArgumentException("identity must not be null");
            this.identity = identity;
            this.resolutionStatus = required(resolutionStatus, "resolutionStatus");
            this.publicationState = required(publicationState, "publicationState");
        }

        public SlpcObject identity() { return identity; }
        public String resolutionStatus() { return resolutionStatus; }
        public String publicationState() { return publicationState; }
    }

    public static final class Builder {
        private String sourceKind = "INLINE_SQL";
        private String logicalLocator;
        private String sqlDialect;
        private String contentSha256;
        private String statementKind = "UNKNOWN";
        private String engineVersion = TBaseType.versionid;
        private IdentityResolver identityResolver;
        private TypedTransformResolver typedTransformResolver;
        private RoutineBindingResolver routineBindingResolver;
        private CompositeForeignKeyResolver compositeForeignKeyResolver;

        public Builder sourceKind(String value) { this.sourceKind = value; return this; }
        public Builder logicalLocator(String value) { this.logicalLocator = value; return this; }
        public Builder sqlDialect(String value) { this.sqlDialect = value; return this; }
        public Builder contentSha256(String value) { this.contentSha256 = value; return this; }
        public Builder statementKind(String value) { this.statementKind = value; return this; }
        public Builder engineVersion(String value) { this.engineVersion = value; return this; }
        public Builder identityResolver(IdentityResolver value) { this.identityResolver = value; return this; }
        public Builder typedTransformResolver(TypedTransformResolver value) { this.typedTransformResolver = value; return this; }
        public Builder routineBindingResolver(RoutineBindingResolver value) { this.routineBindingResolver = value; return this; }
        public Builder compositeForeignKeyResolver(CompositeForeignKeyResolver value) { this.compositeForeignKeyResolver = value; return this; }
        /**
         * Connects evidence captured by the same DataFlowAnalyzer run to all
         * AST/catalog-authoritative adapter resolvers. Explicit resolver calls
         * made after this method may override an individual strategy.
         */
        public Builder authoritativeEvidence(AuthoritativeLineageEvidence value) {
            LegacyAuthoritativeEvidenceBridge bridge = new LegacyAuthoritativeEvidenceBridge(value);
            this.typedTransformResolver = bridge;
            this.routineBindingResolver = bridge;
            this.compositeForeignKeyResolver = bridge;
            return this;
        }
        public LegacyAdapterContext build() { return new LegacyAdapterContext(this); }
    }

    private static <T> List<T> immutable(List<T> values) {
        return values == null ? Collections.<T>emptyList()
                : Collections.unmodifiableList(new ArrayList<T>(values));
    }

    private static <T> List<T> immutableRequired(List<T> values, String field) {
        if (values == null || values.isEmpty()) throw new IllegalArgumentException(field + " must not be empty");
        return Collections.unmodifiableList(new ArrayList<T>(values));
    }

    private static String optional(String value) {
        return value == null || value.isEmpty() ? null : value;
    }

    private static String required(String value, String field) {
        if (value == null || value.isEmpty()) throw new IllegalArgumentException(field + " must not be empty");
        return value;
    }

    private static String sha256(byte[] value) {
        try {
            byte[] digest = MessageDigest.getInstance("SHA-256").digest(value);
            StringBuilder result = new StringBuilder();
            for (byte item : digest) result.append(String.format("%02x", item & 255));
            return result.toString();
        } catch (NoSuchAlgorithmException impossible) { throw new IllegalStateException(impossible); }
    }
}