package gudusoft.gsqlparser.resolver2.format;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.sqlenv.ESQLDataObjectType;
import gudusoft.gsqlparser.sqlenv.IdentifierService;

import java.util.AbstractSet;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

/**
 * The lines of a {@code Fields:} style listing, de-duplicated so that two DIFFERENT objects
 * are never folded into one line.
 *
 * <p>The listings folded rendered lines case-insensitively. For a case-sensitive name that
 * deletes output: BigQuery {@code Sales.amount} and {@code SALES.amount} are columns of two
 * different tables, yet only one line was printed and nothing said a column had gone.</p>
 *
 * <p>This set changes exactly one thing: lines that differ only by case AND whose stated
 * identities differ are kept apart. Byte-identical lines still fold. Everything else folds as it always did — lines still compare case-insensitively,
 * and a line added without an identity (a star entry, an orphan's {@code missed.} line, a
 * constraint column) still folds with any line of the same text, because nothing proves it
 * stands for a separate object. So the set can only ever print MORE lines than before, never
 * fewer.</p>
 */
public final class IdentityLineSet extends AbstractSet<String> {

    private static final Object OPAQUE = new Object();

    /** Case-insensitive text -> (identity -> first spelling seen), in arrival order. */
    // non-identifier-compare: rendered listing lines, folded exactly as the listings always did
    private final Map<String, Map<Object, String>> buckets =
            new TreeMap<String, Map<Object, String>>(String.CASE_INSENSITIVE_ORDER);

    /** Add a line with no stated identity; it folds with any line of the same text. */
    @Override
    public boolean add(String line) {
        return add(line, null);
    }

    /**
     * Add a line for a stated object.
     *
     * @param identity what the line stands for, from {@link #fieldIdentity}; null when unknown
     */
    public boolean add(String line, Object identity) {
        if (line == null) return false;
        Map<Object, String> bucket = buckets.get(line);
        if (bucket == null) {
            bucket = new LinkedHashMap<Object, String>();
            buckets.put(line, bucket);
        }
        Object key = identity != null ? identity : OPAQUE;
        if (bucket.containsKey(key)) return false;
        // Byte-identical text always folds, whatever the identities: two identical lines tell
        // the reader nothing, and the same object can reach the listing from two places that
        // state its identity differently. Only lines that DIFFER (by case) are worth keeping
        // apart, and only when they stand for different objects.
        if (bucket.containsValue(line)) return false;       // exact text, not an identifier compare
        if (key == OPAQUE && !bucket.isEmpty()) return false;       // folds into a stated line
        if (key != OPAQUE && bucket.size() == 1 && bucket.containsKey(OPAQUE)) {
            // The unstated line seen earlier is now accounted for by this object.
            String spelling = bucket.remove(OPAQUE);
            bucket.put(key, spelling);
            return false;
        }
        bucket.put(key, line);
        return true;
    }

    @Override
    public boolean contains(Object o) {
        return o instanceof String && buckets.containsKey(o);
    }

    @Override
    public Iterator<String> iterator() {
        List<String> lines = new ArrayList<String>();
        for (Map<Object, String> bucket : buckets.values()) {
            lines.addAll(bucket.values());
        }
        return lines.iterator();
    }

    @Override
    public int size() {
        int n = 0;
        for (Map<Object, String> bucket : buckets.values()) n += bucket.size();
        return n;
    }

    @Override
    public void clear() {
        buckets.clear();
    }

    /**
     * Identity of a {@code table.column} line, from the SQL spellings and the vendor's rules.
     * The two parts are keyed under their own object types because a vendor can treat them
     * differently: BigQuery compares table names case-sensitively and column names not.
     *
     * @param tableLexical  the table name as written in SQL (may be qualified); null or empty
     *                      when the line's prefix is not a named table
     * @param tableFallback text standing for the prefix when there is no table name
     * @param columnLexical the column name as written in SQL
     * @return an identity for {@link #add(String, Object)}, or null when none can be stated
     */
    public static Object fieldIdentity(EDbVendor vendor, String tableLexical, String tableFallback,
                                       String columnLexical) {
        if (vendor == null || columnLexical == null || columnLexical.isEmpty()) return null;
        try {
            Object table = (tableLexical != null && !tableLexical.isEmpty())
                    ? IdentifierService.qualifiedCanonKeyFromLexicalStatic(vendor,
                            ESQLDataObjectType.dotTable, tableLexical)
                    : Arrays.<Object>asList("prefix", tableFallback);
            Object column = IdentifierService.qualifiedCanonKeyFromLexicalStatic(vendor,
                    ESQLDataObjectType.dotColumn, columnLexical);
            return Arrays.asList(table, column);
        } catch (RuntimeException e) {
            // A spelling the name service rejects: state no identity, fold by text as before.
            return null;
        }
    }
}