use crate::common::status::StatusInfo;
use crate::config::Settings;
use crate::db::Item;
use crate::db::Meta;
use crate::services::data_service::DataService;
use crate::services::error::CoreError;
use crate::services::types::{ItemWithContent, ItemWithMeta};
use clap::Command;
use rusqlite::Connection;
use std::collections::HashMap;
use std::io::Read;
use std::path::PathBuf;
use std::sync::Arc;
use tokio::sync::Mutex;

pub struct AsyncDataService {
    data_path: PathBuf,
    settings: Arc<Settings>,
    db: Arc<Mutex<Connection>>,
}

impl AsyncDataService {
    pub fn new(data_path: PathBuf, settings: Arc<Settings>, db: Arc<Mutex<Connection>>) -> Self {
        Self {
            data_path,
            settings,
            db,
        }
    }

    pub fn data_path(&self) -> &PathBuf {
        &self.data_path
    }

    pub fn settings(&self) -> Arc<Settings> {
        self.settings.clone()
    }

    pub fn db(&self) -> Arc<Mutex<Connection>> {
        self.db.clone()
    }
}

impl DataService for AsyncDataService {
    type Error = CoreError;

    fn save<R: Read>(
        &self,
        content: R,
        cmd: &mut Command,
        settings: &Settings,
        tags: Vec<String>,
        conn: &mut Connection,
    ) -> Result<Item, Self::Error> {
        let sync_service =
            crate::services::SyncDataService::new(self.data_path.clone(), settings.clone());
        sync_service.save(content, cmd, settings, tags, conn)
    }

    fn get(&self, conn: &mut Connection, id: i64) -> Result<ItemWithMeta, Self::Error> {
        let sync_service = crate::services::SyncDataService::new(
            self.data_path.clone(),
            self.settings.as_ref().clone(),
        );
        sync_service.get(conn, id)
    }

    fn get_content(
        &self,
        conn: &mut Connection,
        id: i64,
    ) -> Result<(Box<dyn Read + Send>, ItemWithMeta), Self::Error> {
        let sync_service = crate::services::SyncDataService::new(
            self.data_path.clone(),
            self.settings.as_ref().clone(),
        );
        sync_service.get_content(conn, id)
    }

    fn list(
        &self,
        conn: &mut Connection,
        tags: Vec<String>,
        meta: HashMap<String, String>,
    ) -> Result<Vec<ItemWithMeta>, Self::Error> {
        let sync_service = crate::services::SyncDataService::new(
            self.data_path.clone(),
            self.settings.as_ref().clone(),
        );
        sync_service.list(conn, tags, meta)
    }

    fn delete(&self, conn: &mut Connection, id: i64) -> Result<Item, Self::Error> {
        let sync_service = crate::services::SyncDataService::new(
            self.data_path.clone(),
            self.settings.as_ref().clone(),
        );
        sync_service.delete(conn, id)
    }

    fn find_item(
        &self,
        conn: &mut Connection,
        ids: Vec<i64>,
        tags: Vec<String>,
        meta: HashMap<String, String>,
    ) -> Result<ItemWithMeta, Self::Error> {
        let sync_service = crate::services::SyncDataService::new(
            self.data_path.clone(),
            self.settings.as_ref().clone(),
        );
        sync_service.find_item(conn, ids, tags, meta)
    }

    fn get_items(
        &self,
        conn: &mut Connection,
        ids: &[i64],
        tags: &[String],
        meta: &HashMap<String, String>,
    ) -> Result<Vec<ItemWithMeta>, Self::Error> {
        let sync_service = crate::services::SyncDataService::new(
            self.data_path.clone(),
            self.settings.as_ref().clone(),
        );
        sync_service.get_items(conn, ids, tags, meta)
    }

    fn generate_status(
        &self,
        _cmd: &Command,
        settings: &Settings,
        data_path: &PathBuf,
        db_path: &PathBuf,
    ) -> Result<StatusInfo, Self::Error> {
        let mut cmd_mut = Command::new("keep");
        let sync_service =
            crate::services::SyncDataService::new(self.data_path.clone(), settings.clone());
        Ok(
            sync_service.generate_status(
                &mut cmd_mut,
                settings,
                data_path.clone(),
                db_path.clone(),
            ),
        )
    }
}