package gudusoft.gsqlparser.sqlenv;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.util.SQLUtil;
import gudusoft.gsqlparser.util.keywordChecker;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Objects;

/**
 * Generates a SQL name from STORED name segments.
 *
 * <p>See docs/refactor/identifier/README.md, "Catalog inputs and name output".
 * This capability lets existing getters such as
 * {@code procedure.getName()} can keep their historical output while correct
 * quoting, escaping and qualification live in one place that actually promises
 * them.</p>
 *
 * <h3>Contract</h3>
 * <ul>
 *   <li><b>Input is stored names, never SQL text.</b> Each segment is the name as
 *       the database catalog stores it: {@code db name}, not {@code [db name]}.
 *       A stored name whose real content includes delimiter characters
 *       ({@code [db name]} with the brackets being part of the name) is legal
 *       input and is escaped, not reinterpreted.</li>
 *   <li><b>Segments are structural.</b> A stored name containing a dot
 *       ({@code db.part}) is ONE segment. This class never splits a segment and
 *       never joins pre-rendered text.</li>
 *   <li><b>No guessing.</b> The caller states every segment. Nothing is added:
 *       no default schema, no {@code dbo}, no current database. A missing or
 *       empty segment is a failure, not a hint to fill in.</li>
 *   <li><b>A success is verified.</b> Every quoted segment is decoded back and
 *       must reproduce the stored name exactly, and must be a valid spelling for
 *       the vendor. Anything that cannot be proven yields a failure with a
 *       reason instead of a plausible-looking name.</li>
 * </ul>
 *
 * <h3>What is NOT promised</h3>
 * <p>Validity is at the identifier level: delimiters, escaping, characters and
 * segment structure. Whether the vendor accepts that many segments in a given
 * statement position, length limits, and whether the object exists are outside
 * this class.</p>
 */
public final class SqlNameGenerator {

    /** How to choose between the bare and the delimited spelling of a segment. */
    public enum QuotePolicy {
        /** Delimit every segment. Always correct when the stored name is known. */
        ALWAYS,
        /**
         * Emit the bare spelling only when it is PROVEN to denote the same object;
         * otherwise delimit. See {@link SqlNameGenerator#bareIsProvenSafe}.
         */
        WHEN_NEEDED
    }

    /** Why a name could not be generated. */
    public enum Failure {
        /** No segments were given. */
        NO_SEGMENTS,
        /** A segment, its role or its stored name was null. */
        NULL_SEGMENT,
        /** A segment's stored name was empty; nothing is filled in on the caller's behalf. */
        EMPTY_SEGMENT,
        /** The name needs delimiting but the vendor has no delimited form for that role. */
        NO_QUOTED_FORM,
        /** The name cannot be written as a valid identifier for this vendor at all. */
        NOT_REPRESENTABLE,
        /** The rendered segment did not decode back to the stored name. */
        ROUND_TRIP_MISMATCH
    }

    /** One stored name segment together with its syntactic role. */
    public static final class Segment {
        private final ESQLDataObjectType role;
        private final String stored;

        private Segment(ESQLDataObjectType role, String stored) {
            this.role = role;
            this.stored = stored;
        }

        public static Segment of(ESQLDataObjectType role, String stored) {
            return new Segment(role, stored);
        }

        public static Segment server(String stored) { return of(ESQLDataObjectType.dotServer, stored); }
        public static Segment catalog(String stored) { return of(ESQLDataObjectType.dotCatalog, stored); }
        public static Segment schema(String stored) { return of(ESQLDataObjectType.dotSchema, stored); }
        public static Segment table(String stored) { return of(ESQLDataObjectType.dotTable, stored); }
        public static Segment column(String stored) { return of(ESQLDataObjectType.dotColumn, stored); }
        public static Segment function(String stored) { return of(ESQLDataObjectType.dotFunction, stored); }
        public static Segment procedure(String stored) { return of(ESQLDataObjectType.dotProcedure, stored); }

        public ESQLDataObjectType getRole() { return role; }
        public String getStored() { return stored; }
    }

    /** Outcome of a generation: either the SQL text, or the reason there is none. */
    public static final class Result {
        private final String sql;
        private final Failure failure;
        private final int failedSegmentIndex;
        private final String detail;

        private Result(String sql, Failure failure, int failedSegmentIndex, String detail) {
            this.sql = sql;
            this.failure = failure;
            this.failedSegmentIndex = failedSegmentIndex;
            this.detail = detail;
        }

        static Result ok(String sql) {
            return new Result(sql, null, -1, null);
        }

        static Result fail(Failure failure, int index, String detail) {
            return new Result(null, failure, index, detail);
        }

        public boolean isOk() { return failure == null; }

        /** The generated SQL name, or {@code null} when {@link #isOk()} is false. */
        public String getSql() { return sql; }

        /** The failure reason, or {@code null} on success. */
        public Failure getFailure() { return failure; }

        /** Index of the offending segment, or {@code -1} when not segment-specific. */
        public int getFailedSegmentIndex() { return failedSegmentIndex; }

        /** Human-readable explanation of the failure, or {@code null} on success. */
        public String getDetail() { return detail; }

        /** The generated SQL name; throws when generation failed. */
        public String getSqlOrThrow() {
            if (!isOk()) {
                throw new IllegalStateException("SQL name generation failed: " + failure
                        + (failedSegmentIndex >= 0 ? " at segment " + failedSegmentIndex : "")
                        + (detail != null ? " (" + detail + ")" : ""));
            }
            return sql;
        }

        @Override
        public String toString() {
            return isOk() ? "Result{sql=" + sql + "}"
                    : "Result{failure=" + failure + ", segment=" + failedSegmentIndex + ", detail=" + detail + "}";
        }
    }

    private SqlNameGenerator() {
    }

    /** Generate with every segment delimited. */
    public static Result generate(EDbVendor vendor, Segment... segments) {
        return generate(vendor, QuotePolicy.ALWAYS,
                segments == null ? null : Arrays.asList(segments));
    }

    public static Result generate(EDbVendor vendor, QuotePolicy policy, Segment... segments) {
        return generate(vendor, policy, segments == null ? null : Arrays.asList(segments));
    }

    /**
     * Generate a SQL name.
     *
     * @param vendor target dialect (non-null)
     * @param policy bare-versus-delimited choice (non-null)
     * @param segments stored name segments, outermost first
     * @return the SQL name, or the reason none could be produced
     */
    public static Result generate(EDbVendor vendor, QuotePolicy policy, List<Segment> segments) {
        Objects.requireNonNull(vendor, "vendor");
        Objects.requireNonNull(policy, "policy");
        if (segments == null || segments.isEmpty()) {
            return Result.fail(Failure.NO_SEGMENTS, -1, "at least one segment is required");
        }

        IdentifierProfile profile = IdentifierProfile.forVendor(vendor, IdentifierProfile.VendorFlags.defaults());
        List<String> rendered = new ArrayList<String>(segments.size());

        for (int i = 0; i < segments.size(); i++) {
            Segment seg = segments.get(i);
            if (seg == null || seg.role == null || seg.stored == null) {
                return Result.fail(Failure.NULL_SEGMENT, i, "segment, role and stored name must be non-null");
            }
            if (seg.stored.isEmpty()) {
                return Result.fail(Failure.EMPTY_SEGMENT, i,
                        "empty stored name; qualification is never filled in on the caller's behalf");
            }

            if (policy == QuotePolicy.WHEN_NEEDED && bareIsProvenSafe(vendor, profile, seg)) {
                rendered.add(seg.stored);
                continue;
            }

            if (!IdentifierCodec.hasQuotedForm(profile, seg.role)) {
                // The vendor (SOQL) has no delimited form, so the bare spelling is the
                // ONLY spelling. The keyword condition is dropped here on purpose: in
                // such a dialect an object named after a keyword could never be
                // referenced, so the stored name existing at all proves the bare word
                // is usable. Character-level validity is still required.
                if (IdentifierCodec.isVendorValidSpelling(profile, seg.role, seg.stored)) {
                    rendered.add(seg.stored);
                    continue;
                }
                return Result.fail(Failure.NO_QUOTED_FORM, i,
                        "name needs delimiting but " + vendor + " has no delimited form for " + seg.role);
            }

            String quoted = IdentifierCodec.encodeStored(profile, seg.role, seg.stored);
            if (!IdentifierCodec.isVendorValidSpelling(profile, seg.role, quoted)) {
                return Result.fail(Failure.NOT_REPRESENTABLE, i,
                        "no valid " + vendor + " spelling exists for this stored name");
            }
            String decoded;
            try {
                decoded = IdentifierCodec.decodeLexical(profile, seg.role, quoted);
            } catch (RuntimeException e) {
                return Result.fail(Failure.ROUND_TRIP_MISMATCH, i, "encoded form does not decode: " + e.getMessage());
            }
            // Transport verification of raw text, not an identifier comparison: the
            // decode must reproduce the stored characters exactly.
            if (!decoded.equals(seg.stored)) {
                return Result.fail(Failure.ROUND_TRIP_MISMATCH, i, "encoded form decodes to a different name");
            }
            rendered.add(quoted);
        }

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < rendered.size(); i++) {
            if (i > 0) {
                sb.append('.');
            }
            sb.append(rendered.get(i));
        }
        return Result.ok(sb.toString());
    }

    /**
     * Is the bare spelling PROVEN to denote the same object as the stored name?
     *
     * <p>All five must hold; any doubt means "delimit", because the delimited
     * spelling is always correct and a wrong bare spelling silently names a
     * different object.</p>
     * <ol>
     *   <li>The role has a bare spelling at all: a DAX column is always written
     *       {@code [Name]} ({@link IdentifierCodec#requiresDelimiters}).</li>
     *   <li>The stored text does not itself read as a delimited identifier. MSSQL
     *       stored name {@code [db name]} (brackets being real content) written
     *       bare would be parsed as the different object {@code db name}.</li>
     *   <li>The bare spelling is a valid unquoted identifier for the vendor.</li>
     *   <li>The bare spelling resolves to the same object as the delimited one —
     *       Oracle stored {@code Amount} written bare folds to {@code AMOUNT}.</li>
     *   <li>The vendor's keyword list is available AND the word is not on it. With
     *       no keyword list the word cannot be proven safe, so it is delimited.</li>
     * </ol>
     */
    static boolean bareIsProvenSafe(EDbVendor vendor, IdentifierProfile profile, Segment seg) {
        if (IdentifierCodec.requiresDelimiters(profile, seg.role)) {
            // The role has no bare spelling at all (a DAX column is always [Name]).
            return false;
        }
        String bare = seg.stored;
        if (IdentifierCodec.isQuoted(profile, seg.role, bare)) {
            return false;
        }
        if (!IdentifierCodec.isVendorValidSpelling(profile, seg.role, bare)) {
            return false;
        }
        if (IdentifierCodec.hasQuotedForm(profile, seg.role)) {
            String quoted = IdentifierCodec.encodeStored(profile, seg.role, bare);
            if (!SQLUtil.sameName(vendor, seg.role, bare, quoted)) {
                return false;
            }
        }
        // checkKeywordType splits its input on commas; a valid bare spelling
        // contains none, so exactly one entry comes back when a list exists.
        Map<String, keywordChecker.keywordType> kw = keywordChecker.checkKeywordType(bare, vendor);
        if (kw == null || kw.size() != 1) {
            return false;
        }
        return kw.values().iterator().next() == keywordChecker.keywordType.not_a_keyword;
    }

    /**
     * Re-spell ONE identifier that was read from SQL text, as valid SQL naming the same object.
     *
     * <p>This is the entry point for a name that HAS a source spelling, as opposed to
     * {@link #generate}, which starts from a stored name. The difference matters for case:</p>
     * <ul>
     *   <li><b>Written without delimiters.</b> The script parsed, so the bare word is already
     *       proven to be valid SQL for this object, and re-emitting it bare cannot name anything
     *       else. It is returned as written. It is deliberately NOT case-folded: that would need
     *       the catalog's real stored case, and the name service's fold is a comparison key, not
     *       a storage rule (Teradata is modeled with PostgreSQL's lower-casing although it stores
     *       names as created). Folding here turned {@code DB51_CAD} into {@code db51_cad}.</li>
     *   <li><b>Written with delimiters.</b> Decoding gives the exact stored text, and
     *       {@link #generate} decides whether the delimiters can be dropped.</li>
     * </ul>
     *
     * <p>So two references to one object may still re-spell differently ({@code Sales} and
     * {@code SALES} on Oracle). Making a LISTING show one of them is the job of identity
     * grouping plus a display-name policy, which can consult the catalog; it is not something a
     * single spelling can decide.</p>
     */
    public static Result respell(EDbVendor vendor, QuotePolicy policy, ESQLDataObjectType role, String lexical) {
        Objects.requireNonNull(vendor, "vendor");
        Objects.requireNonNull(policy, "policy");
        Objects.requireNonNull(role, "role");
        if (lexical == null) return Result.fail(Failure.NULL_SEGMENT, 0, "lexical spelling is null");
        if (lexical.isEmpty()) return Result.fail(Failure.EMPTY_SEGMENT, 0, "lexical spelling is empty");

        IdentifierProfile profile = IdentifierProfile.forVendor(vendor, IdentifierProfile.VendorFlags.defaults());
        boolean quoted = IdentifierCodec.isQuoted(profile, role, lexical);

        if (!quoted && IdentifierCodec.isVendorValidSpelling(profile, role, lexical)) {
            if (policy == QuotePolicy.WHEN_NEEDED || !IdentifierCodec.hasQuotedForm(profile, role)) {
                return Result.ok(lexical);
            }
            // ALWAYS: a delimited spelling is wanted, and it must be PROVEN to name the same
            // object as the bare word. Try the text as written first (right wherever case is
            // not observable through quoting), then the name service's fold (right for Oracle).
            String asWritten = IdentifierCodec.encodeStored(profile, role, lexical);
            if (SQLUtil.sameName(vendor, role, lexical, asWritten)) {
                return Result.ok(asWritten);
            }
            try {
                String folded = new IdentifierService(profile, null).normalizeSegment(lexical, role);
                if (folded != null && !folded.isEmpty()) {
                    String foldedQuoted = IdentifierCodec.encodeStored(profile, role, folded);
                    if (SQLUtil.sameName(vendor, role, lexical, foldedQuoted)) {
                        return Result.ok(foldedQuoted);
                    }
                }
            } catch (RuntimeException e) {
                // fall through
            }
            return Result.ok(lexical);   // no provable delimited form; the bare word is still valid
        }

        if (!quoted) {
            // Neither a valid bare word nor a delimited spelling this vendor recognizes: a DAX
            // string-named column ("Name"), a composite listing label. It is not an identifier
            // this class can vouch for, so it is refused rather than wrapped in delimiters.
            return Result.fail(Failure.NOT_REPRESENTABLE, 0, "not an identifier spelling for " + vendor);
        }
        String stored;
        try {
            stored = IdentifierCodec.decodeLexical(profile, role, lexical);
        } catch (RuntimeException e) {
            return Result.fail(Failure.NOT_REPRESENTABLE, 0, "malformed delimited spelling: " + e.getMessage());
        }
        return generate(vendor, policy, Segment.of(role, stored));
    }

    /** Convenience for callers holding an immutable segment list. */
    public static Result generate(EDbVendor vendor, List<Segment> segments) {
        return generate(vendor, QuotePolicy.ALWAYS,
                segments == null ? null : Collections.unmodifiableList(segments));
    }
}