package gudusoft.gsqlparser.pp2.island;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.pp.logger.PPLogger;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Per-vendor table of multi-word SQL keyword phrases that the lexical island
 * pipeline treats as a single keyword unit (e.g. {@code LEFT OUTER JOIN},
 * {@code UNION ALL}, {@code GROUP BY}).
 *
 * <h2>Resource format</h2>
 *
 * <p>The phrases are declared in {@code /pp2/keywords.properties} on the
 * classpath. {@code org.json} is not available to {@code gsp_java_core}, so a
 * line-based format is used instead of {@code keywords.json} (plan §5.5 and
 * forbidden action #8 — no new third-party dependency). Each rule line is:
 *
 * <pre>
 *   &lt;SCOPE&gt;: &lt;phrase&gt; | &lt;phrase&gt; | ...
 * </pre>
 *
 * where {@code SCOPE} is {@code ALL} or an {@link EDbVendor} enum constant name
 * (e.g. {@code dbvoracle}). Blank lines and {@code #} comments are ignored.
 *
 * <h2>Caching</h2>
 *
 * <p>The resource is parsed <b>once per JVM</b> into an immutable base model
 * (eager class-init). {@link #forVendor(EDbVendor)} returns an immutable,
 * longest-phrase-first {@link Phrase} list, memoised per vendor via
 * {@link ConcurrentHashMap#computeIfAbsent}. {@link #getLoadCount()} exposes how
 * many times the resource file itself was parsed (always 1 in a healthy JVM);
 * the S18 test asserts this.
 *
 * <p>Plan reference: §7.3/S18, §7.4/S18.
 */
public final class MultiWordKeywordTable {

    /** Classpath location of the line-based phrase resource. */
    static final String RESOURCE_PATH = "/pp2/keywords.properties";

    /** Scope token meaning "applies to every dialect". */
    private static final String SCOPE_ALL = "ALL";

    /** Valid vendor-scope keys: every {@link EDbVendor} constant name, lower-cased. */
    private static final Set<String> VALID_VENDOR_KEYS = buildValidVendorKeys();

    /** Counts how many times the resource file was parsed (should be 1/JVM). */
    private static final AtomicInteger LOAD_COUNT = new AtomicInteger(0);

    /** Phrases that apply to every dialect (longest-first). */
    private static final List<Phrase> ALL_PHRASES;

    /** Vendor-scope name (lower-cased enum constant) -> its extra phrases. */
    private static final Map<String, List<Phrase>> VENDOR_PHRASES;

    /** Per-vendor memoised merged (ALL + vendor) lists, longest-first. */
    private static final ConcurrentHashMap<EDbVendor, List<Phrase>> PER_VENDOR_CACHE =
        new ConcurrentHashMap<EDbVendor, List<Phrase>>();

    static {
        ParsedTable parsed = loadFromResource();
        ALL_PHRASES = Collections.unmodifiableList(parsed.allPhrases);
        VENDOR_PHRASES = Collections.unmodifiableMap(parsed.vendorPhrases);
    }

    private MultiWordKeywordTable() {
        // static-only utility
    }

    /**
     * Return the immutable, longest-phrase-first list of multi-word keyword
     * phrases applicable to {@code vendor} (the universal {@code ALL} phrases
     * plus any vendor-specific ones). Memoised per vendor.
     *
     * @throws NullPointerException if {@code vendor} is null
     */
    public static List<Phrase> forVendor(EDbVendor vendor) {
        if (vendor == null) throw new NullPointerException("vendor");
        List<Phrase> cached = PER_VENDOR_CACHE.get(vendor);
        if (cached != null) return cached;
        return PER_VENDOR_CACHE.computeIfAbsent(vendor, new java.util.function.Function<EDbVendor, List<Phrase>>() {
            @Override
            public List<Phrase> apply(EDbVendor v) {
                List<Phrase> merged = new ArrayList<Phrase>(ALL_PHRASES);
                List<Phrase> vendorSpecific = VENDOR_PHRASES.get(v.name().toLowerCase(Locale.ROOT));
                if (vendorSpecific != null) merged.addAll(vendorSpecific);
                Collections.sort(merged, LONGEST_FIRST);
                return Collections.unmodifiableList(merged);
            }
        });
    }

    /** Number of times the resource file was parsed (1 in a healthy JVM). */
    public static int getLoadCount() {
        return LOAD_COUNT.get();
    }

    /** Sort phrases by descending word count so the merger matches longest-first. */
    private static final Comparator<Phrase> LONGEST_FIRST = new Comparator<Phrase>() {
        @Override
        public int compare(Phrase a, Phrase b) {
            return b.getWords().size() - a.getWords().size();
        }
    };

    // ---- resource parsing ----------------------------------------------

    private static Set<String> buildValidVendorKeys() {
        Set<String> keys = new HashSet<String>();
        for (EDbVendor v : EDbVendor.values()) {
            keys.add(v.name().toLowerCase(Locale.ROOT));
        }
        return Collections.unmodifiableSet(keys);
    }

    private static ParsedTable loadFromResource() {
        LOAD_COUNT.incrementAndGet();
        ParsedTable table = new ParsedTable();
        InputStream in = MultiWordKeywordTable.class.getResourceAsStream(RESOURCE_PATH);
        if (in == null) {
            PPLogger.info("MultiWordKeywordTable: resource " + RESOURCE_PATH
                + " not found on classpath; multi-word keyword merging disabled.");
            return table;
        }
        BufferedReader reader = new BufferedReader(
            new InputStreamReader(in, Charset.forName("UTF-8")));
        try {
            String line;
            while ((line = reader.readLine()) != null) {
                parseLine(line, table);
            }
        } catch (IOException e) {
            PPLogger.error(e);
            PPLogger.info("MultiWordKeywordTable: failed reading " + RESOURCE_PATH
                + "; using whatever was parsed so far.");
        } finally {
            try { reader.close(); } catch (IOException ignored) { /* nothing to do */ }
        }
        return table;
    }

    private static void parseLine(String rawLine, ParsedTable table) {
        String line = rawLine.trim();
        if (line.isEmpty() || line.charAt(0) == '#') return;

        int colon = line.indexOf(':');
        if (colon < 0) {
            PPLogger.info("MultiWordKeywordTable: ignoring malformed line (no scope ':'): " + rawLine);
            return;
        }
        String scope = line.substring(0, colon).trim();
        String body = line.substring(colon + 1).trim();
        if (scope.isEmpty() || body.isEmpty()) return;

        List<Phrase> target;
        if (SCOPE_ALL.equalsIgnoreCase(scope)) {
            target = table.allPhrases;
        } else {
            String key = scope.toLowerCase(Locale.ROOT);
            if (!VALID_VENDOR_KEYS.contains(key)) {
                // A typo'd vendor scope would silently create a dead phrase
                // list (it could never be looked up by a real EDbVendor). For
                // an allowlist whose correctness depends on exact vendor
                // scoping, surface it instead of swallowing it.
                PPLogger.info("MultiWordKeywordTable: ignoring rule with unknown vendor scope '"
                    + scope + "' (not an EDbVendor constant): " + rawLine);
                return;
            }
            target = table.vendorPhrases.get(key);
            if (target == null) {
                target = new ArrayList<Phrase>();
                table.vendorPhrases.put(key, target);
            }
        }

        for (String chunk : body.split("\\|")) {
            Phrase phrase = Phrase.parse(chunk);
            if (phrase != null) target.add(phrase);
        }
    }

    /** Mutable accumulator used only during parsing. */
    private static final class ParsedTable {
        final List<Phrase> allPhrases = new ArrayList<Phrase>();
        final Map<String, List<Phrase>> vendorPhrases = new LinkedHashMap<String, List<Phrase>>();
    }

    /**
     * An immutable multi-word keyword phrase: its lower-cased words (for
     * matching) and an upper-cased canonical rendering (for reporting/merging).
     */
    public static final class Phrase {
        private final List<String> words;       // lower-cased, for matching
        private final String canonical;         // upper-cased, space-joined

        private Phrase(List<String> words, String canonical) {
            this.words = Collections.unmodifiableList(words);
            this.canonical = canonical;
        }

        /** Parse one " WORD WORD ..." chunk; returns null if it has no words. */
        static Phrase parse(String chunk) {
            String trimmed = chunk.trim();
            if (trimmed.isEmpty()) return null;
            String[] parts = trimmed.split("\\s+");
            List<String> lower = new ArrayList<String>(parts.length);
            StringBuilder canon = new StringBuilder();
            for (String p : parts) {
                if (p.isEmpty()) continue;
                if (canon.length() > 0) canon.append(' ');
                canon.append(p.toUpperCase(Locale.ROOT));
                lower.add(p.toLowerCase(Locale.ROOT));
            }
            if (lower.isEmpty()) return null;
            return new Phrase(lower, canon.toString());
        }

        /** The phrase's lower-cased words, in order. */
        public List<String> getWords() { return words; }

        /** Upper-cased, single-space-joined canonical form (e.g. "LEFT OUTER JOIN"). */
        public String getCanonical() { return canonical; }

        @Override
        public String toString() { return "Phrase[" + canonical + "]"; }
    }
}