use serde::{Deserialize, Serialize};

use crate::types::{ElementContent, ElementId, Family, MessageId, PotId};

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Message {
    id: MessageId,
    signature: MessageSignature,
    content: MessageContent,
}

#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct MessageRelations {
    pub parents: Vec<MessageId>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum MessageContent {
    Hello {
        peer_name: String,
    },
    JoinFamily,
    AddedToFamily {
        family: Family,
    },
    LeaveFamily,
    CreateElement {
        id: ElementId,
        content: ElementContent,
        pot: PotId,
    },
    UpdateElement {
        id: ElementId,
        content: ElementContent,
    },
    RemoveElement {
        id: ElementId,
    },
    AddPot {
        id: PotId,
        app_type: String,
    },
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct MessageSignature {}

impl Message {
    pub fn new(content: MessageContent) -> Self {
        Message {
            id: MessageId::new(),
            signature: MessageSignature {},
            content: content,
        }
    }

    pub fn content(&self) -> &MessageContent {
        &self.content
    }

    pub fn id(&self) -> &MessageId {
        &self.id
    }
}

impl MessageSignature {
    pub fn verify(&self, _content: &MessageContent) -> bool {
        true
    }
}