use directories::ProjectDirs;
use std::path::PathBuf;
use anyhow::Result;
use thiserror::Error;
use kordophone_db::{
    database::Database,
    models::Conversation,
};

use kordophone::api::http_client::HTTPAPIClient;

#[derive(Debug, Error)]
pub enum DaemonError {
    #[error("Client Not Configured")]
    ClientNotConfigured,
}

pub struct Daemon {
    pub version: String,
    database: Database,
    client: Option<HTTPAPIClient>,
}

impl Daemon {
    pub fn new() -> Result<Self> {
        let database_path = Self::get_database_path();
        log::info!("Database path: {}", database_path.display());

        // Create the database directory if it doesn't exist
        let database_dir = database_path.parent().unwrap();
        std::fs::create_dir_all(database_dir)?;

        let database = Database::new(&database_path.to_string_lossy())?;

        // TODO: Check to see if we have client settings in the database 


        Ok(Self { version: "0.1.0".to_string(), database, client: None })
    }

    pub fn get_conversations(&mut self) -> Vec<Conversation> {
        self.database.with_repository(|r| r.all_conversations().unwrap())
    }

    pub fn sync_all_conversations(&mut self) -> Result<()> {
        let client = self.client
            .as_mut()
            .ok_or(DaemonError::ClientNotConfigured)?;

        Ok(())
    }

    fn get_database_path() -> PathBuf {
        if let Some(proj_dirs) = ProjectDirs::from("com", "kordophone", "kordophone") {
            let data_dir = proj_dirs.data_dir();
            data_dir.join("database.db")
        } else {
            // Fallback to a local path if we can't get the system directories
            PathBuf::from("database.db")
        }
    }
}