use rusqlite::{Connection, Result, params};
use serde::{Deserialize, Serialize};
use chrono::Utc;
use uuid::Uuid;

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Profile {
    pub id: String,
    pub name: String,
    pub created_at: String,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct GuideRow {
    pub gid: String,
    pub name: String,
    pub data: String,
    pub last_synced_at: Option<String>,
}

pub fn get_db_path() -> String {
    let data_dir = dirs_next::data_dir()
        .unwrap_or_else(|| std::path::PathBuf::from("."))
        .join("toughligui");
    std::fs::create_dir_all(&data_dir).ok();
    data_dir.join("toughligui.db").to_string_lossy().to_string()
}

pub fn open() -> Result<Connection> {
    let path = get_db_path();
    let conn = Connection::open(&path)?;
    conn.execute_batch("PRAGMA journal_mode=WAL; PRAGMA foreign_keys=ON;")?;
    Ok(conn)
}

pub fn migrate(conn: &Connection) -> Result<()> {
    conn.execute_batch("
        CREATE TABLE IF NOT EXISTS profiles (
            id TEXT PRIMARY KEY,
            name TEXT UNIQUE NOT NULL,
            created_at TEXT NOT NULL
        );

        CREATE TABLE IF NOT EXISTS guides (
            gid TEXT PRIMARY KEY,
            name TEXT NOT NULL,
            data TEXT NOT NULL,
            last_synced_at TEXT
        );

        CREATE TABLE IF NOT EXISTS quest_completions (
            profile_id TEXT NOT NULL,
            quest_name TEXT NOT NULL,
            completed_at TEXT NOT NULL,
            PRIMARY KEY (profile_id, quest_name),
            FOREIGN KEY (profile_id) REFERENCES profiles(id) ON DELETE CASCADE
        );

        CREATE TABLE IF NOT EXISTS settings (
            key TEXT PRIMARY KEY,
            value TEXT NOT NULL
        );

        CREATE TABLE IF NOT EXISTS quest_step_progress (
            profile_id TEXT NOT NULL,
            quest_name TEXT NOT NULL,
            step_index INTEGER NOT NULL,
            PRIMARY KEY (profile_id, quest_name, step_index),
            FOREIGN KEY (profile_id) REFERENCES profiles(id) ON DELETE CASCADE
        );

        CREATE TABLE IF NOT EXISTS resource_inventory (
            profile_id TEXT NOT NULL,
            resource_name TEXT NOT NULL,
            quantity INTEGER NOT NULL DEFAULT 0,
            PRIMARY KEY (profile_id, resource_name),
            FOREIGN KEY (profile_id) REFERENCES profiles(id) ON DELETE CASCADE
        );
    ")?;
    Ok(())
}

pub fn get_profiles(conn: &Connection) -> Result<Vec<Profile>> {
    let mut stmt = conn.prepare("SELECT id, name, created_at FROM profiles ORDER BY created_at ASC")?;
    let rows = stmt.query_map([], |row| {
        Ok(Profile {
            id: row.get(0)?,
            name: row.get(1)?,
            created_at: row.get(2)?,
        })
    })?;
    rows.collect()
}

pub fn create_profile(conn: &Connection, name: &str) -> Result<Profile> {
    let id = Uuid::new_v4().to_string();
    let created_at = Utc::now().to_rfc3339();
    conn.execute(
        "INSERT INTO profiles (id, name, created_at) VALUES (?1, ?2, ?3)",
        params![id, name, created_at],
    )?;
    Ok(Profile { id, name: name.to_string(), created_at })
}

pub fn delete_profile(conn: &Connection, profile_id: &str) -> Result<()> {
    conn.execute("DELETE FROM profiles WHERE id = ?1", params![profile_id])?;
    Ok(())
}

pub fn get_completed_quests(conn: &Connection, profile_id: &str) -> Result<Vec<String>> {
    let mut stmt = conn.prepare(
        "SELECT quest_name FROM quest_completions WHERE profile_id = ?1"
    )?;
    let rows = stmt.query_map(params![profile_id], |row| row.get(0))?;
    rows.collect()
}

pub fn toggle_quest(conn: &Connection, profile_id: &str, quest_name: &str) -> Result<bool> {
    let exists: bool = conn.query_row(
        "SELECT COUNT(*) FROM quest_completions WHERE profile_id = ?1 AND quest_name = ?2",
        params![profile_id, quest_name],
        |row| row.get::<_, i64>(0),
    ).map(|c| c > 0)?;

    if exists {
        conn.execute(
            "DELETE FROM quest_completions WHERE profile_id = ?1 AND quest_name = ?2",
            params![profile_id, quest_name],
        )?;
        Ok(false)
    } else {
        let now = Utc::now().to_rfc3339();
        conn.execute(
            "INSERT INTO quest_completions (profile_id, quest_name, completed_at) VALUES (?1, ?2, ?3)",
            params![profile_id, quest_name, now],
        )?;
        Ok(true)
    }
}

pub fn upsert_guide(conn: &Connection, gid: &str, name: &str, data: &str) -> Result<()> {
    let now = Utc::now().to_rfc3339();
    conn.execute(
        "INSERT INTO guides (gid, name, data, last_synced_at) VALUES (?1, ?2, ?3, ?4)
         ON CONFLICT(gid) DO UPDATE SET name=excluded.name, data=excluded.data, last_synced_at=excluded.last_synced_at",
        params![gid, name, data, now],
    )?;
    Ok(())
}

pub fn get_guides(conn: &Connection) -> Result<Vec<GuideRow>> {
    let mut stmt = conn.prepare("SELECT gid, name, data, last_synced_at FROM guides ORDER BY rowid ASC")?;
    let rows = stmt.query_map([], |row| {
        Ok(GuideRow {
            gid: row.get(0)?,
            name: row.get(1)?,
            data: row.get(2)?,
            last_synced_at: row.get(3)?,
        })
    })?;
    rows.collect()
}

pub fn get_completed_steps(conn: &Connection, profile_id: &str, quest_name: &str) -> Result<Vec<i64>> {
    let mut stmt = conn.prepare(
        "SELECT step_index FROM quest_step_progress WHERE profile_id = ?1 AND quest_name = ?2"
    )?;
    let rows = stmt.query_map(params![profile_id, quest_name], |row| row.get(0))?;
    rows.collect()
}

pub fn toggle_quest_step(conn: &Connection, profile_id: &str, quest_name: &str, step_index: i64) -> Result<bool> {
    let exists: bool = conn.query_row(
        "SELECT COUNT(*) FROM quest_step_progress WHERE profile_id = ?1 AND quest_name = ?2 AND step_index = ?3",
        params![profile_id, quest_name, step_index],
        |row| row.get::<_, i64>(0),
    ).map(|c| c > 0)?;

    if exists {
        conn.execute(
            "DELETE FROM quest_step_progress WHERE profile_id = ?1 AND quest_name = ?2 AND step_index = ?3",
            params![profile_id, quest_name, step_index],
        )?;
        Ok(false)
    } else {
        conn.execute(
            "INSERT INTO quest_step_progress (profile_id, quest_name, step_index) VALUES (?1, ?2, ?3)",
            params![profile_id, quest_name, step_index],
        )?;
        Ok(true)
    }
}

pub fn get_resource_inventory(conn: &Connection, profile_id: &str) -> Result<Vec<(String, i64)>> {
    let mut stmt = conn.prepare(
        "SELECT resource_name, quantity FROM resource_inventory WHERE profile_id = ?1"
    )?;
    let rows = stmt.query_map(params![profile_id], |row| {
        Ok((row.get::<_, String>(0)?, row.get::<_, i64>(1)?))
    })?;
    rows.collect()
}

pub fn set_resource_quantity(conn: &Connection, profile_id: &str, resource_name: &str, quantity: i64) -> Result<()> {
    if quantity <= 0 {
        conn.execute(
            "DELETE FROM resource_inventory WHERE profile_id = ?1 AND resource_name = ?2",
            params![profile_id, resource_name],
        )?;
    } else {
        conn.execute(
            "INSERT INTO resource_inventory (profile_id, resource_name, quantity) VALUES (?1, ?2, ?3)
             ON CONFLICT(profile_id, resource_name) DO UPDATE SET quantity=excluded.quantity",
            params![profile_id, resource_name, quantity],
        )?;
    }
    Ok(())
}

pub fn get_setting(conn: &Connection, key: &str) -> Option<String> {
    conn.query_row(
        "SELECT value FROM settings WHERE key = ?1",
        params![key],
        |row| row.get(0),
    ).ok()
}

pub fn set_setting(conn: &Connection, key: &str, value: &str) -> Result<()> {
    conn.execute(
        "INSERT INTO settings (key, value) VALUES (?1, ?2)
         ON CONFLICT(key) DO UPDATE SET value=excluded.value",
        params![key, value],
    )?;
    Ok(())
}