hexplorer 0.1.0

//! Application state and event handling.

use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
use ratatui::widgets::ListState;
use tokio::sync::mpsc::Sender;

use std::collections::HashMap;

use crate::{
    api::{fetch_by_names, fetch_github_stats, fetch_packages, github_token, GhResult, Package},
    cache::{self, CacheMap, CachedEntry},
    favorites,
    storage::{self, StorageConfig},
    types::{Language, SettingRow, Sort, View},
};

// ── GitHub fetch state ────────────────────────────────────────────────────────

#[derive(Debug, Clone)]
pub enum GhState {
    /// Package has no repository URL.
    NoRepo,
    /// Data served from disk cache. The entry is kept by value so age_label()
    /// can be computed dynamically at render time (avoids stale age strings).
    Cached(CachedEntry),
    /// Network request in flight.
    Loading,
    /// Live data just fetched.
    Live(crate::api::GithubStats),
    /// Hit the unauthenticated 60 req/h rate limit.
    RateLimited,
    /// 401 Unauthorized — the stored/env token is invalid or expired.
    BadToken,
    /// Non-GitHub repo or any other error.
    Unavailable,
}

// ── Async messages ────────────────────────────────────────────────────────────

pub enum Msg {
    /// `u64` is the fetch generation — stale results (gen < app.fetch_gen) are discarded.
    /// `bool` = has_more (a next page exists).
    Loaded(u64, Vec<Package>, bool),
    GhFetched(String, GhResult), // (repo_url, result)
    Err(String),
}

// ── Application state ─────────────────────────────────────────────────────────

pub struct App {
    pub view: View,
    pub language: Language,
    pub packages: Vec<Package>,
    pub list_state: ListState,
    pub input: String,
    pub input_mode: bool,
    pub sort: Sort,
    pub loading: bool,
    pub gh: GhState,
    pub error: Option<String>,
    pub scroll: u16,
    /// Current browse page (1-indexed). Reset to 1 on search, language, or sort change.
    /// Inactive (always 1) when a search query is active.
    pub page: u32,
    /// True when the last fetch returned a full page — a next page likely exists.
    pub has_more: bool,
    /// In-memory mirror of `~/.cache/hexplorer/gh_stats.json`.
    pub cache: CacheMap,
    /// `GITHUB_TOKEN` from environment (`None` = unauthenticated).
    pub token: Option<String>,
    /// Starred packages: name → language. Persisted to `~/.cache/hexplorer/favorites.json`.
    pub favorites: HashMap<String, crate::types::Language>,
    /// When `true`, the list shows only starred packages (fetched individually by name).
    pub favorites_mode: bool,
    // ── Settings screen state ─────────────────────────────────────────────────
    /// Index into `SettingRow::all()` for the settings cursor.
    pub settings_cursor: usize,
    /// `true` while the user is typing a new GitHub token value.
    pub settings_editing: bool,
    /// Buffer for the token being typed.
    pub settings_input: String,
    /// Local copy of `StorageConfig` while the settings screen is open.
    pub settings_config: StorageConfig,
    /// Current stored token (loaded when opening settings, for masked display).
    pub settings_token: Option<String>,
    tx: Sender<Msg>,
    /// Monotonically-increasing counter; each `load()` call increments it.
    /// `Msg::Loaded` carries the generation it was spawned with — results from
    /// earlier generations are silently discarded to prevent stale overwrites.
    fetch_gen: u64,
}

impl App {
    pub fn new(tx: Sender<Msg>, language: Language) -> Self {
        Self {
            view: View::List,
            language,
            packages: vec![],
            list_state: ListState::default(),
            input: String::new(),
            input_mode: false,
            sort: Sort::default(),
            loading: false,
            gh: GhState::NoRepo,
            error: None,
            scroll: 0,
            page: 1,
            has_more: false,
            cache: cache::load(),
            token: github_token(),
            favorites: favorites::load(),
            favorites_mode: false,
            settings_cursor: 0,
            settings_editing: false,
            settings_input: String::new(),
            settings_config: StorageConfig::default(),
            settings_token: None,
            tx,
            fetch_gen: 0,
        }
    }

    // ── Data fetching ─────────────────────────────────────────────────────────

    pub fn load(&mut self) {
        self.fetch_gen += 1;
        let gen = self.fetch_gen;
        self.loading = true;
        self.error = None;
        let tx = self.tx.clone();
        let q = self.input.clone();
        let s = self.sort.api_param().to_string();
        let lng = self.language;
        let pg = self.page;
        tokio::spawn(async move {
            match fetch_packages(&q, &s, lng, pg).await {
                Ok((pkgs, more)) => {
                    let _ = tx.send(Msg::Loaded(gen, pkgs, more)).await;
                }
                Err(e) => {
                    let _ = tx.send(Msg::Err(e.to_string())).await;
                }
            }
        });
    }

    /// Trigger GitHub stats fetch for the selected package (lazy, called on Enter).
    /// Serves from cache when fresh; shows stale data while re-fetching.
    pub fn ensure_gh_stats(&mut self) {
        let Some(pkg) = self.selected() else {
            self.gh = GhState::NoRepo;
            return;
        };
        let Some(repo_url) = pkg.repo_url.clone() else {
            self.gh = GhState::NoRepo;
            return;
        };

        if let Some(entry) = cache::get_fresh(&self.cache, &repo_url) {
            self.gh = GhState::Cached(entry.clone());
            return;
        }

        // Show stale data while re-fetching.
        if let Some(entry) = cache::get_any(&self.cache, &repo_url) {
            self.gh = GhState::Cached(entry.clone());
        } else {
            self.gh = GhState::Loading;
        }

        let tx = self.tx.clone();
        let token = self.token.clone();
        let url = repo_url.clone();
        tokio::spawn(async move {
            let result = fetch_github_stats(&url, token.as_deref())
                .await
                .unwrap_or(GhResult::Unavailable);
            let _ = tx.send(Msg::GhFetched(url, result)).await;
        });
    }

    // ── Message handler ───────────────────────────────────────────────────────

    pub fn on_msg(&mut self, msg: Msg) {
        match msg {
            Msg::Loaded(gen, pkgs, more) => {
                // Discard results from superseded fetches (e.g. rapid sort/language changes).
                if gen != self.fetch_gen {
                    return;
                }
                self.loading = false;
                self.has_more = more;
                self.packages = pkgs;
                if !self.packages.is_empty() {
                    self.list_state.select(Some(0));
                }
            }
            Msg::GhFetched(repo_url, result) => match result {
                GhResult::Ok(stats) => {
                    cache::insert(&mut self.cache, repo_url, &stats);
                    self.gh = GhState::Live(stats);
                }
                GhResult::RateLimited => {
                    self.gh = GhState::RateLimited;
                }
                GhResult::BadToken => {
                    self.gh = GhState::BadToken;
                }
                GhResult::Unavailable => {
                    self.gh = GhState::Unavailable;
                }
            },
            Msg::Err(e) => {
                self.loading = false;
                self.error = Some(e);
            }
        }
    }

    // ── Accessors ─────────────────────────────────────────────────────────────

    pub fn selected(&self) -> Option<&Package> {
        self.list_state
            .selected()
            .and_then(|i| self.packages.get(i))
    }

    /// Cached stats for the highlighted package (list preview — no live fetch).
    pub fn preview_gh(&self) -> Option<&CachedEntry> {
        let repo = self.selected()?.repo_url.as_deref()?;
        cache::get_any(&self.cache, repo)
    }

    // ── Settings ──────────────────────────────────────────────────────────────

    pub fn open_settings(&mut self) {
        self.view = View::Settings;
        self.settings_cursor = 0;
        self.settings_editing = false;
        self.settings_input.clear();
        self.settings_config = storage::load_meta().map(|m| m.config).unwrap_or_default();
        self.settings_token = storage::load_github_token();
    }

    fn key_settings(&mut self, key: KeyEvent) -> bool {
        let rows = SettingRow::all();

        if self.settings_editing {
            match key.code {
                KeyCode::Esc => {
                    self.settings_editing = false;
                    self.settings_input.clear();
                }
                KeyCode::Enter => {
                    let t = self.settings_input.trim().to_string();
                    let _ = storage::save_github_token(if t.is_empty() {
                        None
                    } else {
                        Some(t.as_str())
                    });
                    self.settings_token = storage::load_github_token();
                    self.token = github_token(); // refresh live token
                    self.settings_editing = false;
                    self.settings_input.clear();
                }
                KeyCode::Backspace => {
                    self.settings_input.pop();
                }
                KeyCode::Char(c) => {
                    if self.settings_input.len() < 256 {
                        self.settings_input.push(c);
                    }
                }
                _ => {}
            }
            return false;
        }

        match key.code {
            KeyCode::Char('q') | KeyCode::Esc => {
                self.view = View::List;
            }
            KeyCode::Char('c') if key.modifiers.contains(KeyModifiers::CONTROL) => return true,

            KeyCode::Down | KeyCode::Char('j') => {
                self.settings_cursor = (self.settings_cursor + 1).min(rows.len() - 1);
            }
            KeyCode::Up | KeyCode::Char('k') => {
                self.settings_cursor = self.settings_cursor.saturating_sub(1);
            }

            KeyCode::Enter => match rows[self.settings_cursor] {
                SettingRow::GithubToken => {
                    // Pre-fill with current token so the user can edit it.
                    self.settings_input = self.settings_token.clone().unwrap_or_default();
                    self.settings_editing = true;
                }
                SettingRow::Compress => {
                    self.settings_config.compress = !self.settings_config.compress;
                    self.persist_settings_config();
                }
                SettingRow::ClearGhCache => {
                    self.cache.clear();
                    if let Ok(dir) = storage::cache_dir() {
                        let _ = std::fs::remove_file(dir.join("gh_stats.json"));
                    }
                }
                SettingRow::KeepWeeks => {}
            },

            // `d` on the token row clears it.
            KeyCode::Char('d')
                if rows.get(self.settings_cursor) == Some(&SettingRow::GithubToken) =>
            {
                let _ = storage::save_github_token(None);
                self.settings_token = None;
                self.token = None;
            }

            // ← / → cycle keep_weeks through preset values.
            KeyCode::Left | KeyCode::Right
                if rows.get(self.settings_cursor) == Some(&SettingRow::KeepWeeks) =>
            {
                const PRESETS: &[u32] = &[1, 2, 4, 8, 12, 24, 52];
                let pos = PRESETS
                    .iter()
                    .position(|&w| w == self.settings_config.keep_weeks);
                let cur = pos.unwrap_or(4); // default to 12-week slot
                let next = if key.code == KeyCode::Left {
                    cur.saturating_sub(1)
                } else {
                    (cur + 1).min(PRESETS.len() - 1)
                };
                self.settings_config.keep_weeks = PRESETS[next];
                self.persist_settings_config();
            }

            _ => {}
        }
        false
    }

    fn persist_settings_config(&mut self) {
        if let Ok(mut meta) = storage::load_meta() {
            meta.config = self.settings_config.clone();
            let _ = storage::save_meta(&meta);
        }
    }

    // ── Language switching ────────────────────────────────────────────────────

    // ── Favorites ─────────────────────────────────────────────────────────────

    /// Toggle the star on the currently selected package and persist to disk.
    pub fn toggle_star(&mut self) {
        let Some(pkg) = self.selected() else { return };
        let name = pkg.name.clone();
        let lang = pkg.language;
        favorites::toggle(&mut self.favorites, &name, lang);
        favorites::save(&self.favorites);
        // In favorites mode: remove the package from view immediately if unstarred.
        if self.favorites_mode && !self.favorites.contains_key(&name) {
            self.packages.retain(|p| p.name != name);
            if self.packages.is_empty() {
                self.favorites_mode = false;
                self.load();
            } else {
                // Keep selection in bounds.
                let max = self.packages.len().saturating_sub(1);
                if let Some(i) = self.list_state.selected() {
                    self.list_state.select(Some(i.min(max)));
                }
            }
        }
    }

    /// Enter or exit the favorites view.
    pub fn toggle_favorites_mode(&mut self) {
        if self.favorites_mode {
            self.favorites_mode = false;
            self.reset_nav();
            self.load();
        } else {
            if self.favorites.is_empty() {
                return;
            } // nothing starred yet
            self.favorites_mode = true;
            self.list_state = ListState::default();
            self.scroll = 0;
            self.view = View::List;
            self.load_favorites();
        }
    }

    fn load_favorites(&mut self) {
        self.loading = true;
        self.error = None;
        self.fetch_gen += 1;
        let gen = self.fetch_gen;
        let tx = self.tx.clone();
        let favs = self.favorites.clone();
        tokio::spawn(async move {
            let names = favs.keys().cloned().collect();
            let mut pkgs = fetch_by_names(names).await;
            // Override language from saved favorites — avoids [?] when the
            // listing API omits build_tools for fetched-by-name packages.
            for pkg in &mut pkgs {
                if let Some(&lang) = favs.get(&pkg.name) {
                    pkg.language = lang;
                }
            }
            let _ = tx.send(Msg::Loaded(gen, pkgs, false)).await;
        });
    }

    pub fn switch_language(&mut self) {
        self.language = self.language.cycle();
        self.favorites_mode = false;
        self.reset_nav();
        self.load();
    }

    pub fn switch_language_back(&mut self) {
        self.language = self.language.cycle_back();
        self.favorites_mode = false;
        self.reset_nav();
        self.load();
    }

    fn reset_nav(&mut self) {
        self.view = View::List;
        self.list_state = ListState::default();
        self.scroll = 0;
        self.gh = GhState::NoRepo;
        self.page = 1;
        self.has_more = false;
    }

    pub fn next_page(&mut self) {
        if self.has_more && self.input.trim().is_empty() {
            self.page += 1;
            self.list_state = ListState::default();
            self.scroll = 0;
            self.load();
        }
    }

    pub fn prev_page(&mut self) {
        if self.page > 1 && self.input.trim().is_empty() {
            self.page -= 1;
            self.list_state = ListState::default();
            self.scroll = 0;
            self.load();
        }
    }

    // ── Navigation ────────────────────────────────────────────────────────────

    fn nav(&mut self, delta: i32) {
        if self.packages.is_empty() {
            return;
        }
        let n = self.packages.len() as i32;
        let cur = self.list_state.selected().unwrap_or(0) as i32;
        let nxt = (cur + delta).clamp(0, n - 1) as usize;
        if nxt != cur as usize {
            self.list_state.select(Some(nxt));
        }
    }

    // ── Key handling ──────────────────────────────────────────────────────────

    /// Returns `true` when the app should quit.
    pub fn on_key(&mut self, key: KeyEvent) -> bool {
        if self.input_mode {
            return self.key_input(key);
        }
        match self.view {
            View::List => self.key_list(key),
            View::Detail => self.key_detail(key),
            View::Settings => self.key_settings(key),
        }
    }

    fn key_input(&mut self, key: KeyEvent) -> bool {
        match key.code {
            KeyCode::Esc => {
                self.input_mode = false;
            }
            KeyCode::Enter => {
                self.input_mode = false;
                self.page = 1;
                self.load();
            }
            KeyCode::Backspace => {
                self.input.pop();
            }
            KeyCode::Char(c) => {
                if self.input.len() < 200 {
                    self.input.push(c);
                }
            }
            _ => {}
        }
        false
    }

    fn key_list(&mut self, key: KeyEvent) -> bool {
        match key.code {
            KeyCode::Char('q') => return true,
            KeyCode::Char('c') if key.modifiers.contains(KeyModifiers::CONTROL) => return true,

            KeyCode::Char('/') => {
                self.input_mode = true;
            }
            KeyCode::Char('?') => {
                self.open_settings();
            }
            KeyCode::Tab => {
                self.sort = self.sort.cycle();
                self.page = 1;
                self.load();
            }
            KeyCode::Char(']') => self.next_page(),
            KeyCode::Char('[') => self.prev_page(),

            KeyCode::Char('l') => self.switch_language(),
            KeyCode::Char('L') => self.switch_language_back(),
            KeyCode::Char('s') => self.toggle_star(),
            KeyCode::Char('f') => self.toggle_favorites_mode(),

            KeyCode::Down | KeyCode::Char('j') => self.nav(1),
            KeyCode::Up | KeyCode::Char('k') => self.nav(-1),
            KeyCode::PageDown => self.nav(10),
            KeyCode::PageUp => self.nav(-10),

            KeyCode::Enter => {
                if !self.packages.is_empty() {
                    self.view = View::Detail;
                    self.scroll = 0;
                    self.ensure_gh_stats();
                }
            }
            KeyCode::Char('r') => {
                if !self.loading {
                    if self.favorites_mode {
                        self.load_favorites();
                    } else {
                        self.load();
                    }
                }
            }
            _ => {}
        }
        false
    }

    fn key_detail(&mut self, key: KeyEvent) -> bool {
        match key.code {
            KeyCode::Char('q') | KeyCode::Esc | KeyCode::Backspace => {
                self.view = View::List;
            }
            KeyCode::Char('c') if key.modifiers.contains(KeyModifiers::CONTROL) => return true,
            KeyCode::Down | KeyCode::Char('j') => {
                self.scroll = self.scroll.saturating_add(1);
            }
            KeyCode::Up | KeyCode::Char('k') => {
                self.scroll = self.scroll.saturating_sub(1);
            }
            KeyCode::PageDown => {
                self.scroll = self.scroll.saturating_add(10);
            }
            KeyCode::PageUp => {
                self.scroll = self.scroll.saturating_sub(10);
            }
            _ => {}
        }
        false
    }
}