package gudusoft.gsqlparser.dlineage.routine;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.TCustomSqlStatement;
import gudusoft.gsqlparser.catalog.runtime.CatalogObjectKind;
import gudusoft.gsqlparser.dlineage.dataflow.model.ModelBindingManager;
import gudusoft.gsqlparser.dlineage.dataflow.model.OraclePackage;
import gudusoft.gsqlparser.dlineage.dataflow.model.Procedure;
import gudusoft.gsqlparser.nodes.TFunctionCall;
import gudusoft.gsqlparser.nodes.TObjectName;
import gudusoft.gsqlparser.sqlenv.IdentifierService;
import gudusoft.gsqlparser.stmt.TCommonBlock;
import gudusoft.gsqlparser.stmt.TStoredProcedureSqlStatement;
import gudusoft.gsqlparser.stmt.oracle.TPlsqlCreatePackage;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;

/**
 * Measurement only (D3b.0): runs {@link RoutineRegistry} beside the legacy name-keyed routine registry and
 * records, per declaration and per lookup, what each found. Enabled by the system property
 * {@value #PROPERTY} naming a file the records are appended to (tab separated); off by default, when the
 * callers do not evaluate its arguments. Nothing here throws into the analysis, and the typed registry is fed
 * from the statements themselves, never from the models the legacy registry chose.
 */
public final class RoutineShadow {

    public static final String PROPERTY = "gsp.dlineage.routineShadow";

    private static final Object WRITE_LOCK = new Object();

    /** The shadow's per-analysis state, kept by the analysis's ModelBindingManager and cleared with it. */
    public static final class State {
        final RoutineRegistry routines = new RoutineRegistry();
        final RoutineRegistry definitions = new RoutineRegistry();
    }

    private RoutineShadow() {
    }

    public static boolean enabled() {
        try {
            return System.getProperty(PROPERTY) != null;
        } catch (RuntimeException denied) {
            return false;
        }
    }

    private static State state(ModelBindingManager manager) {
        return manager.routineShadowState();
    }

    private static EDbVendor vendor() {
        return ModelBindingManager.getGlobalVendor();
    }

    private static IdentifierService service() {
        return ModelBindingManager.getGlobalIdentifierService();
    }

    private static TObjectName enclosingPackage() {
        OraclePackage pkg = ModelBindingManager.getGlobalOraclePackage();
        if (pkg != null && pkg.getProcedureObject() instanceof TStoredProcedureSqlStatement) {
            return ((TStoredProcedureSqlStatement) pkg.getProcedureObject()).getStoredProcedureName();
        }
        return null;
    }

    static CatalogObjectKind kindOf(TCustomSqlStatement stmt) {
        String type = stmt == null || stmt.sqlstatementtype == null ? "" : stmt.sqlstatementtype.name();
        type = type.toLowerCase(java.util.Locale.ROOT);
        if (type.contains("trigger")) {
            return CatalogObjectKind.TRIGGER;
        }
        if (type.contains("function")) {
            return CatalogObjectKind.FUNCTION;
        }
        if (type.contains("procedure")) {
            return CatalogObjectKind.PROCEDURE;
        }
        return CatalogObjectKind.ROUTINE;
    }

    /** The named routine a statement is inside of (block owners resolved), or null; a package ends the walk. */
    private static TCustomSqlStatement enclosingRoutine(TCustomSqlStatement stmt) {
        TCustomSqlStatement current = stmt == null ? null : stmt.getParentStmt();
        while (current != null) {
            if (current instanceof TCommonBlock && ((TCommonBlock) current).getBlockBody() != null
                    && ((TCommonBlock) current).getBlockBody().getParentObjectName() instanceof TStoredProcedureSqlStatement) {
                current = (TStoredProcedureSqlStatement) ((TCommonBlock) current).getBlockBody().getParentObjectName();
            }
            if (current instanceof TPlsqlCreatePackage) {
                return null;
            }
            if (current instanceof TStoredProcedureSqlStatement
                    && ((TStoredProcedureSqlStatement) current).getStoredProcedureName() != null) {
                return current;
            }
            current = current.getParentStmt();
        }
        return null;
    }

    /** The routine a PL/SQL routine is local to (Oracle, Dameng), or null for a top-level or package routine. */
    private static Object localScopeOf(TStoredProcedureSqlStatement stmt) {
        EDbVendor vendor = vendor();
        if (vendor != EDbVendor.dbvoracle && vendor != EDbVendor.dbvdameng) {
            return null;
        }
        return enclosingRoutine(stmt);
    }

    /** The routines a statement is inside of, innermost first: the scopes whose local routines it sees. */
    private static List<Object> visibleScopes(TCustomSqlStatement at) {
        List<Object> scopes = new ArrayList<Object>();
        if (at instanceof TStoredProcedureSqlStatement && ((TStoredProcedureSqlStatement) at).getStoredProcedureName() != null) {
            scopes.add(at);
        }
        for (TCustomSqlStatement routine = enclosingRoutine(at); routine != null; routine = enclosingRoutine(routine)) {
            scopes.add(routine);
        }
        return scopes;
    }

    /**
     * A routine statement the legacy registry was asked to create a model for, and the model it returned
     * (a new one, or an existing one it found by name).
     */
    public static void declared(ModelBindingManager manager, String site, TStoredProcedureSqlStatement stmt,
            Procedure legacy) {
        try {
            if (stmt == null || legacy == null || service() == null) {
                return;
            }
            RoutineName name = RoutineName.declared(stmt.getStoredProcedureName(), kindOf(stmt), vendor(), service(),
                    enclosingPackage());
            if (name == null) {
                write("DECL", site, String.valueOf(stmt.getStoredProcedureName()), "-", describe(legacy),
                        "UNREPRESENTABLE", "-", "-", "N");
                return;
            }
            RoutineDeclaration declaration = RoutineDeclaration.of(stmt, name, stmt.getParameterDeclarations(),
                    localScopeOf(stmt), vendor(), service());
            RoutineDeclaration existing = state(manager).routines.find(declaration.identity());
            Object legacyFirst = legacy.getProcedureObject();
            boolean legacyReused = legacyFirst != stmt;
            boolean agree = legacyReused ? existing != null && existing.getRepresentative() == legacyFirst
                    : existing == null || existing.getRepresentative() == stmt;
            state(manager).routines.declare(declaration);
            write("DECL", site, name.toString(), String.valueOf(declaration.getTypes()), describe(legacy),
                    existing == null ? "NEW" : "SAME_IDENTITY", "-",
                    existing == null ? "-" : describe(existing.getRepresentative()), agree ? "Y" : "N");
        } catch (RuntimeException e) {
            write("ERROR", site, String.valueOf(e), "-", "-", "-", "-", "-", "N");
        }
    }

    /**
     * A routine the legacy registry was asked for by name from a call or an EXEC ({@code origin} is the call or
     * name node): it returns an existing routine it found by name, or a new one made from {@code origin}. The
     * typed registry looks the name up first and declares a routine only when nothing is found.
     */
    public static void declaredFromCall(ModelBindingManager manager, String site, TObjectName written, Object origin,
            Integer argumentCount, CatalogObjectKind wanted, Procedure legacy) {
        try {
            if (written == null || legacy == null || service() == null) {
                return;
            }
            boolean legacyCreated = legacy.getProcedureObject() == origin;
            List<RoutineName> names = RoutineName.interpretations(written, CatalogObjectKind.ROUTINE, vendor(), service(),
                    enclosingPackage());
            RoutineLookupResult result = names.isEmpty() ? RoutineLookupResult.NOT_FOUND
                    : state(manager).routines.lookup(names, argumentCount, wanted, null);
            Object resolved = result.getResolved() == null ? null : result.getResolved().getRepresentative();
            boolean agree = legacyCreated ? result.getStatus() == RoutineLookupResult.Status.NOT_FOUND
                    : resolved == legacy.getProcedureObject();
            write("DECL_CALL", site, names.isEmpty() ? String.valueOf(written) : names.get(0).toString(),
                    String.valueOf(argumentCount), (legacyCreated ? "new:" : "found:") + describe(legacy),
                    result.getStatus().name(), result.getBranch().name(), candidates(result), agree ? "Y" : "N");
            if (legacyCreated && !names.isEmpty() && result.getStatus() == RoutineLookupResult.Status.NOT_FOUND) {
                // A placeholder for a routine never declared here, of the kind the call site asks for (a DB2 CALL
                // creates a procedure, not a routine every lookup matches).
                RoutineName name = RoutineName.declared(written, wanted, vendor(), service(), null);
                if (name != null) {
                    state(manager).routines.declare(RoutineDeclaration.ofCall(origin, name, argumentCount, vendor()));
                }
            }
        } catch (RuntimeException e) {
            write("ERROR", site, String.valueOf(e), "-", "-", "-", "-", "-", "N");
        }
    }

    /** A routine definition found by the script pre-scan, analyzed lazily when first called. */
    public static void definition(ModelBindingManager manager, TStoredProcedureSqlStatement stmt) {
        try {
            if (stmt == null || service() == null) {
                return;
            }
            RoutineName name = RoutineName.declared(stmt.getStoredProcedureName(), kindOf(stmt), vendor(), service(),
                    null);
            if (name != null) {
                state(manager).definitions.declare(RoutineDeclaration.of(stmt, name, stmt.getParameterDeclarations(),
                        null, vendor(), service()));
            }
        } catch (RuntimeException e) {
            write("ERROR", "definition", String.valueOf(e), "-", "-", "-", "-", "-", "N");
        }
    }

    /**
     * The argument alias a call is looked up with: its argument count where the vendor overloads routines. A
     * function call always has its parentheses, so one the parser gives no argument list has none (DB2
     * {@code TABLE(f())}).
     */
    public static Integer countAliasOf(TFunctionCall call) {
        if (call == null || vendor() == null || !RoutineDeclaration.callsCounted(vendor())) {
            return null;
        }
        return Integer.valueOf(call.getArgs() == null ? 0 : call.getArgs().size());
    }

    /**
     * A callee lookup at a call site inside {@code at} and the routine the legacy lookup settled on (null when
     * none). {@code aliases} are the argument aliases the site tries in order (null for a name-only lookup), as the
     * site's own retries do. The script's pre-scanned definitions are looked up too, as the lazy analysis would.
     */
    public static void lookedUp(ModelBindingManager manager, String site, TCustomSqlStatement at, TObjectName written,
            Integer[] aliases, CatalogObjectKind wanted, Procedure legacy) {
        try {
            if (written == null || service() == null) {
                return;
            }
            List<RoutineName> names = RoutineName.interpretations(written, CatalogObjectKind.ROUTINE, vendor(), service(),
                    enclosingPackage());
            if (names.isEmpty()) {
                write("LOOKUP", site, String.valueOf(written), "-", describe(legacy), "UNREPRESENTABLE", "-", "-",
                        legacy == null ? "Y" : "N");
                return;
            }
            List<Object> scopes = visibleScopes(at);
            RoutineLookupResult result = RoutineLookupResult.NOT_FOUND;
            boolean viaDefinitions = false;
            Integer used = null;
            for (Integer alias : aliases) {
                used = alias;
                result = state(manager).routines.lookup(names, alias, wanted, scopes);
                if (result.getStatus() != RoutineLookupResult.Status.NOT_FOUND) {
                    break;
                }
            }
            if (result.getStatus() == RoutineLookupResult.Status.NOT_FOUND) {
                // As the lazy analysis does: a routine the script defines later is found among its definitions.
                for (Integer alias : aliases) {
                    RoutineLookupResult definitions = state(manager).definitions.lookup(names, alias, wanted, scopes);
                    if (definitions.getStatus() != RoutineLookupResult.Status.NOT_FOUND) {
                        result = definitions;
                        used = alias;
                        viaDefinitions = true;
                        break;
                    }
                }
            }
            result = result.withLegacyWinner(legacy);
            Object resolved = result.getResolved() == null ? null : result.getResolved().getRepresentative();
            Object legacyFirst = legacy == null ? null : legacy.getProcedureObject();
            boolean agree = resolved == legacyFirst
                    && (legacy != null || result.getStatus() == RoutineLookupResult.Status.NOT_FOUND);
            write("LOOKUP", site, names.get(0).toString(), String.valueOf(used), describe(legacy),
                    result.getStatus().name(), result.getBranch().name(),
                    candidates(result) + (viaDefinitions ? " via:ddl" : ""), agree ? "Y" : "N");
        } catch (RuntimeException e) {
            write("ERROR", site, String.valueOf(e), "-", "-", "-", "-", "-", "N");
        }
    }

    private static String candidates(RoutineLookupResult result) {
        StringBuilder out = new StringBuilder();
        for (RoutineDeclaration candidate : result.getCandidates()) {
            out.append(out.length() == 0 ? "" : ",").append(describe(candidate.getRepresentative()));
        }
        return out.length() == 0 ? "-" : out.toString();
    }

    private static String describe(Object model) {
        if (model == null) {
            return "-";
        }
        if (model instanceof Procedure) {
            Procedure p = (Procedure) model;
            return p.getName() + "#" + p.getId() + "<" + describe(p.getProcedureObject()) + ">";
        }
        if (model instanceof TStoredProcedureSqlStatement) {
            TStoredProcedureSqlStatement s = (TStoredProcedureSqlStatement) model;
            return s.getStoredProcedureName() + "@" + (s.getStartToken() == null ? "?" : String.valueOf(s.getStartToken().lineNo));
        }
        if (model instanceof TObjectName || model instanceof TFunctionCall) {
            return model + "@call";
        }
        return String.valueOf(model);
    }

    private static void write(String event, String site, String name, String alias, String legacy, String status,
            String branch, String candidates, String agree) {
        try {
            String path = System.getProperty(PROPERTY);
            if (path == null) {
                return;
            }
            StringBuilder line = new StringBuilder();
            for (String field : new String[] {event, String.valueOf(vendor()), site, name, alias, legacy, status, branch,
                    candidates, agree}) {
                if (line.length() > 0) {
                    line.append('\t');
                }
                line.append(field == null ? "-" : field.replace('\t', ' ').replace('\n', ' ').replace('\r', ' '));
            }
            line.append('\n');
            synchronized (WRITE_LOCK) {
                try (Writer out = new OutputStreamWriter(new FileOutputStream(path, true), StandardCharsets.UTF_8)) {
                    out.write(line.toString());
                }
            }
        } catch (IOException | RuntimeException ignored) {
            // Measurement output only; the analysis goes on without it.
        }
    }
}