use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use tauri::{AppHandle, Emitter, Manager};

use crate::state::AppState;

#[allow(dead_code)]
pub const TAB_SLEEP_THRESHOLD_SECS: i64 = 30 * 60;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BrowserTab {
    pub id: String,
    pub label: String,
    pub url: String,
    pub title: String,
    pub favicon: Option<String>,
    pub loading: bool,
    pub pinned: bool,
    pub sleeping: bool,
    pub zoom: f64,
    pub can_go_back: bool,
    pub can_go_forward: bool,
    pub last_active: i64,
}

#[derive(Default)]
pub struct TabManager {
    pub tabs: HashMap<String, BrowserTab>,
    pub order: Vec<String>,
    pub active: Option<String>,
    pub closed_stack: Vec<BrowserTab>,
    pub zoom_memory: HashMap<String, f64>,
}

impl TabManager {
    pub fn push_closed(&mut self, tab: BrowserTab) {
        if self.closed_stack.len() >= 25 { self.closed_stack.remove(0); }
        self.closed_stack.push(tab);
    }
    pub fn pop_closed(&mut self) -> Option<BrowserTab> { self.closed_stack.pop() }
    pub fn remember_zoom(&mut self, domain: &str, zoom: f64) { self.zoom_memory.insert(domain.to_string(), zoom); }
    pub fn get_zoom_for_domain(&self, domain: &str) -> Option<f64> { self.zoom_memory.get(domain).copied() }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ViewportLayout {
    #[serde(default)]
    pub x: f64,
    #[serde(default)]
    pub y: f64,
    pub width: f64,
    pub height: f64,
}

#[derive(Debug, Clone, Serialize)]
pub struct BrowserSnapshot {
    pub tabs: Vec<BrowserTab>,
    pub active: Option<String>,
    pub can_restore: bool,
}

pub fn snapshot(app: &AppHandle) -> Result<BrowserSnapshot, String> {
    let state = app.state::<AppState>();
    let tabs = state.tabs.lock().map_err(|_| "lock")?;
    let ordered = tabs.order.iter().filter_map(|id| tabs.tabs.get(id).cloned()).collect();
    let can_restore = !tabs.closed_stack.is_empty();
    Ok(BrowserSnapshot { tabs: ordered, active: tabs.active.clone(), can_restore })
}

pub fn emit_snapshot(app: &AppHandle) -> Result<(), String> {
    let snap = snapshot(app)?;
    app.emit("browser://tabs", snap).map_err(|e| e.to_string())
}

pub fn update_tab_field(app: &AppHandle, id: &str, f: impl FnOnce(&mut BrowserTab)) {
    let state = app.state::<AppState>();
    if let Ok(mut tabs) = state.tabs.lock() {
        if let Some(tab) = tabs.tabs.get_mut(id) { f(tab); }
    }
    let _ = emit_snapshot(app);
}

pub fn tab_label(app: &AppHandle, tab_id: &str) -> Result<String, String> {
    let state = app.state::<AppState>();
    let tabs = state.tabs.lock().map_err(|_| "lock")?;
    tabs.tabs.get(tab_id).map(|t| t.label.clone()).ok_or_else(|| format!("tab not found: {tab_id}"))
}

pub fn eval_on_tab(app: &AppHandle, tab_id: &str, js: &str) -> Result<(), String> {
    let label = tab_label(app, tab_id)?;
    app.get_webview(&label).ok_or("webview not found")?.eval(js).map_err(|e| e.to_string())
}

pub fn extract_domain(url: &str) -> String {
    url.split("//").nth(1)
        .and_then(|s| s.split('/').next())
        .map(|s| s.split(':').next().unwrap_or(s))
        .unwrap_or("")
        .trim_start_matches("www.")
        .to_lowercase()
}