use anyhow::{Context, Result};
use rusqlite::Connection;
use std::str::FromStr;
use uuid::Uuid;

use crate::filetree::node::{Aliases, FileNode, NodeType};

pub mod convert;
pub mod mode;
pub mod modes;
pub mod node;

pub struct FileTree {
    pub user_id: String,
    pub nodes: Vec<FileNode>,
}

const CREATE_TABLES: &str = "
CREATE TABLE IF NOT EXISTS file_registry (
    file_uuid TEXT PRIMARY KEY,
    original_name TEXT NOT NULL,
    file_size INTEGER,
    file_type TEXT,
    registered_at TEXT NOT NULL DEFAULT (datetime('now')),
    last_seen_at TEXT,
    status TEXT NOT NULL DEFAULT 'active'
);

CREATE TABLE IF NOT EXISTS file_nodes (
    node_id TEXT PRIMARY KEY,
    label TEXT NOT NULL,
    aliases_json TEXT NOT NULL DEFAULT '{}',
    file_uuid TEXT,
    sha256 TEXT,
    parent_id TEXT,
    children_json TEXT NOT NULL DEFAULT '[]',
    node_type TEXT NOT NULL DEFAULT 'folder',
    icon TEXT,
    color TEXT,
    bg_color TEXT,
    file_size INTEGER,
    registered_at TEXT,
    created_at TEXT NOT NULL DEFAULT (datetime('now')),
    updated_at TEXT NOT NULL DEFAULT (datetime('now')),
    sort_order INTEGER NOT NULL DEFAULT 0
);

CREATE TABLE IF NOT EXISTS file_locations (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    file_uuid TEXT NOT NULL,
    location TEXT NOT NULL,
    label TEXT,
    added_at TEXT NOT NULL DEFAULT (datetime('now')),
    UNIQUE(file_uuid, location)
);
";

impl FileTree {
    pub fn user_db_path(user_id: &str) -> String {
        format!("data/users/{}.sqlite", user_id)
    }

    pub fn init_user_db(user_id: &str) -> Result<Connection> {
        let db_path = Self::user_db_path(user_id);
        let parent = std::path::Path::new(&db_path).parent().unwrap();
        std::fs::create_dir_all(parent)?;

        let conn = Connection::open(&db_path)?;
        conn.execute_batch(CREATE_TABLES)?;
        Ok(conn)
    }

    pub fn open_user_db(user_id: &str) -> Result<Connection> {
        let db_path = Self::user_db_path(user_id);
        Connection::open(&db_path).with_context(|| format!("Failed to open {}", db_path))
    }

    pub fn load(conn: &Connection, user_id: &str) -> Result<Self> {
        let mut stmt = conn.prepare(
            "SELECT node_id, label, aliases_json, file_uuid, sha256, parent_id, children_json,
                    node_type, icon, color, bg_color, file_size, registered_at,
                    created_at, updated_at, sort_order
             FROM file_nodes ORDER BY sort_order ASC, created_at ASC",
        )?;

        let nodes: Vec<FileNode> = stmt
            .query_map([], |row| {
                let children_json: String = row.get(6)?;
                let children: Vec<String> =
                    serde_json::from_str(&children_json).unwrap_or_default();
                Ok(FileNode {
                    node_id: row.get(0)?,
                    label: row.get(1)?,
                    aliases: Aliases::from_json(&row.get::<_, String>(2)?),
                    file_uuid: row.get(3)?,
                    sha256: row.get(4)?,
                    parent_id: row.get(5)?,
                    children,
                    node_type: NodeType::from_str(&row.get::<_, String>(7)?)
                        .unwrap_or(NodeType::Folder),
                    icon: row.get(8)?,
                    color: row.get(9)?,
                    bg_color: row.get(10)?,
                    file_size: row.get(11)?,
                    registered_at: row.get(12)?,
                    created_at: row.get(13)?,
                    updated_at: row.get(14)?,
                    sort_order: row.get(15)?,
                })
            })?
            .filter_map(|r| r.ok())
            .collect();

        Ok(FileTree {
            user_id: user_id.to_string(),
            nodes,
        })
    }

    pub fn insert_node(&mut self, conn: &Connection, node: &FileNode) -> Result<()> {
        conn.execute(
            "INSERT INTO file_nodes (node_id, label, aliases_json, file_uuid, sha256, parent_id,
             children_json, node_type, icon, color, bg_color, file_size, registered_at,
             created_at, updated_at, sort_order)
             VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15, ?16)",
            rusqlite::params![
                node.node_id,
                node.label,
                node.aliases.to_json(),
                node.file_uuid,
                node.sha256,
                node.parent_id,
                serde_json::to_string(&node.children).unwrap_or_else(|_| "[]".to_string()),
                node.node_type.as_str(),
                node.icon,
                node.color,
                node.bg_color,
                node.file_size,
                node.registered_at,
                node.created_at,
                node.updated_at,
                node.sort_order,
            ],
        )?;
        self.nodes.push(node.clone());
        Ok(())
    }

    pub fn update_node(
        &mut self,
        conn: &Connection,
        node_id: &str,
        updated: &FileNode,
    ) -> Result<()> {
        conn.execute(
            "UPDATE file_nodes SET label=?1, aliases_json=?2, file_uuid=?3, sha256=?4, parent_id=?5,
             children_json=?6, node_type=?7, icon=?8, color=?9, bg_color=?10,
             file_size=?11, registered_at=?12,
             updated_at=?13, sort_order=?14
             WHERE node_id=?15",
            rusqlite::params![
                updated.label,
                updated.aliases.to_json(),
                updated.file_uuid,
                updated.sha256,
                updated.parent_id,
                serde_json::to_string(&updated.children)
                    .unwrap_or_else(|_| "[]".to_string()),
                updated.node_type.as_str(),
                updated.icon,
                updated.color,
                updated.bg_color,
                updated.file_size,
                updated.registered_at,
                updated.updated_at,
                updated.sort_order,
                node_id,
            ],
        )?;

        if let Some(n) = self.nodes.iter_mut().find(|n| n.node_id == node_id) {
            *n = updated.clone();
        }
        Ok(())
    }

    pub fn update_node_alias(
        &mut self,
        conn: &Connection,
        node_id: &str,
        lang: &str,
        value: &str,
    ) -> Result<()> {
        let node = self
            .nodes
            .iter_mut()
            .find(|n| n.node_id == node_id)
            .context("Node not found")?;

        node.aliases.set(lang, value);

        let now = chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string();
        node.updated_at = now.clone();

        conn.execute(
            "UPDATE file_nodes SET aliases_json=?1, updated_at=?2 WHERE node_id=?3",
            rusqlite::params![node.aliases.to_json(), now, node_id],
        )?;

        Ok(())
    }

    pub fn delete_node(&mut self, conn: &Connection, node_id: &str) -> Result<()> {
        conn.execute("DELETE FROM file_nodes WHERE node_id=?1", [node_id])?;
        self.nodes.retain(|n| n.node_id != node_id);
        Ok(())
    }

    pub fn move_node(
        &mut self,
        conn: &Connection,
        node_id: &str,
        new_parent_id: Option<String>,
    ) -> Result<()> {
        let now = chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string();

        conn.execute(
            "UPDATE file_nodes SET parent_id=?1, updated_at=?2 WHERE node_id=?3",
            rusqlite::params![new_parent_id, now, node_id],
        )?;

        if let Some(n) = self.nodes.iter_mut().find(|n| n.node_id == node_id) {
            n.parent_id = new_parent_id;
            n.updated_at = now;
        }
        Ok(())
    }

    pub fn build_tree(&self) -> Vec<FileNode> {
        let mut roots: Vec<FileNode> = self
            .nodes
            .iter()
            .filter(|n| n.parent_id.is_none())
            .cloned()
            .collect();

        for root in &mut roots {
            self.fill_children(root);
        }
        roots
    }

    fn fill_children(&self, node: &mut FileNode) {
        let child_ids: Vec<String> = node.children.clone();
        let mut children: Vec<FileNode> = self
            .nodes
            .iter()
            .filter(|n| {
                n.parent_id.as_deref() == Some(&node.node_id) && child_ids.contains(&n.node_id)
            })
            .cloned()
            .collect();

        for child in &mut children {
            self.fill_children(child);
        }

        node.children = children.iter().map(|c| c.node_id.clone()).collect();
        node.children
            .extend(children.iter().flat_map(|c| c.children.clone()));
    }

    pub fn new_folder(label: &str, parent_id: Option<String>) -> FileNode {
        let now = chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string();
        FileNode {
            node_id: Uuid::new_v4().to_string(),
            label: label.to_string(),
            aliases: Aliases::empty(),
            file_uuid: None,
            sha256: None,
            parent_id,
            children: vec![],
            node_type: NodeType::Folder,
            icon: None,
            color: None,
            bg_color: None,
            file_size: None,
            registered_at: None,
            created_at: now.clone(),
            updated_at: now,
            sort_order: 0,
        }
    }

    #[allow(clippy::too_many_arguments)]
    pub fn new_file_node(
        label: &str,
        file_uuid: &str,
        sha256: Option<&str>,
        original_name: &str,
        file_size: Option<i64>,
        file_type: Option<&str>,
        registered_at: Option<&str>,
        parent_id: Option<String>,
    ) -> (FileNode, Option<String>) {
        let now = chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string();
        let reg_at = registered_at
            .map(|s| s.to_string())
            .unwrap_or_else(|| now.clone());
        let node = FileNode {
            node_id: Uuid::new_v4().to_string(),
            label: label.to_string(),
            aliases: Aliases::empty(),
            file_uuid: Some(file_uuid.to_string()),
            sha256: sha256.map(|s| s.to_string()),
            parent_id,
            children: vec![],
            node_type: NodeType::File,
            icon: None,
            color: None,
            bg_color: None,
            file_size,
            registered_at: Some(reg_at),
            created_at: now.clone(),
            updated_at: now.clone(),
            sort_order: 0,
        };

        let register_sql =
            format!(
            "INSERT OR REPLACE INTO file_registry (file_uuid, original_name, file_size, file_type,
             registered_at, status) VALUES ('{}', '{}', {}, {}, '{}', 'active')",
            file_uuid,
            original_name.replace('\'', "''"),
            file_size.map_or("NULL".to_string(), |s| s.to_string()),
            file_type.map_or("NULL".to_string(), |t| format!("'{}'", t.replace('\'', "''"))),
            now,
        );

        (node, Some(register_sql))
    }

    pub fn add_location(
        conn: &Connection,
        file_uuid: &str,
        location: &str,
        label: Option<&str>,
    ) -> Result<()> {
        conn.execute(
            "INSERT OR IGNORE INTO file_locations (file_uuid, location, label) VALUES (?1, ?2, ?3)",
            rusqlite::params![file_uuid, location, label],
        )?;
        Ok(())
    }

    pub fn get_file_info(conn: &Connection, file_uuid: &str) -> Result<serde_json::Value> {
        let mut virtual_paths: Vec<String> = Vec::new();
        let mut stmt = conn.prepare(
            "SELECT fn.node_id, fn.label, fn.parent_id FROM file_nodes fn WHERE fn.file_uuid = ?1",
        )?;
        let node_rows: Vec<(String, String, Option<String>)> = stmt
            .query_map([file_uuid], |row| {
                Ok((
                    row.get::<_, String>(0)?,
                    row.get::<_, String>(1)?,
                    row.get::<_, Option<String>>(2)?,
                ))
            })?
            .filter_map(|r| r.ok())
            .collect();

        for (_nid, _label, _parent_id) in &node_rows {
            let mut path_parts: Vec<String> = vec![];
            let mut current = _parent_id.clone();
            while let Some(pid) = current {
                let folder: Option<(String, Option<String>)> = conn
                    .query_row(
                        "SELECT label, parent_id FROM file_nodes WHERE node_id = ?1",
                        [&pid],
                        |row| Ok((row.get(0)?, row.get(1)?)),
                    )
                    .ok();
                if let Some((name, next_pid)) = folder {
                    path_parts.push(name);
                    current = next_pid;
                } else {
                    break;
                }
            }
            path_parts.reverse();
            virtual_paths.push(path_parts.join(" / "));
        }

        let mut real_locations: Vec<serde_json::Value> = Vec::new();
        let mut lstmt = conn.prepare(
            "SELECT location, label, added_at FROM file_locations WHERE file_uuid = ?1 ORDER BY added_at",
        )?;
        let locs: Vec<(String, Option<String>, String)> = lstmt
            .query_map([file_uuid], |row| {
                Ok((
                    row.get::<_, String>(0)?,
                    row.get::<_, Option<String>>(1)?,
                    row.get::<_, String>(2)?,
                ))
            })?
            .filter_map(|r| r.ok())
            .collect();
        for (loc, lbl, added) in &locs {
            real_locations.push(serde_json::json!({
                "path": loc,
                "label": lbl,
                "added_at": added,
            }));
        }

        Ok(serde_json::json!({
            "file_uuid": file_uuid,
            "virtual_paths": virtual_paths,
            "real_locations": real_locations,
            "node_count": node_rows.len(),
            "location_count": locs.len(),
        }))
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn temp_db() -> (Connection, String) {
        let user_id = format!("test_{}", Uuid::new_v4());
        let conn = FileTree::init_user_db(&user_id).unwrap();
        (conn, user_id)
    }

    #[test]
    fn test_init_and_load_empty_tree() {
        let (conn, user_id) = temp_db();
        let tree = FileTree::load(&conn, &user_id).unwrap();
        assert_eq!(tree.user_id, user_id);
        assert!(tree.nodes.is_empty());
    }

    #[test]
    fn test_insert_and_load_node() {
        let (conn, user_id) = temp_db();
        let mut tree = FileTree::load(&conn, &user_id).unwrap();

        let folder = FileTree::new_folder("Videos", None);
        tree.insert_node(&conn, &folder).unwrap();

        let loaded = FileTree::load(&conn, &user_id).unwrap();
        assert_eq!(loaded.nodes.len(), 1);
        assert_eq!(loaded.nodes[0].label, "Videos");
        assert_eq!(loaded.nodes[0].node_type, NodeType::Folder);
    }

    #[test]
    fn test_update_node() {
        let (conn, user_id) = temp_db();
        let mut tree = FileTree::load(&conn, &user_id).unwrap();

        let mut folder = FileTree::new_folder("Videos", None);
        tree.insert_node(&conn, &folder).unwrap();

        folder.label = "Movies".to_string();
        folder.icon = Some("📽️".to_string());
        folder.color = Some("#ff0000".to_string());
        tree.update_node(&conn, &folder.node_id, &folder).unwrap();

        let loaded = FileTree::load(&conn, &user_id).unwrap();
        assert_eq!(loaded.nodes[0].label, "Movies");
        assert_eq!(loaded.nodes[0].icon, Some("📽️".to_string()));
        assert_eq!(loaded.nodes[0].color, Some("#ff0000".to_string()));
    }

    #[test]
    fn test_delete_node() {
        let (conn, user_id) = temp_db();
        let mut tree = FileTree::load(&conn, &user_id).unwrap();

        let folder = FileTree::new_folder("Temp", None);
        let node_id = folder.node_id.clone();
        tree.insert_node(&conn, &folder).unwrap();

        tree.delete_node(&conn, &node_id).unwrap();

        let loaded = FileTree::load(&conn, &user_id).unwrap();
        assert_eq!(loaded.nodes.len(), 0);
    }

    #[test]
    fn test_move_node() {
        let (conn, user_id) = temp_db();
        let mut tree = FileTree::load(&conn, &user_id).unwrap();

        let root = FileTree::new_folder("Root", None);
        let child = FileTree::new_folder("Child", Some(root.node_id.clone()));

        tree.insert_node(&conn, &root).unwrap();
        tree.insert_node(&conn, &child).unwrap();

        tree.move_node(&conn, &child.node_id, None).unwrap();

        let loaded = FileTree::load(&conn, &user_id).unwrap();
        let moved = loaded.nodes.iter().find(|n| n.label == "Child").unwrap();
        assert!(moved.parent_id.is_none());
    }

    #[test]
    fn test_update_alias() {
        let (conn, user_id) = temp_db();
        let mut tree = FileTree::load(&conn, &user_id).unwrap();

        let folder = FileTree::new_folder("Videos", None);
        tree.insert_node(&conn, &folder).unwrap();

        tree.update_node_alias(&conn, &folder.node_id, "zh_tw", "影片")
            .unwrap();

        let loaded = FileTree::load(&conn, &user_id).unwrap();
        assert_eq!(
            loaded.nodes[0].aliases.get("zh_tw").map(|s| s.as_str()),
            Some("影片")
        );
    }

    #[test]
    fn test_build_tree() {
        let (conn, user_id) = temp_db();
        let mut tree = FileTree::load(&conn, &user_id).unwrap();

        let root = FileTree::new_folder("Root", None);
        let child1 = FileTree::new_folder("Child1", Some(root.node_id.clone()));
        let child2 = FileTree::new_folder("Child2", Some(root.node_id.clone()));
        let grandchild = FileTree::new_folder("Grandchild", Some(child1.node_id.clone()));

        // Set parent-child relationships
        let mut root_with_children = root.clone();
        root_with_children.children = vec![child1.node_id.clone(), child2.node_id.clone()];
        let mut child1_with_children = child1.clone();
        child1_with_children.children = vec![grandchild.node_id.clone()];

        tree.insert_node(&conn, &root_with_children).unwrap();
        tree.insert_node(&conn, &child1_with_children).unwrap();
        tree.insert_node(&conn, &child2).unwrap();
        tree.insert_node(&conn, &grandchild).unwrap();

        let roots = tree.build_tree();
        assert_eq!(roots.len(), 1);
        assert_eq!(roots[0].label, "Root");
    }
}