/* ══════════════════════════════════════════════════════════════════
   ATLAS COCKPIT — COMMAND PALETTE (⌘K)
   ══════════════════════════════════════════════════════════════════ */
const paletteBus = new Set();
function openPalette() { paletteBus.forEach(fn => fn(true)); }

function CommandPalette({ onNavigate }) {
  const [open, setOpen] = useState(false);
  const [q, setQ] = useState('');
  const [active, setActive] = useState(0);
  const inputRef = useRef(null);
  const listRef = useRef(null);
  const theme = useStore(s => s.theme);
  const focusMode = useStore(s => s.focusMode);
  const notesState = useStore(s => s.notes);
  const logState = useStore(s => s.log);
  const D = window.ATLAS_DATA;

  useEffect(() => {
    const onKey = (e) => {
      if ((e.metaKey || e.ctrlKey) && e.key.toLowerCase() === 'k') { e.preventDefault(); setOpen(o => !o); }
      if (e.key === 'Escape') setOpen(false);
    };
    window.addEventListener('keydown', onKey);
    const busFn = (v) => setOpen(v);
    paletteBus.add(busFn);
    return () => { window.removeEventListener('keydown', onKey); paletteBus.delete(busFn); };
  }, []);
  useEffect(() => { if (open) { setQ(''); setActive(0); setTimeout(() => inputRef.current && inputRef.current.focus(), 30); } }, [open]);

  const nav = (view) => { onNavigate(view); setOpen(false); };

  const groups = useMemo(() => {
    const ql = q.trim().toLowerCase();
    const match = (s) => !ql || String(s).toLowerCase().includes(ql);
    const g = [];
    const dark = effectiveTheme(theme) === 'dark';

    const navItems = [
      { id: 'nav-today', kind: 'Go to', title: 'Today', icon: 'today', run: () => nav('today') },
      { id: 'nav-projects', kind: 'Go to', title: 'Projects', icon: 'projects', run: () => nav('projects') },
      { id: 'nav-finance', kind: 'Go to', title: 'Finance', icon: 'finance', run: () => nav('finance') },
      { id: 'nav-risks', kind: 'Go to', title: 'Risks', icon: 'risks', run: () => nav('risks') },
      { id: 'nav-ideas', kind: 'Go to', title: 'Ideas', icon: 'ideas', run: () => nav('ideas') },
      { id: 'nav-calendar', kind: 'Go to', title: 'Calendar', icon: 'calendar', run: () => nav('calendar') },
      { id: 'nav-log', kind: 'Go to', title: 'Decision log', icon: 'doc', run: () => nav('log') },
      { id: 'nav-settings', kind: 'Go to', title: 'Settings', icon: 'settings', run: () => nav('settings') }
    ].filter(i => match(i.title));
    if (navItems.length) g.push({ label: 'Navigate', items: navItems });

    const actions = [
      { id: 'act-theme', kind: 'Action', title: dark ? 'Switch to light mode' : 'Switch to dark mode', icon: dark ? 'sun' : 'moon', sub: '', run: () => { setKV({ theme: dark ? 'light' : 'dark' }); setOpen(false); } },
      { id: 'act-focus', kind: 'Action', title: focusMode ? 'Exit focus mode' : 'Enter focus mode', icon: 'focus', run: () => { setKV({ focusMode: !focusMode }); setOpen(false); } },
      { id: 'act-reset', kind: 'Action', title: 'Reset all local state', icon: 'refresh', run: () => { if (confirm('Reset all decisions, notes, edits and checkmarks?')) { Store.reset(); } setOpen(false); } }
    ].filter(i => match(i.title) || match('command'));
    if (actions.length) g.push({ label: 'Quick actions', items: actions });

    if (ql) {
      const open_ = (store, id) => isDecided(store, id);
      const proj = D.projects.filter(p => match(p.name) || match(p.summary)).map(p => ({
        id: 'p-' + p.id, kind: 'Project', title: p.name, sub: window.ATLAS_STATUS[p.status], icon: 'projects', run: () => { setOpen(false); openDrawer('project', p.id); }
      }));
      if (proj.length) g.push({ label: 'Projects', items: proj });

      const acts = getActions().filter(a => !open_('actions', a.id) && (match(a.title) || match(a.why))).map(a => ({
        id: 'a-' + a.id, kind: a.urgency, title: a.title, sub: 'Action · ' + a.source, icon: 'zap',
        run: () => { setOpen(false); openDrawer('action', a.id); },
        quick: [{ label: 'Approve', run: () => decide('actions', a.id, 'approve', a.title, '') }, { label: 'Defer', run: () => decide('actions', a.id, 'defer', a.title, '') }]
      }));
      if (acts.length) g.push({ label: 'Actions', items: acts });

      const ideas = getIdeas().filter(i => !open_('ideas', i.id) && (match(i.name) || match(i.thesis))).map(i => ({
        id: 'i-' + i.id, kind: 'Idea · ' + i.score, title: i.name, sub: i.category, icon: 'ideas', run: () => { setOpen(false); openDrawer('idea', i.id); }
      }));
      if (ideas.length) g.push({ label: 'Ideas', items: ideas });

      const risks = D.risks.filter(r => !open_('risks', r.id) && (match(r.title) || match(r.body))).map(r => ({
        id: 'r-' + r.id, kind: r.severity, title: r.title, sub: 'Risk', icon: 'risks', run: () => { setOpen(false); openDrawer('risk', r.id); }
      }));
      if (risks.length) g.push({ label: 'Risks', items: risks });

      const recs = D.recommendations.filter(r => !open_('recs', r.id) && (match(r.title) || match(r.thesis))).map(r => ({
        id: 'rec-' + r.id, kind: 'Rec · ' + r.score, title: r.title, sub: r.src, icon: 'sparkle', run: () => { nav('today'); }
      }));
      if (recs.length) g.push({ label: 'Recommendations', items: recs });

      /* ── Pass 2 · search across notes, blockers, decision log ── */
      const S = Store.get();
      const allNotes = S.notes || {};
      const snippet = (s, n = 70) => { const t = String(s || '').replace(/\s+/g, ' ').trim(); return t.length > n ? t.slice(0, n) + '…' : t; };

      /* Notes — match across actions/recs/ideas/risks/projectNotes/blockers entries. */
      const noteHits = [];
      const NOTE_STORES = [
        { key: 'actions', kind: 'action', list: getActions(), titleKey: 'title', drawerType: 'action' },
        { key: 'ideas', kind: 'idea', list: getIdeas(), titleKey: 'name', drawerType: 'idea' },
        { key: 'risks', kind: 'risk', list: D.risks, titleKey: 'title', drawerType: 'risk' },
        { key: 'recs', kind: 'rec', list: D.recommendations, titleKey: 'title', drawerType: null },
        { key: 'projectNotes', kind: 'project', list: D.projects, titleKey: 'name', drawerType: 'project' }
      ];
      NOTE_STORES.forEach(({ key, kind, list, titleKey, drawerType }) => {
        const bucket = allNotes[key] || {};
        Object.keys(bucket).forEach(id => {
          const txt = bucket[id]; if (!txt) return;
          if (!match(txt)) return;
          const ent = list.find(x => x.id === id);
          const parentTitle = (ent && ent[titleKey]) || id;
          noteHits.push({
            id: 'note-' + key + '-' + id, kind: 'Note · ' + kind, title: snippet(txt, 60), sub: 'on ' + parentTitle,
            icon: 'doc', run: () => { setOpen(false); if (drawerType) openDrawer(drawerType, id); }
          });
        });
      });
      if (noteHits.length) g.push({ label: 'Notes', items: noteHits });

      /* Blockers — match the blocker body text + any attached note. */
      const blockerNotes = allNotes.blockers || {};
      const blockerHits = D.blockers.filter(b => match(b.title) || match(b.body) || match(blockerNotes[b.id] || '')).map(b => ({
        id: 'blk-' + b.id, kind: 'Blocker', title: b.title, sub: snippet(blockerNotes[b.id] || b.body),
        icon: 'alert', run: () => { nav('today'); setTimeout(() => { const el = document.querySelector('#blockers, .blockers-rail'); if (el) el.scrollIntoView({ behavior: 'smooth', block: 'start' }); }, 60); }
      }));
      if (blockerHits.length) g.push({ label: 'Blockers', items: blockerHits });

      /* Decision log — match title + note + decision kind. Newest first; cap at 12. */
      const logHits = (S.log || []).filter(e => match(e.title) || match(e.note) || match(e.kind) || match(e.decision)).slice(0, 12).map(e => ({
        id: 'log-' + e.uid, kind: 'Log · ' + String(e.ts).slice(0, 10), title: e.title || (e.kind + ' (no title)'),
        sub: e.note ? snippet(e.note) : (e.decision + ' · ' + e.store),
        icon: 'clock', run: () => { setOpen(false); window.location.hash = '#/decisions/' + e.uid; }
      }));
      if (logHits.length) g.push({ label: 'Decision log', items: logHits });
    }
    return g;
  }, [q, theme, focusMode, notesState, logState]);

  const flat = useMemo(() => groups.flatMap(g => g.items), [groups]);
  useEffect(() => { if (active >= flat.length) setActive(0); }, [flat.length]);

  const onKeyDown = (e) => {
    if (e.key === 'ArrowDown') { e.preventDefault(); setActive(a => Math.min(a + 1, flat.length - 1)); }
    else if (e.key === 'ArrowUp') { e.preventDefault(); setActive(a => Math.max(a - 1, 0)); }
    else if (e.key === 'Enter') { e.preventDefault(); flat[active] && flat[active].run(); }
  };
  useEffect(() => {
    if (!listRef.current) return;
    const el = listRef.current.querySelector('.cmd-item.active');
    if (el) el.scrollIntoView({ block: 'nearest' });
  }, [active]);

  if (!open) return null;
  let idx = -1;
  return React.createElement('div', { className: cls('cmd-scrim', 'show'), onMouseDown: (e) => { if (e.target === e.currentTarget) setOpen(false); } },
    React.createElement('div', { className: 'cmd', role: 'dialog', 'aria-label': 'Command palette' },
      React.createElement('div', { className: 'cmd-input-row' },
        React.createElement(Icon, { name: 'search', size: 18, style: { color: 'var(--ink-faint)' } }),
        React.createElement('input', { ref: inputRef, className: 'cmd-input', placeholder: 'Search or jump to…', value: q, onChange: e => { setQ(e.target.value); setActive(0); }, onKeyDown }),
        React.createElement('span', { className: 'kbd' }, 'Esc')
      ),
      React.createElement('div', { className: 'cmd-list scroll', ref: listRef },
        flat.length === 0 && React.createElement('div', { className: 'cmd-empty' }, 'No matches for “', q, '”'),
        groups.map(grp => React.createElement('div', { key: grp.label },
          React.createElement('div', { className: 'cmd-group-label' }, grp.label),
          grp.items.map(it => { idx++; const myIdx = idx; return React.createElement('div', {
            key: it.id, className: cls('cmd-item', myIdx === active && 'active'),
            onMouseEnter: () => setActive(myIdx), onClick: it.run
          },
            React.createElement(Icon, { name: it.icon, size: 17, className: 'ci-ico' }),
            React.createElement('div', { className: 'ci-main' },
              React.createElement('div', { className: 'ci-title' }, it.title),
              it.sub && React.createElement('div', { className: 'ci-sub' }, it.sub)),
            it.quick && myIdx === active && React.createElement('div', { style: { display: 'flex', gap: 5 } },
              it.quick.map((qa, i) => React.createElement('button', { key: i, className: 'btn xs', onClick: (e) => { e.stopPropagation(); qa.run(); setOpen(false); } }, qa.label))),
            !it.quick && React.createElement('span', { className: 'ci-kind' }, it.kind)
          ); })
        ))
      ),
      React.createElement('div', { className: 'cmd-foot' },
        React.createElement('span', { className: 'ck' }, React.createElement('span', { className: 'kbd' }, '↑'), React.createElement('span', { className: 'kbd' }, '↓'), 'navigate'),
        React.createElement('span', { className: 'ck' }, React.createElement('span', { className: 'kbd' }, '↵'), 'select'),
        React.createElement('span', { className: 'ck', style: { marginLeft: 'auto' } }, React.createElement(BrandMark, { size: 13 }), 'ATLAS')
      )
    )
  );
}
Object.assign(window, { CommandPalette, openPalette });