pub mod settings;
use settings::Settings;

pub mod events;
use events::*;

use anyhow::Result;
use directories::ProjectDirs;
use std::error::Error;
use std::path::PathBuf;
use thiserror::Error;
use tokio::sync::mpsc::{Sender, Receiver};

use kordophone_db::{
    database::Database,
    models::Conversation,
    repository::Repository,
};

use kordophone::model::JwtToken;
use kordophone::api::{
    http_client::{Credentials, HTTPAPIClient}, 
    APIInterface, 
    TokenManagement, 
};

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

pub type DaemonResult<T> = Result<T, Box<dyn Error + Send + Sync>>;

pub struct Daemon {
    pub event_sender: Sender<Event>,
    event_receiver: Receiver<Event>,
    version: String,
    database: Database,
    runtime: tokio::runtime::Runtime,
}

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)?;

        // Create event channels
        let (event_sender, event_receiver) = tokio::sync::mpsc::channel(100);

        // Create background task runtime 
        let runtime = tokio::runtime::Builder::new_multi_thread()
            .enable_all()
            .build()
            .unwrap();

        let database = Database::new(&database_path.to_string_lossy())?;
        Ok(Self { version: "0.1.0".to_string(), database, event_receiver, event_sender, runtime })
    }

    pub async fn run(&mut self) {
        while let Some(event) = self.event_receiver.recv().await {
            self.handle_event(event).await;
        }
    }

    async fn handle_event(&mut self, event: Event) {
        match event {
            Event::GetVersion(reply) => {
                reply.send(self.version.clone()).unwrap();
            },

            Event::SyncAllConversations(reply) => {
                self.sync_all_conversations().await.unwrap_or_else(|e| {
                    log::error!("Error handling sync event: {}", e);
                });

                reply.send(()).unwrap();
            }, 

            Event::GetAllConversations(reply) => {
                let conversations = self.get_conversations();
                reply.send(conversations).unwrap();
            },
        }
    }

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

    async fn sync_all_conversations(&mut self) -> Result<()> {
        tokio::time::sleep(tokio::time::Duration::from_secs(10)).await;

        let mut client = self.get_client()
            .map_err(|_| DaemonError::ClientNotConfigured)?;

        let fetched_conversations = client.get_conversations().await?;
        let db_conversations: Vec<kordophone_db::models::Conversation> = fetched_conversations.into_iter()
            .map(|c| kordophone_db::models::Conversation::from(c))
            .collect();

        // Process each conversation
        let mut repository = Repository::new(&mut self.database.connection);
        for conversation in db_conversations {
            let conversation_id = conversation.guid.clone();
            
            // Insert the conversation
            repository.insert_conversation(conversation)?;

            // Fetch and sync messages for this conversation
            let messages = client.get_messages(&conversation_id).await?;
            let db_messages: Vec<kordophone_db::models::Message> = messages.into_iter()
                .map(|m| kordophone_db::models::Message::from(m))
                .collect();

            // Insert each message
            for message in db_messages {
                repository.insert_message(&conversation_id, message)?;
            }
        }

        Ok(())
    }

    fn get_settings(&mut self) -> Result<Settings> {
        let settings = self.database.with_settings(|s| 
            Settings::from_db(s)
        )?;

        Ok(settings)
    }

    fn get_client(&mut self) -> Result<HTTPAPIClient> {
        let settings = self.database.with_settings(|s| 
            Settings::from_db(s)
        )?;

        let server_url = settings.server_url
            .ok_or(DaemonError::ClientNotConfigured)?;

        let client = HTTPAPIClient::new(
            server_url.parse().unwrap(),

            match (settings.username, settings.credential_item) {
                (Some(username), Some(password)) => Some(
                    Credentials {
                        username,
                        password,
                    }
                ),
                _ => None,
            }
        );

        Ok(client)
    }

    fn get_database_path() -> PathBuf {
        if let Some(proj_dirs) = ProjectDirs::from("net", "buzzert", "kordophonecd") {
            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")
        }
    }
}

impl TokenManagement for &mut Daemon {
    fn get_token(&mut self) -> Option<JwtToken> {
        self.database.get_token()
    }

    fn set_token(&mut self, token: JwtToken) {
        self.database.set_token(token);
    }
}