use lampada::error::WriteError;

use crate::{
    Command,
    error::{RosterError, StatusError},
};

use super::ClientLogic;

pub async fn handle_offline(logic: ClientLogic, command: Command) {
    match command {
        Command::GetRoster(sender) => {
            let roster = logic.db().read_cached_roster().await;
            match roster {
                Ok(roster) => {
                    let _ = sender.send(Ok(roster));
                }
                Err(e) => {
                    let _ = sender.send(Err(RosterError::Cache(e.into())));
                }
            }
        }
        Command::GetChats(sender) => {
            let chats = logic.db().read_chats().await.map_err(|e| e.into());
            sender.send(chats);
        }
        Command::GetChatsOrdered(sender) => {
            let chats = logic.db().read_chats_ordered().await.map_err(|e| e.into());
            sender.send(chats);
        }
        Command::GetChatsOrderedWithLatestMessages(sender) => {
            let chats = logic
                .db()
                .read_chats_ordered_with_latest_messages()
                .await
                .map_err(|e| e.into());
            sender.send(chats);
        }
        Command::GetChat(jid, sender) => {
            let chats = logic.db().read_chat(jid).await.map_err(|e| e.into());
            sender.send(chats);
        }
        Command::GetMessages(jid, sender) => {
            let messages = logic
                .db()
                .read_message_history(jid)
                .await
                .map_err(|e| e.into());
            sender.send(messages);
        }
        Command::DeleteChat(jid, sender) => {
            let result = logic.db().delete_chat(jid).await.map_err(|e| e.into());
            sender.send(result);
        }
        Command::DeleteMessage(uuid, sender) => {
            let result = logic.db().delete_message(uuid).await.map_err(|e| e.into());
            sender.send(result);
        }
        Command::GetUser(jid, sender) => {
            let user = logic.db().read_user(jid).await.map_err(|e| e.into());
            sender.send(user);
        }
        // TODO: offline queue to modify roster
        Command::AddContact(_jid, sender) => {
            sender.send(Err(RosterError::Write(WriteError::Disconnected)));
        }
        Command::BuddyRequest(_jid, sender) => {
            sender.send(Err(WriteError::Disconnected));
        }
        Command::SubscriptionRequest(_jid, sender) => {
            sender.send(Err(WriteError::Disconnected));
        }
        Command::AcceptBuddyRequest(_jid, sender) => {
            sender.send(Err(WriteError::Disconnected));
        }
        Command::AcceptSubscriptionRequest(_jid, sender) => {
            sender.send(Err(WriteError::Disconnected));
        }
        Command::UnsubscribeFromContact(_jid, sender) => {
            sender.send(Err(WriteError::Disconnected));
        }
        Command::UnsubscribeContact(_jid, sender) => {
            sender.send(Err(WriteError::Disconnected));
        }
        Command::UnfriendContact(_jid, sender) => {
            sender.send(Err(WriteError::Disconnected));
        }
        Command::DeleteContact(_jid, sender) => {
            sender.send(Err(RosterError::Write(WriteError::Disconnected)));
        }
        Command::UpdateContact(_jid, _contact_update, sender) => {
            sender.send(Err(RosterError::Write(WriteError::Disconnected)));
        }
        Command::SetStatus(online, sender) => {
            let result = logic
                .db()
                .upsert_cached_status(online)
                .await
                .map_err(|e| StatusError::Cache(e.into()));
            sender.send(result);
        }
        // TODO: offline message queue
        Command::SendMessage(_jid, _body, sender) => {
            sender.send(Err(WriteError::Disconnected));
        }
        Command::SendPresence(_jid, _presence, sender) => {
            sender.send(Err(WriteError::Disconnected));
        }
    }
}