use chrono::{DateTime, NaiveDateTime};
use uuid::Uuid;
use crate::models::participant::Participant;

#[derive(Clone, Debug)] 
pub struct Message {
    pub id: String,
    pub sender: Participant,
    pub text: String,
    pub date: NaiveDateTime,
}

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()
        }
    }
}

pub struct MessageBuilder {
    id: Option<String>,
    sender: Option<Participant>,
    text: Option<String>,
    date: Option<NaiveDateTime>,
}

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

impl MessageBuilder {
    pub fn new() -> Self {
        Self {
            id: None,
            sender: None,
            text: None,
            date: 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 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()),
        }
    }
}