import {useEffect, useMemo, useRef, useState} from 'react';
import {createRoot} from 'react-dom/client';
import {dateKey} from './game';
import {LangContext, detectLang, makeTranslator, type Key} from './i18n';
import {moonAt, moonAge} from './logic';
import {LESSONS, MAX_STARS, earned, fresh, legacyKeys, liveStreak, recordDaily, recordLesson, recordRush, restore, storageKey, totalStars, type Lang, type Progress, type Settings} from './progress';
import {Results} from './Results';
import {Run, type Mode, type Outcome} from './Run';
import {LearnView, LessonPlayer, Onboarding, PlayView, SettingsView, Tonight, YearView, type Install, type Today} from './screens';
import {configure, sfx} from './sound';
import {Icon, pages, type Page} from './ui';
import './style.css';

const pageFromHash = (): Page => pages.find(page => '#' + page === location.hash) ?? 'tonight';
function computeToday(): Today {
  const now = new Date();
  return {time: Date.UTC(now.getFullYear(), now.getMonth(), now.getDate()), now: now.getTime(), key: dateKey(now)};
}
function loadProgress() {
  try { return restore(localStorage.getItem(storageKey), ...legacyKeys.map(k => localStorage.getItem(k))); } catch { return fresh(); }
}

type BeforeInstall = Event & {prompt: () => Promise<void>; userChoice: Promise<{outcome: string}>};
function useInstall(): Install {
  const [event, setEvent] = useState<BeforeInstall | null>(null);
  const [installed, setInstalled] = useState(() => matchMedia('(display-mode: standalone)').matches || (navigator as {standalone?: boolean}).standalone === true);
  useEffect(() => {
    const before = (e: Event) => { e.preventDefault(); setEvent(e as BeforeInstall); };
    const done = () => { setInstalled(true); setEvent(null); };
    addEventListener('beforeinstallprompt', before);
    addEventListener('appinstalled', done);
    return () => { removeEventListener('beforeinstallprompt', before); removeEventListener('appinstalled', done); };
  }, []);
  return {
    canPrompt: !!event, installed, ios: /iphone|ipad|ipod/i.test(navigator.userAgent),
    prompt: () => { void event?.prompt(); event?.userChoice.finally(() => setEvent(null)); },
  };
}

type Session = {mode: Mode; id: number};
type Result = {outcome: Outcome; unlocks: string[]; best: boolean; streak: number};

function App() {
  const [progress, setProgress] = useState<Progress>(loadProgress);
  const [draftLang, setDraftLang] = useState<Lang>(detectLang);
  const [saveFailed, setSaveFailed] = useState(false);
  const [page, setPage] = useState<Page>(pageFromHash);
  const [session, setSession] = useState<Session | null>(null);
  const [result, setResult] = useState<Result | null>(null);
  const [today, setToday] = useState(computeToday);
  const [lesson, setLesson] = useState<number | null>(null);
  const [update, setUpdate] = useState<ServiceWorker | null>(null);
  const install = useInstall();
  const lang = progress.settings.lang ?? draftLang;
  const tr = useMemo(() => makeTranslator(lang), [lang]);
  const {t, n} = tr;
  const latest = useRef(progress);
  latest.current = progress;

  useEffect(() => {
    try { localStorage.setItem(storageKey, JSON.stringify(progress)); } catch { setSaveFailed(true); }
  }, [progress]);
  useEffect(() => configure(progress.settings.sound, progress.settings.haptics), [progress.settings.sound, progress.settings.haptics]);
  useEffect(() => {
    document.documentElement.lang = lang;
    document.documentElement.dir = tr.dir;
    document.title = t('app') + ' · ' + t('tagline');
  }, [lang, tr, t]);
  useEffect(() => {
    const sync = () => {
      if (location.hash === '#run') return;
      setSession(null);
      setResult(null);
      setLesson(null);
      setPage(pageFromHash());
      window.scrollTo(0, 0);
    };
    const tick = () => setToday(computeToday());
    const id = setInterval(tick, 60_000);
    addEventListener('hashchange', sync);
    document.addEventListener('visibilitychange', tick);
    const onUpdate = (e: Event) => setUpdate((e as CustomEvent<ServiceWorker>).detail);
    addEventListener('moonkeeper:update', onUpdate);
    if (location.hash === '#run') history.replaceState(null, '', '#play'), setPage('play');
    if (location.hash === '#daily') {
      history.replaceState(null, '', '#tonight');
      setPage('tonight');
      if (latest.current.settings.lang) playDaily();
    }
    return () => { clearInterval(id); removeEventListener('hashchange', sync); document.removeEventListener('visibilitychange', tick); removeEventListener('moonkeeper:update', onUpdate); };
  }, []);

  const setSettings = (s: Partial<Settings>) => setProgress(p => ({...p, settings: {...p.settings, ...s}}));
  function go(target: Page) {
    sfx.tap();
    location.hash = target;
  }
  function start(mode: Mode) {
    setResult(null);
    setSession(s => ({mode, id: (s?.id ?? 0) + 1}));
    if (location.hash !== '#run') history.pushState(null, '', '#run');
    window.scrollTo(0, 0);
  }
  function exit(target: Page) {
    setSession(null);
    setResult(null);
    setLesson(null);
    history.replaceState(null, '', '#' + target);
    setPage(target);
    window.scrollTo(0, 0);
  }
  const playQuiz = (index: number) => start({type: 'lesson', index});
  const openLesson = (index: number) => {
    sfx.tap();
    setSession(null);
    setResult(null);
    setLesson(index);
    history.replaceState(null, '', '#learn');
    setPage('learn');
    window.scrollTo(0, 0);
  };
  const playDaily = () => start({type: 'daily', key: today.key, tonight: moonAt(today.now).phase});
  const playRush = () => start({type: 'rush'});

  function done(outcome: Outcome) {
    const before = latest.current;
    let after = before;
    let best = false;
    const {mode} = outcome;
    if (mode.type === 'lesson') {
      after = recordLesson(before, mode.index, outcome.stars, outcome.maxCombo);
    } else if (mode.type === 'daily') {
      after = recordDaily(before, mode.key, outcome.score, outcome.maxCombo);
    } else {
      after = recordRush(before, outcome.score, outcome.maxCombo);
      best = outcome.score > before.rushBest && outcome.score > 0;
    }
    const unlocks: string[] = [];
    const had = earned(before);
    for (const id of earned(after)) if (!had.includes(id)) unlocks.push(t('unlock_badge', {name: t(('ach_' + id) as Key)}));
    setProgress(after);
    setResult({outcome, unlocks, best, streak: liveStreak(after, today.key)});
  }

  const motion = progress.settings.motion;
  const onboarding = progress.settings.lang === null;
  const running = !!session || lesson !== null;
  const stars = totalStars(progress);
  const streak = liveStreak(progress, today.key);

  let body;
  if (onboarding) {
    body = <Onboarding lang={draftLang} onLang={l => { sfx.tap(); setDraftLang(l); }} onBegin={() => {
      setSettings({lang: draftLang});
      sfx.start();
      exit('tonight');
    }} />;
  } else if (session && result) {
    const {mode} = result.outcome;
    const nextIndex = mode.type === 'lesson' ? mode.index + 1 : -1;
    body = <Results key={'r' + session.id} outcome={result.outcome} unlocks={result.unlocks} best={result.best} streak={result.streak}
      dateLabel={tr.date(today.time, {day: 'numeric', month: 'short', year: 'numeric'})}
      onNext={mode.type === 'lesson' && nextIndex < LESSONS ? () => openLesson(nextIndex) : undefined}
      onRetry={() => start(mode)} onMap={() => exit('learn')} onHome={() => exit(mode.type === 'daily' ? 'tonight' : 'play')} />;
  } else if (session) {
    body = <Run key={session.id} mode={session.mode} onDone={done}
      onQuit={() => (session.mode.type === 'lesson' ? openLesson(session.mode.index) : exit(session.mode.type === 'daily' ? 'tonight' : 'play'))} />;
  } else if (lesson !== null) {
    body = <LessonPlayer key={lesson} index={lesson} tonight={moonAge(today.now)} motion={motion} onQuiz={() => playQuiz(lesson)} onClose={() => exit('learn')} />;
  } else {
    body = <>
      {page === 'tonight' && <Tonight p={progress} today={today} motion={motion} onDaily={playDaily} onRush={playRush} onLesson={openLesson} go={go} install={install} />}
      {page === 'year' && <YearView today={today} />}
      {page === 'learn' && <LearnView p={progress} onOpen={openLesson} />}
      {page === 'play' && <PlayView p={progress} today={today} onDaily={playDaily} onRush={playRush} onQuiz={playQuiz} />}
      {page === 'settings' && <SettingsView p={progress} setSettings={setSettings} install={install} onReset={() => setProgress({...fresh(), settings: progress.settings})} />}
    </>;
  }

  return <LangContext.Provider value={tr}>
    <div className={'app' + (motion ? '' : ' still') + (running || onboarding ? ' focus' : '')}>
      {!running && !onboarding && <header className="top">
        <a href="#tonight" className="brand"><img src="/icon-192.png" alt="" width="34" height="34" /> {t('app')}</a>
        <div className="pills">
          <span className="pill" title={t('streak', {n: streak})}><Icon name="flame" className={streak ? 'hot' : ''} /> {n(streak)}</span>
          <span className="pill gold" aria-label={t('stars_of', {n: stars, max: MAX_STARS})}>★ {n(stars)}</span>
        </div>
      </header>}
      {saveFailed && <p className="alert" role="alert">{t('storage_fail')}</p>}
      <main key={running ? 'run' : onboarding ? 'onboard' : page}>{body}</main>
      {!running && !onboarding && <nav aria-label="Main">{pages.map(target => <a key={target} href={'#' + target} onClick={() => sfx.tap()} aria-current={page === target ? 'page' : undefined}><Icon name={target} /><span>{t(('nav_' + target) as Key)}</span></a>)}</nav>}
      {update && <div className="toast" role="status"><span>{t('update_ready')}</span><button className="primary" onClick={() => update.postMessage('skip')}>{t('update_btn')}</button></div>}
    </div>
  </LangContext.Provider>;
}

createRoot(document.getElementById('root')!).render(<App />);

if (import.meta.env.PROD && 'serviceWorker' in navigator) {
  const announce = (worker: ServiceWorker | null) => { if (worker && navigator.serviceWorker.controller) dispatchEvent(new CustomEvent('moonkeeper:update', {detail: worker})); };
  navigator.serviceWorker.register('/sw.js').then(reg => {
    announce(reg.waiting);
    reg.addEventListener('updatefound', () => {
      const worker = reg.installing;
      worker?.addEventListener('statechange', () => { if (worker.state === 'installed') announce(worker); });
    });
    setInterval(() => void reg.update(), 60 * 60 * 1000);
  }).catch(error => console.warn('Offline cache registration failed', error));
  // Only reload when an existing page was taken over by an update, not on first install.
  let reloading = !navigator.serviceWorker.controller;
  navigator.serviceWorker.addEventListener('controllerchange', () => { if (!reloading) { reloading = true; location.reload(); } });
}
