use std::collections::HashSet;
use std::path::PathBuf;

use async_trait::async_trait;
use bson::{doc, oid::ObjectId, Document};
use tracing::debug;

use crate::adapter::StorageAdapter;
use crate::error::{StorageError, StorageResult};

/// File-based storage adapter. Each collection is stored as a JSON file:
///   `{base_path}/{db}/{coll}.json`
/// Index metadata lives alongside:
///   `{base_path}/{db}/{coll}.indexes.json`
pub struct FileStorageAdapter {
    base_path: PathBuf,
}

impl FileStorageAdapter {
    pub fn new(base_path: impl Into<PathBuf>) -> Self {
        Self {
            base_path: base_path.into(),
        }
    }

    fn db_dir(&self, db: &str) -> PathBuf {
        self.base_path.join(db)
    }

    fn coll_path(&self, db: &str, coll: &str) -> PathBuf {
        self.db_dir(db).join(format!("{coll}.json"))
    }

    fn index_path(&self, db: &str, coll: &str) -> PathBuf {
        self.db_dir(db).join(format!("{coll}.indexes.json"))
    }

    /// Read all documents from a collection file. Returns empty vec if file doesn't exist.
    async fn read_docs(&self, db: &str, coll: &str) -> StorageResult<Vec<Document>> {
        let path = self.coll_path(db, coll);
        if !path.exists() {
            return Err(StorageError::NotFound(format!(
                "collection '{db}.{coll}'"
            )));
        }
        let data = tokio::fs::read_to_string(&path).await?;
        let json_docs: Vec<serde_json::Value> = serde_json::from_str(&data)?;
        let mut docs = Vec::with_capacity(json_docs.len());
        for jv in json_docs {
            let bson_val: bson::Bson = serde_json::from_value(jv)
                .map_err(|e| StorageError::SerializationError(e.to_string()))?;
            let doc = bson_val
                .as_document()
                .ok_or_else(|| StorageError::SerializationError("expected document".into()))?
                .clone();
            docs.push(doc);
        }
        Ok(docs)
    }

    /// Write all documents to a collection file.
    async fn write_docs(&self, db: &str, coll: &str, docs: &[Document]) -> StorageResult<()> {
        let path = self.coll_path(db, coll);
        if let Some(parent) = path.parent() {
            tokio::fs::create_dir_all(parent).await?;
        }
        let json_vals: Vec<serde_json::Value> = docs
            .iter()
            .map(|d| {
                let b = bson::to_bson(d)
                    .map_err(|e| StorageError::SerializationError(e.to_string()))?;
                serde_json::to_value(&b)
                    .map_err(|e| StorageError::SerializationError(e.to_string()))
            })
            .collect::<StorageResult<Vec<_>>>()?;
        let json = serde_json::to_string_pretty(&json_vals)?;
        tokio::fs::write(&path, json).await?;
        Ok(())
    }

    /// Read index specs from the indexes file.
    async fn read_indexes(&self, db: &str, coll: &str) -> StorageResult<Vec<Document>> {
        let path = self.index_path(db, coll);
        if !path.exists() {
            return Ok(vec![]);
        }
        let data = tokio::fs::read_to_string(&path).await?;
        let json_vals: Vec<serde_json::Value> = serde_json::from_str(&data)?;
        let mut docs = Vec::new();
        for jv in json_vals {
            let bson_val: bson::Bson = serde_json::from_value(jv)
                .map_err(|e| StorageError::SerializationError(e.to_string()))?;
            let doc = bson_val
                .as_document()
                .ok_or_else(|| StorageError::SerializationError("expected document".into()))?
                .clone();
            docs.push(doc);
        }
        Ok(docs)
    }

    /// Write index specs to the indexes file.
    async fn write_indexes(&self, db: &str, coll: &str, specs: &[Document]) -> StorageResult<()> {
        let path = self.index_path(db, coll);
        if let Some(parent) = path.parent() {
            tokio::fs::create_dir_all(parent).await?;
        }
        let json_vals: Vec<serde_json::Value> = specs
            .iter()
            .map(|d| {
                let b = bson::to_bson(d)
                    .map_err(|e| StorageError::SerializationError(e.to_string()))?;
                serde_json::to_value(&b)
                    .map_err(|e| StorageError::SerializationError(e.to_string()))
            })
            .collect::<StorageResult<Vec<_>>>()?;
        let json = serde_json::to_string_pretty(&json_vals)?;
        tokio::fs::write(&path, json).await?;
        Ok(())
    }

    fn extract_id_hex(doc: &Document) -> StorageResult<String> {
        match doc.get("_id") {
            Some(bson::Bson::ObjectId(oid)) => Ok(oid.to_hex()),
            _ => Err(StorageError::NotFound("document missing _id".into())),
        }
    }
}

#[async_trait]
impl StorageAdapter for FileStorageAdapter {
    async fn initialize(&self) -> StorageResult<()> {
        tokio::fs::create_dir_all(&self.base_path).await?;
        debug!("FileStorageAdapter initialized at {:?}", self.base_path);
        Ok(())
    }

    async fn close(&self) -> StorageResult<()> {
        debug!("FileStorageAdapter closed");
        Ok(())
    }

    // ---- database ----

    async fn list_databases(&self) -> StorageResult<Vec<String>> {
        let mut dbs = Vec::new();
        let mut entries = tokio::fs::read_dir(&self.base_path).await?;
        while let Some(entry) = entries.next_entry().await? {
            if entry.file_type().await?.is_dir() {
                if let Some(name) = entry.file_name().to_str() {
                    dbs.push(name.to_string());
                }
            }
        }
        Ok(dbs)
    }

    async fn create_database(&self, db: &str) -> StorageResult<()> {
        let dir = self.db_dir(db);
        if dir.exists() {
            return Err(StorageError::AlreadyExists(format!("database '{db}'")));
        }
        tokio::fs::create_dir_all(&dir).await?;
        Ok(())
    }

    async fn drop_database(&self, db: &str) -> StorageResult<()> {
        let dir = self.db_dir(db);
        if dir.exists() {
            tokio::fs::remove_dir_all(&dir).await?;
        }
        Ok(())
    }

    async fn database_exists(&self, db: &str) -> StorageResult<bool> {
        Ok(self.db_dir(db).exists())
    }

    // ---- collection ----

    async fn list_collections(&self, db: &str) -> StorageResult<Vec<String>> {
        let dir = self.db_dir(db);
        if !dir.exists() {
            return Err(StorageError::NotFound(format!("database '{db}'")));
        }
        let mut colls = Vec::new();
        let mut entries = tokio::fs::read_dir(&dir).await?;
        while let Some(entry) = entries.next_entry().await? {
            if let Some(name) = entry.file_name().to_str() {
                if name.ends_with(".json") && !name.ends_with(".indexes.json") {
                    colls.push(name.trim_end_matches(".json").to_string());
                }
            }
        }
        Ok(colls)
    }

    async fn create_collection(&self, db: &str, coll: &str) -> StorageResult<()> {
        let path = self.coll_path(db, coll);
        if path.exists() {
            return Err(StorageError::AlreadyExists(format!(
                "collection '{db}.{coll}'"
            )));
        }
        // Ensure db dir exists.
        tokio::fs::create_dir_all(self.db_dir(db)).await?;
        // Write empty array.
        self.write_docs(db, coll, &[]).await?;
        // Write default _id index.
        let idx_spec = doc! { "name": "_id_", "key": { "_id": 1 } };
        self.write_indexes(db, coll, &[idx_spec]).await?;
        Ok(())
    }

    async fn drop_collection(&self, db: &str, coll: &str) -> StorageResult<()> {
        let path = self.coll_path(db, coll);
        if path.exists() {
            tokio::fs::remove_file(&path).await?;
        }
        let idx_path = self.index_path(db, coll);
        if idx_path.exists() {
            tokio::fs::remove_file(&idx_path).await?;
        }
        Ok(())
    }

    async fn collection_exists(&self, db: &str, coll: &str) -> StorageResult<bool> {
        Ok(self.coll_path(db, coll).exists())
    }

    async fn rename_collection(
        &self,
        db: &str,
        old_name: &str,
        new_name: &str,
    ) -> StorageResult<()> {
        let old_path = self.coll_path(db, old_name);
        let new_path = self.coll_path(db, new_name);
        if !old_path.exists() {
            return Err(StorageError::NotFound(format!(
                "collection '{db}.{old_name}'"
            )));
        }
        if new_path.exists() {
            return Err(StorageError::AlreadyExists(format!(
                "collection '{db}.{new_name}'"
            )));
        }
        tokio::fs::rename(&old_path, &new_path).await?;

        // Rename index file too.
        let old_idx = self.index_path(db, old_name);
        let new_idx = self.index_path(db, new_name);
        if old_idx.exists() {
            tokio::fs::rename(&old_idx, &new_idx).await?;
        }
        Ok(())
    }

    // ---- document writes ----

    async fn insert_one(
        &self,
        db: &str,
        coll: &str,
        mut doc: Document,
    ) -> StorageResult<String> {
        if !doc.contains_key("_id") {
            doc.insert("_id", ObjectId::new());
        }
        let id = Self::extract_id_hex(&doc)?;

        let mut docs = self.read_docs(db, coll).await?;
        // Check for duplicate.
        for existing in &docs {
            if Self::extract_id_hex(existing)? == id {
                return Err(StorageError::AlreadyExists(format!("document '{id}'")));
            }
        }
        docs.push(doc);
        self.write_docs(db, coll, &docs).await?;
        Ok(id)
    }

    async fn insert_many(
        &self,
        db: &str,
        coll: &str,
        mut new_docs: Vec<Document>,
    ) -> StorageResult<Vec<String>> {
        let mut docs = self.read_docs(db, coll).await?;
        let mut ids = Vec::with_capacity(new_docs.len());

        for doc in &mut new_docs {
            if !doc.contains_key("_id") {
                doc.insert("_id", ObjectId::new());
            }
            ids.push(Self::extract_id_hex(doc)?);
        }

        docs.extend(new_docs);
        self.write_docs(db, coll, &docs).await?;
        Ok(ids)
    }

    async fn update_by_id(
        &self,
        db: &str,
        coll: &str,
        id: &str,
        doc: Document,
    ) -> StorageResult<()> {
        let mut docs = self.read_docs(db, coll).await?;
        let mut found = false;
        for existing in &mut docs {
            if Self::extract_id_hex(existing)? == id {
                *existing = doc.clone();
                found = true;
                break;
            }
        }
        if !found {
            return Err(StorageError::NotFound(format!("document '{id}'")));
        }
        self.write_docs(db, coll, &docs).await?;
        Ok(())
    }

    async fn delete_by_id(
        &self,
        db: &str,
        coll: &str,
        id: &str,
    ) -> StorageResult<()> {
        let mut docs = self.read_docs(db, coll).await?;
        let len_before = docs.len();
        docs.retain(|d| Self::extract_id_hex(d).map(|i| i != id).unwrap_or(true));
        if docs.len() == len_before {
            return Err(StorageError::NotFound(format!("document '{id}'")));
        }
        self.write_docs(db, coll, &docs).await?;
        Ok(())
    }

    async fn delete_by_ids(
        &self,
        db: &str,
        coll: &str,
        ids: &[String],
    ) -> StorageResult<()> {
        let id_set: HashSet<&str> = ids.iter().map(|s| s.as_str()).collect();
        let mut docs = self.read_docs(db, coll).await?;
        docs.retain(|d| {
            Self::extract_id_hex(d)
                .map(|i| !id_set.contains(i.as_str()))
                .unwrap_or(true)
        });
        self.write_docs(db, coll, &docs).await?;
        Ok(())
    }

    // ---- document reads ----

    async fn find_all(
        &self,
        db: &str,
        coll: &str,
    ) -> StorageResult<Vec<Document>> {
        self.read_docs(db, coll).await
    }

    async fn find_by_ids(
        &self,
        db: &str,
        coll: &str,
        ids: HashSet<String>,
    ) -> StorageResult<Vec<Document>> {
        let docs = self.read_docs(db, coll).await?;
        Ok(docs
            .into_iter()
            .filter(|d| {
                Self::extract_id_hex(d)
                    .map(|i| ids.contains(&i))
                    .unwrap_or(false)
            })
            .collect())
    }

    async fn find_by_id(
        &self,
        db: &str,
        coll: &str,
        id: &str,
    ) -> StorageResult<Option<Document>> {
        let docs = self.read_docs(db, coll).await?;
        Ok(docs
            .into_iter()
            .find(|d| Self::extract_id_hex(d).map(|i| i == id).unwrap_or(false)))
    }

    async fn count(
        &self,
        db: &str,
        coll: &str,
    ) -> StorageResult<u64> {
        let docs = self.read_docs(db, coll).await?;
        Ok(docs.len() as u64)
    }

    // ---- indexes ----

    async fn save_index(
        &self,
        db: &str,
        coll: &str,
        name: &str,
        spec: Document,
    ) -> StorageResult<()> {
        let mut indexes = self.read_indexes(db, coll).await?;
        indexes.retain(|s| s.get_str("name").unwrap_or("") != name);
        let mut full_spec = spec;
        full_spec.insert("name", name);
        indexes.push(full_spec);
        self.write_indexes(db, coll, &indexes).await
    }

    async fn get_indexes(
        &self,
        db: &str,
        coll: &str,
    ) -> StorageResult<Vec<Document>> {
        self.read_indexes(db, coll).await
    }

    async fn drop_index(
        &self,
        db: &str,
        coll: &str,
        name: &str,
    ) -> StorageResult<()> {
        let mut indexes = self.read_indexes(db, coll).await?;
        let before = indexes.len();
        indexes.retain(|s| s.get_str("name").unwrap_or("") != name);
        if indexes.len() == before {
            return Err(StorageError::NotFound(format!("index '{name}'")));
        }
        self.write_indexes(db, coll, &indexes).await
    }

    // ---- snapshot / conflict detection ----
    // File adapter doesn't track per-document timestamps, so conflict detection
    // is a no-op (always returns false).

    async fn create_snapshot(
        &self,
        _db: &str,
        _coll: &str,
    ) -> StorageResult<i64> {
        use std::time::{SystemTime, UNIX_EPOCH};
        Ok(SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_millis() as i64)
    }

    async fn has_conflicts(
        &self,
        _db: &str,
        _coll: &str,
        _ids: &HashSet<String>,
        _snapshot_time: i64,
    ) -> StorageResult<bool> {
        // File adapter does not track modification timestamps per document.
        Ok(false)
    }
}