pragma Singleton

import QtQuick
import QtQuick.Controls
import Quickshell
import Quickshell.Io
import qs.Commons

Singleton {
  id: root

  property ListModel availableFonts: ListModel {}
  property ListModel monospaceFonts: ListModel {}
  property ListModel displayFonts: ListModel {}
  property bool fontsLoaded: false
  property bool isLoading: false

  // Use objects for O(1) lookup instead of arrays
  property var fontconfigMonospaceFonts: ({})

  // Cache for font classification to avoid repeated checks
  property var fontCache: ({})

  // Chunk size for async processing
  readonly property int chunkSize: 100

  // -------------------------------------------
  function init() {
    Logger.i("Font", "Service started")
    loadFontconfigMonospaceFonts()
  }

  function loadFontconfigMonospaceFonts() {
    fontconfigProcess.command = ["fc-list", ":mono", "family"]
    fontconfigProcess.running = true
  }

  function loadSystemFonts() {
    if (isLoading)
      return

    Logger.d("Font", "Loading system fonts...")
    isLoading = true

    var fontFamilies = Qt.fontFamilies()

    // Pre-sort fonts before processing to ensure consistent order
    fontFamilies.sort(function (a, b) {
      return a.localeCompare(b)
    })

    // Clear existing models
    availableFonts.clear()
    monospaceFonts.clear()
    displayFonts.clear()
    fontCache = {}

    // Process fonts in chunks to avoid blocking
    processFontsAsync(fontFamilies, 0)
  }

  function processFontsAsync(fontFamilies, startIndex) {
    var endIndex = Math.min(startIndex + chunkSize, fontFamilies.length)
    var hasMore = endIndex < fontFamilies.length

    // Batch arrays to append all at once (much faster than individual appends)
    var availableBatch = []
    var monospaceBatch = []
    var displayBatch = []

    for (var i = startIndex; i < endIndex; i++) {
      var fontName = fontFamilies[i]
      if (!fontName || fontName.trim() === "")
        continue

      // Add to available fonts
      var fontObj = {
        "key": fontName,
        "name": fontName
      }
      availableBatch.push(fontObj)

      // Check monospace (with caching)
      if (isMonospaceFont(fontName)) {
        monospaceBatch.push(fontObj)
      }

      // Check display font (with caching)
      if (isDisplayFont(fontName)) {
        displayBatch.push(fontObj)
      }
    }

    // Batch append to models
    batchAppendToModel(availableFonts, availableBatch)
    batchAppendToModel(monospaceFonts, monospaceBatch)
    batchAppendToModel(displayFonts, displayBatch)

    if (hasMore) {
      // Continue processing in next frame
      Qt.callLater(function () {
        processFontsAsync(fontFamilies, endIndex)
      })
    } else {
      // Finished loading all fonts
      finalizeFontLoading()
    }
  }

  function batchAppendToModel(model, items) {
    for (var i = 0; i < items.length; i++) {
      model.append(items[i])
    }
  }

  function finalizeFontLoading() {
    // Add fallbacks if needed (models are already sorted)
    if (monospaceFonts.count === 0) {
      addFallbackFonts(monospaceFonts, ["DejaVu Sans Mono"])
    }

    if (displayFonts.count === 0) {
      addFallbackFonts(displayFonts, ["Inter", "Roboto", "DejaVu Sans"])
    }

    fontsLoaded = true
    isLoading = false
    Logger.d("Font", "Loaded", availableFonts.count, "fonts:", monospaceFonts.count, "monospace,", displayFonts.count, "display")
  }

  function isMonospaceFont(fontName) {
    // Check cache first
    if (fontCache.hasOwnProperty(fontName)) {
      return fontCache[fontName].isMonospace
    }

    var result = false

    // O(1) lookup using object instead of indexOf
    if (fontconfigMonospaceFonts.hasOwnProperty(fontName)) {
      result = true
    } else {
      // Fallback: check for basic monospace patterns
      var lowerFontName = fontName.toLowerCase()
      if (lowerFontName.includes("mono") || lowerFontName.includes("monospace")) {
        result = true
      }
    }

    // Cache the result
    if (!fontCache[fontName]) {
      fontCache[fontName] = {}
    }
    fontCache[fontName].isMonospace = result

    return result
  }

  function isDisplayFont(fontName) {
    // Check cache first
    if (fontCache.hasOwnProperty(fontName) && fontCache[fontName].hasOwnProperty('isDisplay')) {
      return fontCache[fontName].isDisplay
    }

    var result = false
    var lowerFontName = fontName.toLowerCase()

    if (lowerFontName.includes("display") || lowerFontName.includes("headline") || lowerFontName.includes("title")) {
      result = true
    }

    // Essential fallback fonts only
    var essentialFonts = ["Inter", "Roboto", "DejaVu Sans"]
    if (essentialFonts.indexOf(fontName) !== -1) {
      result = true
    }

    // Cache the result
    if (!fontCache[fontName]) {
      fontCache[fontName] = {}
    }
    fontCache[fontName].isDisplay = result

    return result
  }

  function sortModel(model) {
    // Convert to array
    var fontsArray = []
    for (var i = 0; i < model.count; i++) {
      fontsArray.push({
                        "key": model.get(i).key,
                        "name": model.get(i).name
                      })
    }

    // Sort
    fontsArray.sort(function (a, b) {
      return a.name.localeCompare(b.name)
    })

    // Clear and rebuild
    model.clear()
    batchAppendToModel(model, fontsArray)
  }

  function addFallbackFonts(model, fallbackFonts) {
    // Build a set of existing fonts for O(1) lookup
    var existingFonts = {}
    for (var i = 0; i < model.count; i++) {
      existingFonts[model.get(i).name] = true
    }

    var toAdd = []
    for (var j = 0; j < fallbackFonts.length; j++) {
      var fontName = fallbackFonts[j]
      if (!existingFonts[fontName]) {
        toAdd.push({
                     "key": fontName,
                     "name": fontName
                   })
      }
    }

    if (toAdd.length > 0) {
      batchAppendToModel(model, toAdd)
      sortModel(model)
    }
  }

  function searchFonts(query) {
    if (!query || query.trim() === "")
      return availableFonts

    var results = []
    var lowerQuery = query.toLowerCase()

    for (var i = 0; i < availableFonts.count; i++) {
      var font = availableFonts.get(i)
      if (font.name.toLowerCase().includes(lowerQuery)) {
        results.push(font)
      }
    }

    return results
  }

  // Process for fontconfig commands
  Process {
    id: fontconfigProcess
    running: false

    stdout: StdioCollector {
      onStreamFinished: {
        if (this.text !== "") {
          var lines = this.text.split('\n')
          // Use object for O(1) lookup instead of array
          var monospaceLookup = {}

          for (var i = 0; i < lines.length; i++) {
            var line = lines[i].trim()
            if (line && line !== "") {
              monospaceLookup[line] = true
            }
          }

          fontconfigMonospaceFonts = monospaceLookup
        }
        loadSystemFonts()
      }
    }

    onExited: function (exitCode, exitStatus) {
      if (exitCode !== 0) {
        fontconfigMonospaceFonts = {}
      }
      loadSystemFonts()
    }
  }
}