use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use tele_tui::tdlib::types::{FolderInfo, ReactionInfo};
use tele_tui::tdlib::{AuthState, ChatInfo, MessageInfo, NetworkState, ProfileInfo, ReplyInfo};
use tele_tui::types::{ChatId, MessageId, UserId};
use tokio::sync::mpsc;

pub type ViewedMessages = Vec<(i64, Vec<i64>)>;
pub type PendingViewMessages = Vec<(ChatId, Vec<MessageId>)>;

/// Update events from TDLib, simplified for tests.
#[derive(Debug, Clone)]
#[allow(dead_code)]
pub enum TdUpdate {
    NewMessage {
        chat_id: ChatId,
        message: Box<MessageInfo>,
    },
    MessageContent {
        chat_id: ChatId,
        message_id: MessageId,
        new_text: String,
    },
    DeleteMessages {
        chat_id: ChatId,
        message_ids: Vec<MessageId>,
    },
    ChatAction {
        chat_id: ChatId,
        user_id: UserId,
        action: String,
    },
    MessageInteractionInfo {
        chat_id: ChatId,
        message_id: MessageId,
        reactions: Vec<ReactionInfo>,
    },
    ConnectionState {
        state: NetworkState,
    },
    ChatReadOutbox {
        chat_id: ChatId,
        last_read_outbox_message_id: MessageId,
    },
    ChatDraftMessage {
        chat_id: ChatId,
        draft_text: Option<String>,
    },
}

/// Simplified mock TDLib client for tests.
#[allow(dead_code)]
pub struct FakeTdClient {
    pub chats: Arc<Mutex<Vec<ChatInfo>>>,
    pub messages: Arc<Mutex<HashMap<i64, Vec<MessageInfo>>>>,
    pub folders: Arc<Mutex<Vec<FolderInfo>>>,
    pub user_names: Arc<Mutex<HashMap<i64, String>>>,
    pub profiles: Arc<Mutex<HashMap<i64, ProfileInfo>>>,
    pub drafts: Arc<Mutex<HashMap<i64, String>>>,
    pub available_reactions: Arc<Mutex<Vec<String>>>,

    pub network_state: Arc<Mutex<NetworkState>>,
    pub typing_chat_id: Arc<Mutex<Option<i64>>>,
    pub current_chat_id: Arc<Mutex<Option<i64>>>,
    pub current_pinned_message: Arc<Mutex<Option<MessageInfo>>>,
    pub auth_state: Arc<Mutex<AuthState>>,

    pub sent_messages: Arc<Mutex<Vec<SentMessage>>>,
    pub edited_messages: Arc<Mutex<Vec<EditedMessage>>>,
    pub deleted_messages: Arc<Mutex<Vec<DeletedMessages>>>,
    pub forwarded_messages: Arc<Mutex<Vec<ForwardedMessages>>>,
    pub searched_queries: Arc<Mutex<Vec<SearchQuery>>>,
    pub viewed_messages: Arc<Mutex<ViewedMessages>>,
    pub chat_actions: Arc<Mutex<Vec<(i64, String)>>>,
    pub pending_view_messages: Arc<Mutex<PendingViewMessages>>,

    pub update_tx: Arc<Mutex<Option<mpsc::UnboundedSender<TdUpdate>>>>,
    pub downloaded_files: Arc<Mutex<HashMap<i32, String>>>,

    pub simulate_delays: bool,
    pub fail_next_operation: Arc<Mutex<bool>>,
}

#[derive(Debug, Clone)]
#[allow(dead_code)]
pub struct SentMessage {
    pub chat_id: i64,
    pub text: String,
    pub reply_to: Option<MessageId>,
    pub reply_info: Option<ReplyInfo>,
}

#[derive(Debug, Clone)]
#[allow(dead_code)]
pub struct EditedMessage {
    pub chat_id: i64,
    pub message_id: MessageId,
    pub new_text: String,
}

#[derive(Debug, Clone)]
#[allow(dead_code)]
pub struct DeletedMessages {
    pub chat_id: i64,
    pub message_ids: Vec<MessageId>,
    pub revoke: bool,
}

#[derive(Debug, Clone)]
#[allow(dead_code)]
pub struct ForwardedMessages {
    pub from_chat_id: i64,
    pub to_chat_id: i64,
    pub message_ids: Vec<MessageId>,
}

#[derive(Debug, Clone)]
#[allow(dead_code)]
pub struct SearchQuery {
    pub chat_id: i64,
    pub query: String,
    pub results_count: usize,
}

impl Default for FakeTdClient {
    fn default() -> Self {
        Self::new()
    }
}

impl Clone for FakeTdClient {
    fn clone(&self) -> Self {
        Self {
            chats: Arc::clone(&self.chats),
            messages: Arc::clone(&self.messages),
            folders: Arc::clone(&self.folders),
            user_names: Arc::clone(&self.user_names),
            profiles: Arc::clone(&self.profiles),
            drafts: Arc::clone(&self.drafts),
            available_reactions: Arc::clone(&self.available_reactions),
            network_state: Arc::clone(&self.network_state),
            typing_chat_id: Arc::clone(&self.typing_chat_id),
            current_chat_id: Arc::clone(&self.current_chat_id),
            current_pinned_message: Arc::clone(&self.current_pinned_message),
            auth_state: Arc::clone(&self.auth_state),
            sent_messages: Arc::clone(&self.sent_messages),
            edited_messages: Arc::clone(&self.edited_messages),
            deleted_messages: Arc::clone(&self.deleted_messages),
            forwarded_messages: Arc::clone(&self.forwarded_messages),
            searched_queries: Arc::clone(&self.searched_queries),
            viewed_messages: Arc::clone(&self.viewed_messages),
            chat_actions: Arc::clone(&self.chat_actions),
            pending_view_messages: Arc::clone(&self.pending_view_messages),
            downloaded_files: Arc::clone(&self.downloaded_files),
            update_tx: Arc::clone(&self.update_tx),
            simulate_delays: self.simulate_delays,
            fail_next_operation: Arc::clone(&self.fail_next_operation),
        }
    }
}

#[allow(dead_code)]
impl FakeTdClient {
    pub fn new() -> Self {
        Self {
            chats: Arc::new(Mutex::new(vec![])),
            messages: Arc::new(Mutex::new(HashMap::new())),
            folders: Arc::new(Mutex::new(vec![FolderInfo { id: 0, name: "All".to_string() }])),
            user_names: Arc::new(Mutex::new(HashMap::new())),
            profiles: Arc::new(Mutex::new(HashMap::new())),
            drafts: Arc::new(Mutex::new(HashMap::new())),
            available_reactions: Arc::new(Mutex::new(vec![
                "👍".to_string(),
                "❤️".to_string(),
                "😂".to_string(),
                "😮".to_string(),
                "😢".to_string(),
                "🙏".to_string(),
                "👏".to_string(),
                "🔥".to_string(),
            ])),
            network_state: Arc::new(Mutex::new(NetworkState::Ready)),
            typing_chat_id: Arc::new(Mutex::new(None)),
            current_chat_id: Arc::new(Mutex::new(None)),
            current_pinned_message: Arc::new(Mutex::new(None)),
            auth_state: Arc::new(Mutex::new(AuthState::Ready)),
            sent_messages: Arc::new(Mutex::new(vec![])),
            edited_messages: Arc::new(Mutex::new(vec![])),
            deleted_messages: Arc::new(Mutex::new(vec![])),
            forwarded_messages: Arc::new(Mutex::new(vec![])),
            searched_queries: Arc::new(Mutex::new(vec![])),
            viewed_messages: Arc::new(Mutex::new(vec![])),
            chat_actions: Arc::new(Mutex::new(vec![])),
            pending_view_messages: Arc::new(Mutex::new(vec![])),
            downloaded_files: Arc::new(Mutex::new(HashMap::new())),
            update_tx: Arc::new(Mutex::new(None)),
            simulate_delays: false,
            fail_next_operation: Arc::new(Mutex::new(false)),
        }
    }
}