package gudusoft.gsqlparser.ir.builder.common;

import gudusoft.gsqlparser.ir.bound.*;
import gudusoft.gsqlparser.ir.common.Evidence;

import java.util.*;

/**
 * Shared base class for dialect-specific routine reference resolvers.
 * <p>
 * Owns the common resolve() loop: builds uppercase and name-based indexes,
 * iterates all unresolved refs, delegates per-ref resolution to subclass,
 * and replaces the ref list on the program.
 * <p>
 * Dialect-specific resolution tiers (qualified match, schema inference,
 * default schema, etc.) belong in the subclass {@link #tryResolve} method.
 */
public abstract class AbstractRoutineRefResolver {

    /**
     * Resolves all unresolved routine refs in the program.
     * Replaces the program's ref list with updated copies where matches are found.
     */
    public final void resolve(BoundProgram program) {
        if (program == null) return;

        Map<String, BoundRoutineSymbol> upperIndex = buildUpperCaseIndex(program);
        if (upperIndex.isEmpty()) return;

        Map<String, List<BoundRoutineSymbol>> nameIndex = buildNameIndex(program);

        List<BoundRoutineRef> original = program.getAllRoutineRefs();
        List<BoundRoutineRef> resolved = new ArrayList<BoundRoutineRef>(original.size());

        for (BoundRoutineRef ref : original) {
            if (ref.getBindingStatus() == EBindingStatus.EXACT) {
                resolved.add(ref);
                continue;
            }
            if (Boolean.TRUE.equals(ref.getProperty("externalDependency"))) {
                resolved.add(ref);
                continue;
            }

            BoundRoutineRef resolvedRef = tryResolve(ref, program, upperIndex, nameIndex);
            if (resolvedRef != null) {
                resolved.add(resolvedRef);
            } else {
                classifyExternalIfKnown(ref);
                resolved.add(ref);
            }
        }

        program.replaceRoutineRefs(resolved);
    }

    /**
     * Attempts to resolve a single routine ref against the known routines.
     *
     * @param ref        the unresolved ref
     * @param program    the program containing all routines
     * @param upperIndex case-insensitive routineId → symbol index
     * @param nameIndex  case-insensitive name → list of symbols index
     * @return resolved ref, or null if no match found
     */
    protected abstract BoundRoutineRef tryResolve(
            BoundRoutineRef ref,
            BoundProgram program,
            Map<String, BoundRoutineSymbol> upperIndex,
            Map<String, List<BoundRoutineSymbol>> nameIndex);

    /**
     * Called for unresolved refs to check if they are known external dependencies.
     * Subclasses should set properties like "externalDependency", "externalType", etc.
     */
    protected abstract void classifyExternalIfKnown(BoundRoutineRef ref);

    // ====== Index Building (shared) ======

    /**
     * Builds a case-insensitive routineId → symbol index.
     */
    protected final Map<String, BoundRoutineSymbol> buildUpperCaseIndex(BoundProgram program) {
        Map<String, BoundRoutineSymbol> ciIndex =
                new LinkedHashMap<String, BoundRoutineSymbol>();
        for (Map.Entry<String, BoundRoutineSymbol> entry : program.getRoutineIndex().entrySet()) {
            ciIndex.put(entry.getKey().toUpperCase(), entry.getValue());
        }
        return ciIndex;
    }

    /**
     * Builds a case-insensitive name → list of symbols index.
     */
    protected final Map<String, List<BoundRoutineSymbol>> buildNameIndex(BoundProgram program) {
        Map<String, List<BoundRoutineSymbol>> nameIndex =
                new LinkedHashMap<String, List<BoundRoutineSymbol>>();
        for (BoundRoutineSymbol sym : program.getRoutineIndex().values()) {
            String nameKey = sym.getRoutineName().toUpperCase();
            List<BoundRoutineSymbol> list = nameIndex.get(nameKey);
            if (list == null) {
                list = new ArrayList<BoundRoutineSymbol>();
                nameIndex.put(nameKey, list);
            }
            list.add(sym);
        }
        return nameIndex;
    }

    // ====== Common Resolution Helpers ======

    /**
     * Tries all KIND code variants for a given base name and argCount.
     * Returns the first match, or null.
     */
    protected static BoundRoutineSymbol tryKindVariants(
            Map<String, BoundRoutineSymbol> ciIndex,
            String baseName, int argCount, String[] kindCodes) {
        // First pass: exact argCount
        for (String kind : kindCodes) {
            String candidateId = baseName + "/" + kind + "(" + argCount + ")";
            BoundRoutineSymbol match = ciIndex.get(candidateId.toUpperCase());
            if (match != null) {
                return match;
            }
        }
        // Second pass: default parameter tolerance (paramCount > argCount)
        String prefix = baseName.toUpperCase() + "/";
        BoundRoutineSymbol bestMatch = null;
        int bestParamCount = Integer.MAX_VALUE;
        for (Map.Entry<String, BoundRoutineSymbol> entry : ciIndex.entrySet()) {
            String key = entry.getKey();
            if (!key.startsWith(prefix)) continue;
            int openParen = key.lastIndexOf('(');
            int closeParen = key.lastIndexOf(')');
            if (openParen < 0 || closeParen <= openParen) continue;
            try {
                int paramCount = Integer.parseInt(key.substring(openParen + 1, closeParen));
                if (paramCount > argCount && paramCount < bestParamCount) {
                    bestMatch = entry.getValue();
                    bestParamCount = paramCount;
                }
            } catch (NumberFormatException e) {
                // skip
            }
        }
        return bestMatch;
    }

    /**
     * Finds candidates matching a name and exact arg count from the name index.
     */
    protected static List<BoundRoutineSymbol> findByNameAndArgCount(
            Map<String, List<BoundRoutineSymbol>> nameIndex,
            String upperName, int argCount) {
        List<BoundRoutineSymbol> candidates = nameIndex.get(upperName);
        if (candidates == null || candidates.isEmpty()) {
            return Collections.emptyList();
        }
        List<BoundRoutineSymbol> matches = new ArrayList<BoundRoutineSymbol>();
        for (BoundRoutineSymbol sym : candidates) {
            if (sym.getParameters().size() == argCount) {
                matches.add(sym);
            }
        }
        return matches;
    }

    /**
     * Finds the best default-parameter match (smallest paramCount > argCount).
     */
    protected static BoundRoutineSymbol findBestDefaultParamMatch(
            Map<String, List<BoundRoutineSymbol>> nameIndex,
            String upperName, int argCount) {
        List<BoundRoutineSymbol> candidates = nameIndex.get(upperName);
        if (candidates == null) return null;
        BoundRoutineSymbol best = null;
        int bestCount = Integer.MAX_VALUE;
        for (BoundRoutineSymbol sym : candidates) {
            int pc = sym.getParameters().size();
            if (pc > argCount && pc < bestCount) {
                best = sym;
                bestCount = pc;
            }
        }
        return best;
    }
}