pragma Singleton

import QtQuick
import Quickshell
import Quickshell.Io
import "UnitConverter.js" as UnitConverter

QtObject {
    id: root

    property bool visible: false
    property string query: ""
    property string debouncedQuery: ""
    property int selectedIndex: 0

    onQueryChanged: debounceTimer.restart()

    property Timer debounceTimer: Timer {
        interval: 80
        repeat: false
        onTriggered: root.debouncedQuery = root.query
    }

    readonly property var allEntries: {
        const out = [];
        const apps = DesktopEntries.applications;
        const n = apps.values ? apps.values.length : apps.count;
        for (let i = 0; i < n; i++) {
            const e = apps.values ? apps.values[i] : apps.get(i);
            if (!e || e.noDisplay) continue;
            out.push(e);
        }
        out.sort((a, b) => (a.name || "").localeCompare(b.name || ""));
        return out;
    }

    readonly property var filtered: {
        const raw = (debouncedQuery || "").trim();
        if (!raw) return allEntries;

        // Command-prefix dispatch. Each command returns synthetic entries
        // shaped like DesktopEntry (name, icon, comment) plus an internal
        // `_copy` field used by launch().
        if (raw.startsWith("=")) return calcResults(raw.substring(1).trim());
        if (raw.startsWith(".")) return unicodeResults(raw.substring(1).trim());
        if (raw.startsWith("!")) return gifResults(raw.substring(1).trim());

        const q = raw.toLowerCase();
        const scored = [];
        for (let i = 0; i < allEntries.length; i++) {
            const e = allEntries[i];
            const s = fuzzyScore(q, (e.name || "").toLowerCase(),
                                    (e.genericName || "").toLowerCase(),
                                    (e.comment || "").toLowerCase());
            if (s > 0) scored.push({ entry: e, score: s });
        }
        scored.sort((a, b) => b.score - a.score);
        return scored.map(x => x.entry);
    }

    // Unicode lookup: lazy-dumped once via Python's unicodedata, then filtered
    // in-memory by name substring.
    property var unicodeData: null  // [{ ch, name }, ...]
    property bool unicodeLoading: false

    function ensureUnicodeLoaded() {
        if (unicodeData !== null || unicodeLoading) return;
        unicodeLoading = true;
        unicodeProc.running = false;
        unicodeProc.running = true;
    }

    function unicodeResults(q) {
        ensureUnicodeLoaded();
        if (!unicodeData || unicodeData.length === 0 || q.length < 2) {
            const hint = unicodeLoading ? "Loading unicode database…"
                       : (!q ? "Type to search unicode (min 2 chars)"
                       : q.length < 2 ? "Type at least 2 characters…" : "");
            return hint ? [{ name: hint, genericName: "", comment: "",
                             icon: "accessories-character-map" }] : [];
        }
        const ql = q.toUpperCase();
        const out = [];
        const limit = 50;
        const t0 = Date.now();
        for (let i = 0; i < unicodeData.length && out.length < limit; i++) {
            const e = unicodeData[i];
            if (e.name.indexOf(ql) >= 0) {
                const cp = e.ch.codePointAt(0).toString(16).toUpperCase();
                out.push({
                    name: e.name,
                    genericName: "U+" + cp.padStart(4, "0"),
                    comment: "Press Enter to copy",
                    icon: "",
                    _noIcon: true,
                    _glyph: e.ch,
                    _copy: e.ch
                });
            }
        }
        console.log("unicode filter '" + q + "' →", out.length, "results in", (Date.now() - t0), "ms (scanned", unicodeData.length, "entries)");
        return out;
    }

    property Process unicodeProc: Process {
        command: ["python3", "-c",
            "import unicodedata,sys\n" +
            "for cp in range(0x110000):\n" +
            "  try: n = unicodedata.name(chr(cp))\n" +
            "  except ValueError: continue\n" +
            "  sys.stdout.write(f'{cp:X}\\t{n}\\n')\n"]
        running: false
        stdout: StdioCollector {
            onStreamFinished: {
                const t0 = Date.now();
                const lines = this.text.split("\n");
                const out = [];
                for (let i = 0; i < lines.length; i++) {
                    const tab = lines[i].indexOf("\t");
                    if (tab <= 0) continue;
                    const cp = parseInt(lines[i].substring(0, tab), 16);
                    if (!cp) continue;
                    out.push({ ch: String.fromCodePoint(cp), name: lines[i].substring(tab + 1) });
                }
                root.unicodeData = out;
                root.unicodeLoading = false;
                console.log("unicode load: parsed", out.length, "entries in", (Date.now() - t0), "ms");
            }
        }
    }

    // In-memory currency rate cache: { "<YYYY-MM-DD>_<BASE>": { TGT: rate, ... } }
    // Populated lazily when a currency query is typed; the same day's table is
    // reused for any further conversions from that base.
    property var currencyRates: ({})
    property string currencyFetching: ""  // "<date>_<base>" currently in flight, "" if idle

    function todayKey() {
        return new Date().toISOString().substring(0, 10);
    }

    function fetchCurrency(base) {
        const key = todayKey() + "_" + base;
        if (currencyRates[key] || currencyFetching === key) return;
        currencyFetching = key;
        currencyProc.command = ["curl", "-sSL", "--max-time", "5",
            "https://api.frankfurter.dev/v1/latest?base=" + base];
        currencyProc.running = true;
    }

    property Process currencyProc: Process {
        command: []
        running: false
        stdout: StdioCollector {
            onStreamFinished: {
                root.currencyFetching = "";
                try {
                    const data = JSON.parse(this.text);
                    if (!data || !data.base || !data.rates) return;
                    // Cache under today's date (the request-side key), not
                    // data.date — Frankfurter reports the last *business* day,
                    // which won't match today on weekends/holidays and would
                    // cause a perpetual cache miss + refetch loop.
                    const key = root.todayKey() + "_" + data.base;
                    const updated = Object.assign({}, root.currencyRates);
                    const rates = Object.assign({}, data.rates);
                    rates[data.base] = 1;
                    updated[key] = rates;
                    root.currencyRates = updated;
                } catch (e) {
                    console.log("currency: parse failed:", e);
                }
            }
        }
    }

    function formatConv(v) {
        return Number.isInteger(v) ? String(v) : String(+v.toPrecision(10));
    }

    function formatMoney(v) {
        return (Math.round(v * 100) / 100).toFixed(2);
    }

    function convEntry(conv, expr) {
        const text = formatConv(conv.value);
        return {
            name: text + " " + conv.to,
            genericName: "= " + expr + (expr.match(/\s(to|in|->)(\s|$)/i) ? "" : " (" + conv.from + " → " + conv.to + ")"),
            comment: "Press Enter to copy",
            icon: "accessories-calculator",
            _copy: text
        };
    }

    function currencyResults(parsed, expr) {
        const base = parsed.from.toUpperCase();
        const key = todayKey() + "_" + base;
        const rates = currencyRates[key];
        if (!rates) {
            fetchCurrency(base);
            return [{
                name: "Fetching rates…",
                genericName: "= " + expr,
                comment: base + " — Frankfurter",
                icon: "accessories-calculator"
            }];
        }
        const convs = UnitConverter.currencyConvert(parsed.amount, base, parsed.partial, rates);
        return convs.map(c => {
            const text = formatMoney(c.value);
            return {
                name: text + " " + c.to,
                genericName: "= " + expr,
                comment: "Press Enter to copy",
                icon: "accessories-calculator",
                _copy: text
            };
        });
    }

    function calcResults(expr) {
        if (!expr) return [];
        const conv = UnitConverter.convert(expr);
        if (conv) return [convEntry(conv, expr)];
        const parsed = UnitConverter.parseQuery(expr);
        if (parsed && UnitConverter.isCurrency(parsed.from)) return currencyResults(parsed, expr);
        const suggestions = UnitConverter.suggest(expr);
        if (suggestions) return suggestions.map(c => convEntry(c, expr));
        // Whitelist: digits, operators, parens, dot, comma, whitespace,
        // and identifiers (for Math.* / pi / e). Reject anything else.
        if (!/^[0-9a-zA-Z_+\-*/%().,\s^!]+$/.test(expr)) return [];
        let src = expr.replace(/\^/g, "**");
        try {
            const fn = new Function("Math", "pi", "e",
                "\"use strict\"; return (" + src + ");");
            const v = fn(Math, Math.PI, Math.E);
            if (typeof v !== "number" || !isFinite(v)) return [];
            const text = Number.isInteger(v) ? String(v) : String(+v.toFixed(10));
            return [{
                name: text,
                genericName: "= " + expr,
                comment: "Press Enter to copy",
                icon: "accessories-calculator",
                _copy: text
            }];
        } catch (_) {
            return [];
        }
    }

    // GIF search (Giphy v1). Key comes from Config (config.json -> giphyApiKey).
    // Results are cached per-query for the session. Each result exposes
    // `_isGif`, `_previewUrl` (small animated preview), `_ratio` (h/w for
    // masonry packing), and `_copy` (the direct .gif URL — what FB Messenger
    // / Discord / etc. need to inline the animation).
    readonly property string gifApiKey: Config.giphyApiKey
    readonly property bool gifApiKeyLoaded: Config.loaded
    property var gifCache: ({})
    property string gifFetching: ""

    readonly property bool gifMode: (debouncedQuery || "").trim().startsWith("!")

    function fetchGifs(q) {
        if (!gifApiKey || !q || gifCache[q] || gifFetching === q) return;
        gifFetching = q;
        gifProc.command = ["curl", "-sSL", "--max-time", "8",
            "https://api.giphy.com/v1/gifs/search?api_key=" + gifApiKey +
            "&q=" + encodeURIComponent(q) +
            "&limit=24&rating=pg-13&bundle=messaging_non_clips"];
        gifProc.running = true;
    }

    property Process gifProc: Process {
        command: []
        running: false
        stdout: StdioCollector {
            onStreamFinished: {
                const q = root.gifFetching;
                root.gifFetching = "";
                if (!q) return;
                try {
                    const data = JSON.parse(this.text);
                    if (!data || !data.data) return;
                    const out = [];
                    for (let i = 0; i < data.data.length; i++) {
                        const r = data.data[i];
                        const imgs = r.images || {};
                        // Preview: fixed_width (200px wide, animated) is the
                        // standard small-grid asset. fixed_width_small (100px)
                        // is even lighter but blurs at column widths > 160px.
                        const prev = imgs.fixed_width || imgs.fixed_width_small
                                  || imgs.preview_gif || imgs.original;
                        const full = imgs.original;
                        if (!prev || !prev.url || !full || !full.url) continue;
                        const w = parseFloat(full.width) || 1;
                        const h = parseFloat(full.height) || 1;
                        out.push({
                            name: r.title || "GIF",
                            _isGif: true,
                            _previewUrl: prev.url,
                            _ratio: w > 0 ? h / w : 1,
                            _copy: full.url
                        });
                    }
                    const updated = Object.assign({}, root.gifCache);
                    updated[q] = out;
                    root.gifCache = updated;
                } catch (e) {
                    console.log("gif: parse failed:", e);
                }
            }
        }
    }

    function gifResults(q) {
        if (!gifApiKeyLoaded) {
            return [{ name: "Loading config…", genericName: "",
                      comment: "~/.config/omni-launcher/config.json",
                      icon: "image-x-generic" }];
        }
        if (!gifApiKey) {
            return [{ name: "Missing Giphy API key",
                      genericName: "~/.config/omni-launcher/config.json",
                      comment: "Set \"giphyApiKey\" in config.json.",
                      icon: "dialog-warning" }];
        }
        if (!q) {
            return [{ name: "Type to search Giphy…", genericName: "",
                      comment: "", icon: "image-x-generic" }];
        }
        const cached = gifCache[q];
        if (!cached) {
            fetchGifs(q);
            return [{ name: "Searching Giphy…", genericName: "",
                      comment: q, icon: "image-x-generic" }];
        }
        return cached;
    }

    // Masonry packing: 3 columns, each item appended to the leftmost
    // shortest column. Tracks cumulative h/w ratio per column — column
    // widths are equal so ratio sum is proportional to rendered height.
    // Adds `_globalIndex` to each entry so the delegate can compare against
    // `selectedIndex` regardless of column placement.
    readonly property var gifColumns: {
        const empty = [[], [], []];
        if (!gifMode) return empty;
        const items = filtered;
        if (!items || items.length === 0 || !items[0]._isGif) return empty;
        const cols = [[], [], []];
        const heights = [0, 0, 0];
        for (let i = 0; i < items.length; i++) {
            const it = items[i];
            if (!it._isGif) continue;
            let pick = 0;
            for (let j = 1; j < 3; j++) if (heights[j] < heights[pick]) pick = j;
            cols[pick].push(Object.assign({}, it, { _globalIndex: i }));
            heights[pick] += it._ratio || 1;
        }
        return cols;
    }

    function fuzzyScore(q, name, generic, comment) {
        const nameIdx = name.indexOf(q);
        if (nameIdx === 0) return 1000 - name.length;
        if (nameIdx > 0) return 500 - name.length + (name[nameIdx - 1] === ' ' ? 200 : 0);
        if (generic.indexOf(q) >= 0) return 200;
        if (comment.indexOf(q) >= 0) return 100;
        // Subsequence match in name with word-start bonuses.
        let qi = 0, score = 0, prev = ' ';
        for (let i = 0; i < name.length && qi < q.length; i++) {
            if (name[i] === q[qi]) {
                score += 1;
                if (prev === ' ' || prev === '-' || prev === '_' || prev === '.') score += 5;
                qi++;
            }
            prev = name[i];
        }
        return qi === q.length ? score : 0;
    }

    function open() {
        query = "";
        debouncedQuery = "";
        debounceTimer.stop();
        selectedIndex = 0;
        visible = true;
    }

    function close() {
        visible = false;
        query = "";
        debouncedQuery = "";
        debounceTimer.stop();
        selectedIndex = 0;
    }

    function toggle() {
        if (visible) close(); else open();
    }

    function launchSelected() {
        const list = filtered;
        if (selectedIndex < 0 || selectedIndex >= list.length) return;
        launch(list[selectedIndex]);
    }

    function launch(entry) {
        if (!entry) return;
        close();
        if (entry._isGif && entry._copy) {
            // Save the .gif to a temp file and put a text/uri-list entry on
            // the clipboard. Web apps (Discord, Messenger) translate file-URI
            // pastes into the file-upload flow and preserve animation, which
            // they do NOT do for image/gif blob pastes.
            copyProc.running = false;
            copyProc.command = ["bash", "-c",
                "f=$(mktemp --suffix=.gif) && " +
                "curl -sSL --max-time 15 \"$1\" -o \"$f\" && " +
                "printf 'file://%s\\r\\n' \"$f\" | wl-copy --type text/uri-list",
                "_", String(entry._copy)];
            copyProc.running = true;
            return;
        }
        if (entry._copy !== undefined) {
            copyProc.running = false;
            copyProc.command = ["wl-copy", "--", String(entry._copy)];
            copyProc.running = true;
            return;
        }
        if (entry.execute) entry.execute();
    }

    property Process copyProc: Process {
        command: []
        running: false
    }
}