package gudusoft.gsqlparser.resolver2.format;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.sqlenv.ESQLDataObjectType;
import gudusoft.gsqlparser.nodes.TObjectName;
import gudusoft.gsqlparser.sqlenv.IdentifierService;
import gudusoft.gsqlparser.sqlenv.SqlNameGenerator;
import gudusoft.gsqlparser.sqlenv.TSQLEnv;
import gudusoft.gsqlparser.sqlenv.TSQLTable;
import gudusoft.gsqlparser.util.SQLUtil;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

/**
 * Collects the names a listing will print and de-duplicates them by OBJECT IDENTITY, then
 * picks which spelling to print with a {@link DisplayNamePolicy}.
 *
 * <p>The listings used to de-duplicate rendered strings case-insensitively. Rendered text has
 * already lost what decides identity, so that was wrong in both directions:</p>
 * <ul>
 *   <li>it MERGED distinct objects. BigQuery table names are case-sensitive, so
 *       {@code Sales} and {@code SALES} are two tables, yet only one reached the list —
 *       a silently missing table;</li>
 *   <li>it SPLIT one object. Oracle {@code Sales}, {@code SALES} and {@code "SALES"} are one
 *       table, yet the quoted spelling printed as a second row.</li>
 * </ul>
 *
 * <p>Identity comes from the unified name service ({@link IdentifierService}), per vendor and
 * per object type — BigQuery tables compare case-sensitively while its columns do not, so the
 * caller states the type and nothing here guesses it from text.</p>
 */
public final class IdentityNameList {

    private static final class Occurrence {
        final String rendered;
        final boolean definitionSite;
        final String catalogRendered;

        Occurrence(String rendered, boolean definitionSite, String catalogRendered) {
            this.rendered = rendered;
            this.definitionSite = definitionSite;
            this.catalogRendered = catalogRendered;
        }
    }

    private final EDbVendor vendor;
    private final DisplayNamePolicy policy;
    /** Insertion-ordered so "first occurrence" means source order. */
    private final Map<Object, List<Occurrence>> groups = new LinkedHashMap<Object, List<Occurrence>>();

    public IdentityNameList(EDbVendor vendor, DisplayNamePolicy policy) {
        this.vendor = vendor != null ? vendor : EDbVendor.dbvansi;
        this.policy = policy != null ? policy : DisplayNamePolicy.PREFER_DEFINITION_SITE;
    }

    public void clear() {
        groups.clear();
    }

    public boolean isEmpty() {
        return groups.isEmpty();
    }

    /**
     * Record one occurrence of a name.
     *
     * @param rendered        the text the listing would print for this occurrence, decorations
     *                        included
     * @param lexical         the name as written in SQL (may be qualified); identity is derived
     *                        from this, never from {@code rendered}
     * @param objectType      syntactic role of {@code lexical}
     * @param decoration      any suffix the listing appended ({@code "(tetSelect)"}); two
     *                        occurrences of one object under different decorations are
     *                        different lines. May be null.
     * @param definitionSite  true when this occurrence is where the object is defined
     * @param catalogRendered how the listing would print the catalog's stored name for this
     *                        object, or null when no catalog metadata is known
     */
    public void add(String rendered, String lexical, ESQLDataObjectType objectType,
                    String decoration, boolean definitionSite, String catalogRendered) {
        if (rendered == null) return;
        Object identity = identityOf(lexical, objectType, rendered);
        Object key = java.util.Arrays.asList(identity, decoration == null ? "" : decoration);
        List<Occurrence> list = groups.get(key);
        if (list == null) {
            list = new ArrayList<Occurrence>();
            groups.put(key, list);
        }
        list.add(new Occurrence(rendered, definitionSite, catalogRendered));
    }

    /**
     * How a listing prints the catalog's stored name for a table, or null when there is no
     * catalog entry. One rule shared by every writer, so the metadata rung of the policy cannot
     * differ between them.
     *
     * <p>Only an unqualified reference is answered: a stored leaf name says nothing about how
     * the qualifiers should be spelled, and none are invented. Under
     * {@link DisplayNameMode#SQL_RENDER} the stored name is written back as SQL by
     * {@link SqlNameGenerator}, delimited only when it must be.</p>
     */
    public static String renderCatalogTableName(EDbVendor vendor, TSQLEnv sqlEnv, TObjectName tableName,
                                                DisplayNameMode mode, SqlNameGenerator.QuotePolicy quotePolicy) {
        if (vendor == null || sqlEnv == null || tableName == null) return null;
        String lexical = tableName.toString();
        if (lexical == null || lexical.isEmpty()) return null;
        TSQLTable found;
        try {
            if (SQLUtil.parseNames(lexical, vendor).size() != 1) return null;
            found = sqlEnv.searchTable(tableName);
        } catch (RuntimeException e) {
            return null;
        }
        if (found == null || found.getName() == null || found.getName().isEmpty()) return null;
        if (mode != DisplayNameMode.SQL_RENDER) return found.getName();
        SqlNameGenerator.Result r = SqlNameGenerator.generate(vendor,
                quotePolicy != null ? quotePolicy : SqlNameGenerator.QuotePolicy.WHEN_NEEDED,
                SqlNameGenerator.Segment.table(found.getName()));
        return r.isOk() ? r.getSql() : null;
    }

    /**
     * Record a line whose identity the caller cannot state (a synthesized or composite line).
     * It is de-duplicated only against an identical line, so it can never swallow a named
     * object and never be swallowed by one.
     */
    public void addOpaque(String rendered) {
        if (rendered == null) return;
        Object key = java.util.Arrays.asList("opaque", rendered);
        List<Occurrence> list = groups.get(key);
        if (list == null) {
            list = new ArrayList<Occurrence>();
            groups.put(key, list);
        }
        list.add(new Occurrence(rendered, false, null));
    }

    private Object identityOf(String lexical, ESQLDataObjectType objectType, String rendered) {
        if (lexical != null && !lexical.isEmpty() && objectType != null) {
            try {
                return IdentifierService.qualifiedCanonKeyFromLexicalStatic(vendor, objectType, lexical);
            } catch (RuntimeException e) {
                // A spelling the name service rejects still has to be listed. Fall through to
                // an exact-text identity: it can only merge with a byte-identical spelling.
            }
        }
        return java.util.Arrays.asList("text", lexical != null ? lexical : rendered);
    }

    /**
     * The lines to print: exactly ONE per object in every mode, sorted case-insensitively as
     * the listings always were.
     *
     * <p>A {@link DisplayNameMode} decides HOW a name is written and a
     * {@link DisplayNamePolicy} decides WHICH occurrence supplies the spelling; the two are
     * orthogonal and no mode is exempt from the policy. {@link DisplayNameMode#SQL_RENDER}
     * therefore prints the policy-chosen occurrence with its SQL delimiters kept, rather than
     * one row per spelling: a listing row stands for an object, and how an object with several
     * spellings is shown is the policy's question, not the mode's.</p>
     *
     * @param mode accepted for symmetry with the writers; the rendering was already applied
     *             when each occurrence was added
     */
    public List<String> resolve(DisplayNameMode mode) {
        List<String> out = new ArrayList<String>();
        for (List<Occurrence> occurrences : groups.values()) {
            out.add(choose(occurrences));
        }
        Collections.sort(out, new Comparator<String>() {
            public int compare(String a, String b) {
                // non-identifier-compare: presentation order of already de-duplicated lines
                int c = String.CASE_INSENSITIVE_ORDER.compare(a, b);
                return c != 0 ? c : a.compareTo(b);
            }
        });
        return out;
    }

    /**
     * Apply the policy's fallback chain: definition site, then catalog metadata, then first
     * occurrence. Metadata sits in the middle because without a definition site the remaining
     * spellings are arbitrary references, and "first occurrence" alone would make the printed
     * name depend on statement order.
     */
    private String choose(List<Occurrence> occurrences) {
        Occurrence first = occurrences.get(0);
        // The policy chooses AMONG spellings. When every occurrence is spelled the same there
        // is nothing to choose, and the spelling is printed as written — so a table that is
        // only ever referenced one way prints exactly as it always did, metadata or not.
        boolean oneSpelling = true;
        for (Occurrence o : occurrences) {
            if (!o.rendered.equals(first.rendered)) {   // exact text, not an identifier compare
                oneSpelling = false;
                break;
            }
        }
        if (oneSpelling || policy == DisplayNamePolicy.PREFER_FIRST_OCCURRENCE) {
            return first.rendered;
        }
        Occurrence definition = null;
        String catalog = null;
        for (Occurrence o : occurrences) {
            if (definition == null && o.definitionSite) definition = o;
            if (catalog == null && o.catalogRendered != null) catalog = o.catalogRendered;
        }
        if (policy == DisplayNamePolicy.PREFER_METADATA) {
            if (catalog != null) return catalog;
            return definition != null ? definition.rendered : first.rendered;
        }
        // PREFER_DEFINITION_SITE
        if (definition != null) return definition.rendered;
        if (catalog != null) return catalog;
        return first.rendered;
    }
}