//! `DirectBackend` library structure: VFS create/rename/delete, directory
//! listing (plain and analysis-enriched), tags, and collections.

use super::{
    BackendResult, Collection, CollectionBackend, CollectionId, DirectBackend, NodeId,
    SearchFilter, TagBackend, Vfs, VfsBackend, VfsId, VfsNode, VfsNodeWithAnalysis, collections,
    instrument, tags, vfs,
};

impl VfsBackend for DirectBackend {
    // --- VFS ---

    fn list_vfs(&self) -> BackendResult<Vec<Vfs>> {
        let db = self.db.lock();
        Ok(vfs::list_vfs(&db)?)
    }

    #[instrument(skip(self))]
    fn create_vfs(&self, name: &str) -> BackendResult<VfsId> {
        let db = self.db.lock();
        Ok(vfs::create_vfs(&db, name)?)
    }

    #[instrument(skip(self))]
    fn rename_vfs(&self, id: VfsId, new_name: &str) -> BackendResult<()> {
        let db = self.db.lock();
        Ok(vfs::rename_vfs(&db, id, new_name)?)
    }

    #[instrument(skip(self))]
    fn delete_vfs(&self, id: VfsId) -> BackendResult<()> {
        let db = self.db.lock();
        Ok(vfs::delete_vfs(&db, id)?)
    }

    fn list_children_enriched(
        &self,
        vfs_id: VfsId,
        parent_id: Option<NodeId>,
    ) -> BackendResult<Vec<VfsNodeWithAnalysis>> {
        let db = self.db.lock();
        Ok(vfs::list_children_enriched(&db, vfs_id, parent_id)?)
    }

    fn list_children(
        &self,
        vfs_id: VfsId,
        parent_id: Option<NodeId>,
    ) -> BackendResult<Vec<VfsNode>> {
        let db = self.db.lock();
        Ok(vfs::list_children(&db, vfs_id, parent_id)?)
    }

    #[instrument(skip(self))]
    fn create_directory(
        &self,
        vfs_id: VfsId,
        parent_id: Option<NodeId>,
        name: &str,
    ) -> BackendResult<NodeId> {
        let db = self.db.lock();
        Ok(vfs::create_directory(&db, vfs_id, parent_id, name)?)
    }

    #[instrument(skip(self))]
    fn create_sample_link(
        &self,
        vfs_id: VfsId,
        parent_id: Option<NodeId>,
        name: &str,
        sample_hash: &str,
    ) -> BackendResult<NodeId> {
        let db = self.db.lock();
        Ok(vfs::create_sample_link(
            &db,
            vfs_id,
            parent_id,
            name,
            sample_hash,
        )?)
    }

    fn get_node(&self, id: NodeId) -> BackendResult<VfsNode> {
        let db = self.db.lock();
        Ok(vfs::get_node(&db, id)?)
    }

    fn get_breadcrumb(&self, node_id: NodeId) -> BackendResult<Vec<VfsNode>> {
        let db = self.db.lock();
        Ok(vfs::get_breadcrumb(&db, node_id)?)
    }

    #[instrument(skip(self))]
    fn rename_node(&self, id: NodeId, new_name: &str) -> BackendResult<()> {
        let db = self.db.lock();
        Ok(vfs::rename_node(&db, id, new_name)?)
    }

    #[instrument(skip(self))]
    fn move_node(&self, id: NodeId, new_parent_id: Option<NodeId>) -> BackendResult<()> {
        let db = self.db.lock();
        Ok(vfs::move_node(&db, id, new_parent_id)?)
    }

    #[instrument(skip(self))]
    fn delete_node(&self, id: NodeId) -> BackendResult<()> {
        let db = self.db.lock();
        Ok(vfs::delete_node(&db, id)?)
    }

    #[instrument(skip_all)]
    fn restore_node(&self, node: &VfsNode) -> BackendResult<()> {
        let db = self.db.lock();
        Ok(vfs::restore_node(&db, node)?)
    }

    fn collect_subtree(&self, node_id: NodeId) -> BackendResult<Vec<VfsNode>> {
        let db = self.db.lock();
        Ok(vfs::collect_subtree(&db, node_id)?)
    }

    fn list_all_directories(&self, vfs_id: VfsId) -> BackendResult<Vec<(NodeId, String)>> {
        let db = self.db.lock();
        Ok(vfs::list_all_directories(&db, vfs_id)?)
    }

    fn find_nodes_by_hashes(
        &self,
        vfs_id: VfsId,
        hashes: &[&str],
    ) -> BackendResult<Vec<VfsNodeWithAnalysis>> {
        let db = self.db.lock();
        Ok(vfs::find_nodes_by_hashes(&db, vfs_id, hashes)?)
    }
}

impl TagBackend for DirectBackend {
    // --- Tags ---

    #[instrument(skip(self))]
    fn add_tag(&self, hash: &str, tag: &str) -> BackendResult<()> {
        let db = self.db.lock();
        Ok(tags::add_tag(&db, hash, tag)?)
    }

    #[instrument(skip(self))]
    fn remove_tag(&self, hash: &str, tag: &str) -> BackendResult<()> {
        let db = self.db.lock();
        Ok(tags::remove_tag(&db, hash, tag)?)
    }

    fn get_sample_tags(&self, hash: &str) -> BackendResult<Vec<String>> {
        let db = self.db.lock();
        Ok(tags::get_sample_tags(&db, hash)?)
    }

    fn list_all_tags(&self) -> BackendResult<Vec<String>> {
        let db = self.db.lock();
        Ok(tags::list_all_tags(&db)?)
    }

    #[instrument(skip(self, hashes))]
    fn bulk_add_tag(&self, hashes: &[&str], tag: &str) -> BackendResult<usize> {
        let db = self.db.lock();
        Ok(tags::bulk_add_tag(&db, hashes, tag)?)
    }

    #[instrument(skip(self, hashes))]
    fn bulk_remove_tag(&self, hashes: &[&str], tag: &str) -> BackendResult<usize> {
        let db = self.db.lock();
        Ok(tags::bulk_remove_tag(&db, hashes, tag)?)
    }

    fn rename_tag_globally(&self, old_tag: &str, new_tag: &str) -> BackendResult<usize> {
        let db = self.db.lock();
        Ok(tags::rename_tag_globally(&db, old_tag, new_tag)?)
    }

    fn count_samples_with_tag(&self, tag: &str) -> BackendResult<usize> {
        let db = self.db.lock();
        Ok(tags::find_by_tag(&db, tag)?.len())
    }

    fn remove_tag_globally(&self, tag: &str) -> BackendResult<usize> {
        let db = self.db.lock();
        Ok(tags::remove_tag_globally(&db, tag)?)
    }
}

impl CollectionBackend for DirectBackend {
    // --- Collections ---

    fn list_collections(&self) -> BackendResult<Vec<Collection>> {
        let db = self.db.lock();
        Ok(collections::list_collections(&db)?)
    }

    #[instrument(skip(self))]
    fn create_collection(
        &self,
        name: &str,
        description: Option<&str>,
    ) -> BackendResult<CollectionId> {
        let db = self.db.lock();
        Ok(collections::create_collection(&db, name, description)?)
    }

    fn create_dynamic_collection(
        &self,
        name: &str,
        filter: &SearchFilter,
    ) -> BackendResult<CollectionId> {
        let db = self.db.lock();
        Ok(collections::create_dynamic_collection(&db, name, filter)?)
    }

    fn rename_collection(&self, id: CollectionId, new_name: &str) -> BackendResult<()> {
        let db = self.db.lock();
        Ok(collections::rename_collection(&db, id, new_name)?)
    }

    #[instrument(skip(self))]
    fn delete_collection(&self, id: CollectionId) -> BackendResult<()> {
        let db = self.db.lock();
        Ok(collections::delete_collection(&db, id)?)
    }

    fn add_to_collection(
        &self,
        collection_id: CollectionId,
        sample_hash: &str,
    ) -> BackendResult<()> {
        let db = self.db.lock();
        Ok(collections::add_to_collection(
            &db,
            collection_id,
            sample_hash,
        )?)
    }

    fn remove_from_collection(
        &self,
        collection_id: CollectionId,
        sample_hash: &str,
    ) -> BackendResult<()> {
        let db = self.db.lock();
        Ok(collections::remove_from_collection(
            &db,
            collection_id,
            sample_hash,
        )?)
    }

    fn list_collection_members(&self, collection_id: CollectionId) -> BackendResult<Vec<String>> {
        let db = self.db.lock();
        Ok(collections::list_collection_members(&db, collection_id)?)
    }

    fn get_sample_collections(&self, sample_hash: &str) -> BackendResult<Vec<Collection>> {
        let db = self.db.lock();
        Ok(collections::get_sample_collections(&db, sample_hash)?)
    }
}