use chrono::{DateTime, NaiveDateTime};
use std::collections::HashMap;
use uuid::Uuid;
use crate::models::participant::Participant;
use kordophone::model::outgoing_message::OutgoingMessage;
use kordophone::model::message::AttachmentMetadata;

#[derive(Clone, Debug)] 
pub struct Message {
    pub id: String,
    pub sender: Participant,
    pub text: String,
    pub date: NaiveDateTime,
    pub file_transfer_guids: Vec<String>,
    pub attachment_metadata: Option<HashMap<String, AttachmentMetadata>>,
}

impl Message {
    pub fn builder() -> MessageBuilder {
        MessageBuilder::new()
    }
}

impl From<kordophone::model::Message> for Message {
    fn from(value: kordophone::model::Message) -> Self {
        Self {
            id: value.guid,
            sender: match value.sender {
                Some(sender) => Participant::Remote {
                    id: None,
                    display_name: sender,
                },
                None => Participant::Me,
            },
            text: value.text,
            date: DateTime::from_timestamp(
                value.date.unix_timestamp(),
                value.date.unix_timestamp_nanos()
                    .try_into()
                    .unwrap_or(0),
                )
                .unwrap()
                .naive_local(),
            file_transfer_guids: value.file_transfer_guids,
            attachment_metadata: value.attachment_metadata,
        }
    }
}

impl From<&OutgoingMessage> for Message {
    fn from(value: &OutgoingMessage) -> Self {
        Self {
            id: value.guid.to_string(),
            sender: Participant::Me,
            text: value.text.clone(),
            date: value.date,
            file_transfer_guids: Vec::new(), // Outgoing messages don't have file transfer GUIDs initially
            attachment_metadata: None, // Outgoing messages don't have attachment metadata initially
        }
    }
}

pub struct MessageBuilder {
    id: Option<String>,
    sender: Option<Participant>,
    text: Option<String>,
    date: Option<NaiveDateTime>,
    file_transfer_guids: Option<Vec<String>>,
    attachment_metadata: Option<HashMap<String, AttachmentMetadata>>,
}

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

impl MessageBuilder {
    pub fn new() -> Self {
        Self {
            id: None,
            sender: None,
            text: None,
            date: None,
            file_transfer_guids: None,
            attachment_metadata: None,
        }
    }

    pub fn sender(mut self, sender: Participant) -> Self {
        self.sender = Some(sender);
        self
    }

    pub fn text(mut self, text: String) -> Self {
        self.text = Some(text);
        self
    }

    pub fn date(mut self, date: NaiveDateTime) -> Self {
        self.date = Some(date);
        self
    }

    pub fn file_transfer_guids(mut self, file_transfer_guids: Vec<String>) -> Self {
        self.file_transfer_guids = Some(file_transfer_guids);
        self
    }

    pub fn attachment_metadata(mut self, attachment_metadata: HashMap<String, AttachmentMetadata>) -> Self {
        self.attachment_metadata = Some(attachment_metadata);
        self
    }

    pub fn build(self) -> Message {
        Message {
            id: self.id.unwrap_or_else(|| Uuid::new_v4().to_string()),
            sender: self.sender.unwrap_or(Participant::Me),
            text: self.text.unwrap_or_default(),
            date: self.date.unwrap_or_else(|| chrono::Utc::now().naive_utc()),
            file_transfer_guids: self.file_transfer_guids.unwrap_or_default(),
            attachment_metadata: self.attachment_metadata,
        }
    }
}