/**
 * useLegendData — builds a unified, data-driven legend item tree
 * for ANY legend type from a single declarative config map.
 *
 * Each legend type produces an array of LegendItem:
 *   { key, label, color, count?, population?, filterKey?, children?: LegendItem[] }
 *
 * The composable reads from injected Pinia stores (dataStore, uiStore, mapStore)
 * so it works identically in both Desktop and Mobile legend shells.
 *
 * USAGE:
 *   const { items, columns, title, activeFilter, setFilter, totalCount, totalPopulation,
 *           progress }   // progress: prayer-only payload for <LegendProgressBar>, else null
 *     = useLegendData(props.legendType)
 */

import { computed, inject } from 'vue'
import { useI18n } from 'vue-i18n'
import { PRAYER_COLORS } from '../../colors/prayer-progress.js'
import { usePrayerStatistics } from '../usePrayerStatistics.js'
import { ENGAGEMENT_COLORS } from '../../colors/engagement.js'
import { ADOPTION_COLORS } from '../../colors/adoption.js'
import { getLanguageFamilyColor } from '../../colors/language-family.js'
import { getColorStrategy, COLOR_MODES } from '../../colors/_registry.js'
import { PALETTE as RELIGION_COLORS, getReligionFamily, religionFamilyLabel } from '../../colors/religion.js'
import { useLanguageFamilyLegendData } from './useLanguageFamilyLegendData.js'

const COLUMNS_SIMPLE = [] // e.g. affinity-blocs — no numeric columns

// ─── Resource palette/names (research-only strategy) ──────────────────────────
// resource is a per-map (research-only) strategy that lives in
// library/colors/resource.js (moved there in C1b) and is resolved via
// the registry (registered by the research bundle's local src/colors glob).
// Read LAZILY (inside the items computed, at call time) so registration has already
// run, and GUARDED on propertyKey — getColorStrategy silently falls back to
// language-family when a mode isn't registered on a bundle, and we must not paint
// the resource legend with the language-family palette.
function resourceStrategy() {
  const strat = getColorStrategy(COLOR_MODES.RESOURCE)
  return (strat && strat.propertyKey === 'resourceType') ? strat : null
}

// ─── Region / Bloc palettes (registry strategies — single source of truth) ───
// doxa-region and affinity-block are PER-MAP (research-only) strategies that
// live in library/colors/ and are discovered by _registry.js for every bundle, not via a
// research bundle's local src/colors glob. Read LAZILY (inside the items
// computed, at call time) so registration has already run, and GUARDED on
// propertyKey — getColorStrategy silently falls back to language-family when a
// mode isn't registered on a bundle, and we must not paint these legends with
// the language-family palette. The STRATEGY palettes win: the palettes
// previously inlined here had drifted from them (they were the bug).
function doxaRegionPalette() {
  const strat = getColorStrategy(COLOR_MODES.DOXA_REGION)
  return (strat && strat.propertyKey === 'doxaRegion') ? (strat.palette || {}) : {}
}

// The affinity-block strategy PALETTE is keyed by ROP1 CODE (A001…) while the
// legend rows are keyed by display NAME ('Arab World'…). The registry hands
// back the strategy's default export, which carries no name-keyed color map —
// so derive one at call time from its code→name (names) + code→color (palette)
// maps.
function affinityBlocColorsByName() {
  const strat = getColorStrategy(COLOR_MODES.AFFINITY_BLOCK)
  if (!strat || strat.propertyKey !== 'affinityBlock') return {}
  const names = strat.names || {}
  const palette = strat.palette || {}
  const byName = {}
  for (const code of Object.keys(names)) byName[names[code]] = palette[code] || '#999'
  return byName
}

// ─── Helper: scan all loaded sources for features matching a predicate ────────
function scanFeatures(dataStore, filterFn) {
  const allSources = Object.values(dataStore.sources || {})
  const features = allSources.flatMap(src => src?.features || [])
  const matched = features.filter(item => filterFn(item.properties || item))
  return {
    count: matched.length,
    population: matched.reduce((sum, item) => {
      const p = item.properties || item
      return sum + (parseInt(p.population || p._raw?.Population || 0) || 0)
    }, 0)
  }
}

// ─── Prayer coverage by the COMMITTED metric (matches the parent site) ────────
// The prayer legend COUNTS come from usePrayerStatistics (/statistics aggregate over
// the full dataset). Population has no per-bucket authoritative value, so it is summed
// from the loaded set using the SAME `people_committed` metric — so a row's count and
// population describe one thing. 100 = the parent's full-coverage threshold
// (FULL_PRAYER_COVERAGE_COUNT in server/api/people-groups/statistics.get.ts).
const FULL_PRAYER_COMMITTED = 100
function committedOf(p) {
  let v = p?.peopleCommitted ?? p?._raw?.people_committed ?? p?.people_committed ?? null
  if (v && typeof v === 'object') v = v.value ?? v.label ?? 0
  return Number(v) || 0
}
function committedLevel(level) {
  return (p) => {
    const c = committedOf(p)
    if (level === 'fullPrayer') return c >= FULL_PRAYER_COMMITTED
    if (level === 'hasPrayer')  return c > 0 && c < FULL_PRAYER_COMMITTED
    return c <= 0   // noPrayer
  }
}

// ─── Engagement / Adoption checkers ───────────────────────────────────────────
function checkHasEngagement(props) {
  const val = props.engagementStatus ?? props._raw?.people_committed
  return val === true || val === 1 || val === '1' || val === 'true'
      || (typeof val === 'number' && val > 0)
      || (typeof val === 'string' && parseInt(val, 10) > 0)
}
function checkHasAdoption(props) {
  const val = props.adoptionStatus ?? props._raw?.adopted_by_churches
  return val === true || val === 1 || val === '1' || val === 'true'
      || (typeof val === 'number' && val > 0)
      || (typeof val === 'string' && parseInt(val, 10) > 0)
}

// ─── Title i18n-key map ───────────────────────────────────────────────────────
// Maps legend type → i18n key under `legend.title.*`.
const TITLE_KEYS = {
  'prayer':            'legend.title.prayer',
  'engagement':        'legend.title.engagement',
  'adoption':          'legend.title.adoption',
  'language-families': 'legend.title.languageFamilies',
  // 'language-family' (singular) is the NEW expand/collapse tree variant —
  // its rows come from useLanguageFamilyLegendData. Title falls back to the
  // plural i18n key so existing translations work.
  'language-family':   'legend.title.languageFamilies',
  'doxa-regions':      'legend.title.doxaRegions',
  // Alias: research-map profile uses 'doxa-region' (singular) for symmetry
  // with 'language-family'. Resolved to the same data path below.
  'doxa-region':       'legend.title.doxaRegions',
  'affinity-blocs':    'legend.title.affinityBlocs',
  // COUNTRIES — the country-posters map's default level. No i18n key yet; the
  // title falls back to the literal "Countries" the same way religion does.
  // Both singular and plural resolve to one canonical key below, matching the
  // doxa-region / language-family precedent.
  'countries':         'legend.title.countries',
  'country':           'legend.title.countries',
  'gospel-resources':  'legend.title.gospelResources',
  // No i18n key for religion in v1 — title falls back to the literal "Religion"
  // via the title computed below. Add `legend.title.religion` translations
  // when localizing the religion tab.
  'religion':          'legend.title.religion'
}

// ─── Legend-type alias normalizer ─────────────────────────────────────────────
// Profiles may use either singular or plural forms; normalize so the items
// computed below can use a single canonical key per type.
function normalizeLegendType(t) {
  if (t === 'doxa-region') return 'doxa-regions'
  if (t === 'country') return 'countries'
  return t
}

// ─── Format helpers ───────────────────────────────────────────────────────────
function fmtPop(pop) {
  if (!pop) return '0'
  if (pop >= 1_000_000) return (pop / 1_000_000).toFixed(1) + 'M'
  if (pop >= 1_000)     return (pop / 1_000).toFixed(1) + 'K'
  return pop.toLocaleString()
}
function fmtCount(n) { return (Number(n) || 0).toLocaleString() }

// ═══════════════════════════════════════════════════════════════════════════════
// Main composable
// ═══════════════════════════════════════════════════════════════════════════════
export function useLegendData(legendTypeRef, opts = {}) {
  const dataStore = inject('dataStore')
  const uiStore   = inject('uiStore')
  const mapStore  = inject('mapStore')
  const { t: $t } = useI18n()

  // Authoritative prayer-coverage counts (single source of truth shared by every
  // profile). Kick off the one /statistics fetch; the `items` computed reads its
  // reactive `loaded` flag, so the legend updates to 601/1505/0 the moment it resolves.
  const prayerStats = usePrayerStatistics()
  prayerStats.load()

  // ── Title ─────────────────────────────────────────────────────────────────
  const title = computed(() => {
    const _t = normalizeLegendType(legendTypeRef.value)
    if (_t === 'religion') return 'Religion'  // literal fallback until i18n added
    const key = TITLE_KEYS[legendTypeRef.value]
    return key ? $t(key) : ''
  })

  // ── Columns ───────────────────────────────────────────────────────────────
  // Column labels translated at read-time so locale switches re-render headers.
  const columns = computed(() => {
    const type = normalizeLegendType(legendTypeRef.value)
    if (type === 'affinity-blocs') return COLUMNS_SIMPLE
    return [
      { key: 'count',      label: $t('legend.columns.upgs'),       width: 48 },
      { key: 'population', label: $t('legend.columns.population'), width: 48 }
    ]
  })

  // ── Active filter key (for highlight ring on selected row) ────────────────
  const activeFilter = computed(() => {
    const t = normalizeLegendType(legendTypeRef.value)
    if (t === 'prayer')     return uiStore.prayerFilter
    if (t === 'engagement') return uiStore.engagementFilter
    if (t === 'adoption')   return uiStore.adoptionFilter
    if (t === 'language-families') return mapStore.selectedFamily
    if (t === 'doxa-regions')     return mapStore.selectedRegion
    if (t === 'gospel-resources') return mapStore.selectedResource
    if (t === 'religion')         return uiStore.religionFilter
    return null
  })

  // ── Set filter (called when a row is clicked) ─────────────────────────────
  function setFilter(filterKey) {
    const t = normalizeLegendType(legendTypeRef.value)
    if (t === 'prayer') {
      uiStore.setPrayerFilter(uiStore.prayerFilter === filterKey ? null : filterKey)
    } else if (t === 'engagement') {
      uiStore.setEngagementFilter(uiStore.engagementFilter === filterKey ? null : filterKey)
    } else if (t === 'adoption') {
      uiStore.setAdoptionFilter(uiStore.adoptionFilter === filterKey ? null : filterKey)
    } else if (t === 'language-families') {
      mapStore.selectFamily(mapStore.selectedFamily === filterKey ? null : filterKey)
    } else if (t === 'doxa-regions') {
      mapStore.selectRegion(mapStore.selectedRegion === filterKey ? null : filterKey)
    } else if (t === 'gospel-resources') {
      mapStore.selectResource(mapStore.selectedResource === filterKey ? null : filterKey)
    } else if (t === 'religion') {
      uiStore.setReligionFilter(uiStore.religionFilter === filterKey ? null : filterKey)
    }
  }

  // ── Items tree ────────────────────────────────────────────────────────────
  const items = computed(() => {
    const t = normalizeLegendType(legendTypeRef.value)

    // ── Prayer (3-tier: parent + 2 children) ────────────────────────────────
    if (t === 'prayer') {
      // COUNT = the authoritative /statistics aggregate (committed metric, full
      // dataset) — the single source of truth the parent site uses, NOT a client
      // scan of loaded pins (which under-counted to 435 vs the parent's 601).
      // Population is summed from the loaded set on the SAME committed metric so
      // each row's count + population agree. Until /statistics resolves, fall back
      // to the committed scan so the legend is never blank.
      const noScan   = scanFeatures(dataStore, committedLevel('noPrayer'))
      const hasScan  = scanFeatures(dataStore, committedLevel('hasPrayer'))
      const fullScan = scanFeatures(dataStore, committedLevel('fullPrayer'))
      const ready = prayerStats.loaded.value
      const noCount   = ready ? prayerStats.noPrayerCount()   : noScan.count
      const hasCount  = ready ? prayerStats.hasPrayerCount()  : hasScan.count
      const fullCount = ready ? prayerStats.fullPrayerCount() : fullScan.count
      return [{
        key: 'noPrayer', label: $t('legend.prayer.needsPrayer'), color: PRAYER_COLORS.noPrayer,
        count: noCount, population: noScan.population, filterKey: 'noPrayer',
        children: [
          { key: 'hasPrayer', label: $t('legend.prayer.hasPrayer'), color: PRAYER_COLORS.hasPrayer,
            count: hasCount, population: hasScan.population, filterKey: 'hasPrayer' },
          { key: 'fullPrayer', label: $t('legend.prayer.fullPrayerCoverage'), color: PRAYER_COLORS.fullPrayer,
            count: fullCount, population: fullScan.population, filterKey: 'fullPrayer' }
        ]
      }]
    }

    // ── Engagement (binary parent/child) ────────────────────────────────────
    if (t === 'engagement') {
      const no  = scanFeatures(dataStore, p => !checkHasEngagement(p))
      const has = scanFeatures(dataStore, p => checkHasEngagement(p))
      return [{
        key: 'notEngaged', label: $t('legend.engagement.needsEngagement'), color: ENGAGEMENT_COLORS.notEngaged,
        count: no.count, population: no.population, filterKey: 'notEngaged',
        children: [
          { key: 'hasEngagement', label: $t('legend.engagement.hasEngagement'), color: ENGAGEMENT_COLORS.hasEngagement,
            count: has.count, population: has.population, filterKey: 'hasEngagement' }
        ]
      }]
    }

    // ── Adoption (binary parent/child) ──────────────────────────────────────
    if (t === 'adoption') {
      const no  = scanFeatures(dataStore, p => !checkHasAdoption(p))
      const has = scanFeatures(dataStore, p => checkHasAdoption(p))
      return [{
        key: 'notAdopted', label: $t('legend.adoption.needsAdoption'), color: ADOPTION_COLORS.notAdopted,
        count: no.count, population: no.population, filterKey: 'notAdopted',
        children: [
          { key: 'hasAdoption', label: $t('legend.adoption.hasAdoption'), color: ADOPTION_COLORS.hasAdoption,
            count: has.count, population: has.population, filterKey: 'hasAdoption' }
        ]
      }]
    }

    // ── Religion (flat list, one row per religion family) ──────────────────
    if (t === 'religion') {
      // Roll up by family letter (first char of religion code: C/M/H/B/E/J/S/N/O/U).
      // Each row gets a count + population summed across all sub-religions in that family.
      const familyAggregates = {}
      const allSources = Object.values(dataStore.sources || {})
      const features = allSources.flatMap(src => src?.features || [])
      for (const item of features) {
        const p = item.properties || item
        const code = p.religion || p._raw?.religion?.value || p._raw?.religion || ''
        const fam = getReligionFamily(code)
        if (!familyAggregates[fam]) familyAggregates[fam] = { count: 0, population: 0 }
        familyAggregates[fam].count += 1
        familyAggregates[fam].population += parseInt(p.population || p._raw?.Population || 0) || 0
      }
      // Christianity always first; rest sorted by population desc.
      // Optional family-letter exclusions (e.g. ['C'] on the unengaged-PG dataset
      // — Christianity-followers aren't unengaged so the row would be misleading).
      // Configured via RESEARCH_LEGEND_OPTIONS.excludeReligionFamilies.
      const exclude = new Set(opts?.excludeReligionFamilies || [])
      for (const fam of exclude) delete familyAggregates[fam]
      const order = Object.keys(familyAggregates).sort((a, b) => {
        if (a === 'C') return -1
        if (b === 'C') return 1
        return (familyAggregates[b].population - familyAggregates[a].population)
      })
      return order.map(fam => ({
        key:        fam,
        // REGREL: the LABEL is localized, the VALUE is not. `key` and `filterKey` below stay the
        // canonical family letter, which is what the filter and the map compare on; only this
        // display string follows the reader's language. RELIGION_FAMILIES is no longer imported here:
        // religionFamilyLabel() reads it internally, so this file's only use of it was this label.
        label:      religionFamilyLabel(fam) || 'Unknown',
        color:      RELIGION_COLORS[fam] || '#94a3b8',
        count:      familyAggregates[fam].count,
        population: familyAggregates[fam].population,
        filterKey:  fam,
        children:   []
      }))
    }

    // ── Language Families (flat list, each is a "parent" with no children) ───
    if (t === 'language-families') {
      return (dataStore.languageFamiliesData || []).map(f => ({
        key: f.name, label: f.name, color: getLanguageFamilyColor(f.name),
        count: f.count, population: f.population, filterKey: f.name,
        children: []
      }))
    }

    // ── Language Family TREE (singular) — delegate row construction to the
    // dedicated composable. The returned shape is the LegendRow shape from
    // useLanguageFamilyLegendData ({ peopleGroupCount, ..., kind, pinIds }).
    // LegendDesktop / LegendMobile branch on `legendType === 'language-family'`
    // BEFORE consuming items, so this is a fallback for any caller that still
    // reads `items` directly (e.g. a custom host).
    if (t === 'language-family') {
      const features = Object.values(dataStore.sources || {})
        .flatMap(src => src?.features || [])
      const featuresRef = { value: features }
      const { rows: famRows } = useLanguageFamilyLegendData(featuresRef)
      return famRows.value.map(r => ({
        key: r.key, label: r.label, color: r.color,
        count: r.peopleGroupCount, population: r.population,
        filterKey: r.key, children: []
      }))
    }

    // ── Doxa Regions (flat) ─────────────────────────────────────────────────
    if (t === 'doxa-regions') {
      const REGION_COLORS = doxaRegionPalette() // lazy+guarded registry read
      return (dataStore.doxaRegionsData || []).map(r => ({
        key: r.name, label: r.name, color: REGION_COLORS[r.name] || '#999',
        count: r.count, population: r.population, filterKey: r.name,
        children: []
      }))
    }

    // ── Gospel Resources (parent/child tree) ────────────────────────────────
    if (t === 'gospel-resources') {
      // Lazy + guarded: research-only strategy, present only on bundles that
      // register it locally. Empty legend (not wrong colors) when absent.
      const strat = resourceStrategy()
      const RESOURCE_COLORS = strat?.palette ?? {}
      const RESOURCE_NAMES  = strat?.names ?? {}
      const resources = dataStore.resourcesData || []
      return Object.keys(RESOURCE_COLORS).map(rKey => {
        const data = resources.find(r => r.key === rKey)
        return {
          key: rKey, label: RESOURCE_NAMES[rKey] || rKey, color: RESOURCE_COLORS[rKey],
          count: data?.count || 0, population: data?.population || 0, filterKey: rKey,
          children: (data?.children || []).map(c => ({
            key: c.key, label: c.name || c.key, color: c.color || RESOURCE_COLORS[rKey],
            count: c.count || 0, population: c.population || 0, filterKey: c.key
          }))
        }
      })
    }

    // ── Affinity Blocks (flat, no counts) ────────────────────────────────────
    if (t === 'affinity-blocs') {
      // lazy+guarded registry read; sorted to keep the alphabetical row order
      // the old inlined (name-keyed) palette produced.
      const BLOC_COLORS = affinityBlocColorsByName()
      return Object.keys(BLOC_COLORS).sort().map(b => ({
        key: b, label: b, color: BLOC_COLORS[b], filterKey: b, children: []
      }))
    }

    return []
  })

  // ── Totals ────────────────────────────────────────────────────────────────
  function sumTree(arr, field) {
    return arr.reduce((s, item) => {
      let v = item[field] || 0
      if (item.children?.length) v += sumTree(item.children, field)
      return s + v
    }, 0)
  }
  const totalCount      = computed(() => sumTree(items.value, 'count'))
  const totalPopulation = computed(() => sumTree(items.value, 'population'))

  // ── Prayer progress (header bar payload) ──────────────────────────────────
  // Payload for <LegendProgressBar> (library/components/legends/LegendProgressBar.vue)
  // — PRAYER ONLY, null for every other legend type (the consumers render nothing
  // on null). Hosts pass it as the `progress` prop of SemanticTreeLegend / LegendRows
  // AND provide('legendProgress', progress) so the mobile sheet's embedded legend
  // (LegendMobile → SemanticTreeLegend) picks it up via inject.
  // The three prayer row counts above are mutually EXCLUSIVE (usePrayerStatistics:
  // partial excludes full; committedLevel: has = 0 < committed < 100), so the bar's
  // has-prayer SPAN = has + full and full FILLS that span from the left (full ⊂ has).
  //   covered  = has + full                      (the span; drives "covered/total · %")
  //   total    = totalCount                      (no + has + full = /statistics `total`
  //              once loaded — every people group in the data source; the loaded-pin
  //              count until then)
  //   segments = [full, has, no] LEFT→RIGHT, exclusive counts, prayer-strategy colours
  const progress = computed(() => {
    if (normalizeLegendType(legendTypeRef.value) !== 'prayer') return null
    const row = items.value[0]
    if (!row) return null
    const has  = (row.children || []).find(c => c.key === 'hasPrayer')
    const full = (row.children || []).find(c => c.key === 'fullPrayer')
    const noCount = Number(row.count) || 0
    const hasCount = Number(has?.count) || 0
    const fullCount = Number(full?.count) || 0
    // Population of the covered span, so the progress row can fill the Population column
    // with the same number the Has Prayer + Full Prayer rows add up to.
    const coveredPopulation = (Number(has?.population) || 0) + (Number(full?.population) || 0)
    return {
      covered: hasCount + fullCount,
      total: totalCount.value,
      coveredPopulation,
      totalPopulation: totalPopulation.value,
      segments: [
        { key: 'fullPrayer', label: full?.label ?? $t('legend.prayer.fullPrayerCoverage'), count: fullCount, color: PRAYER_COLORS.fullPrayer },
        { key: 'hasPrayer',  label: has?.label  ?? $t('legend.prayer.hasPrayer'),          count: hasCount,  color: PRAYER_COLORS.hasPrayer },
        { key: 'noPrayer',   label: row.label,                                              count: noCount,   color: PRAYER_COLORS.noPrayer }
      ]
    }
  })

  return {
    items, columns, title, activeFilter, setFilter,
    totalCount, totalPopulation,
    progress,
    fmtPop, fmtCount
  }
}