use serde::{Deserialize, Serialize};


#[derive(Serialize, Deserialize, Debug, Clone, Default)]
pub struct ChatMessage {
    /// message text, `{item}` can be used to refer to items and such, where item is of the path such as `items/sword` or `spells/fireball`
    pub text: String,
    /// Source user initiated the action/sent the message
    #[serde(default = "default_source")]
    pub source: String,
    /// Character "sending" the message
    pub character: Option<String>,
    /// whisper item
    pub whisper: Option<String>,
    /// Rolls of the action, if not empty a roll should happen before
    pub roll: Option<Vec<RollDialogOption>>,
    /// Optional roll target
    pub roll_target: Option<i32>,
    /// Optional action buttons, for a chat message this will be empty
    pub actions: Option<Vec<String>>,
    /// Targets of the action, for a chat message this will be empty
    pub targets: Option<Vec<String>>,
    /// message id, should be left emitted or 0 for new messages
    #[serde(default = "default_id")]
    pub id: usize,
}
fn default_source() -> String {
    String::new()
}

impl ChatMessage {
    /// Creates a new chat message with a given text and source
    pub fn new(text: String) -> Self {
        Self {
            text, ..Default::default()
        }
    }
    pub fn source(mut self, source: String) -> Self {
        self.source = source;
        self
    }
    /// sets the whisper value of the message
    pub fn whisper(mut self, whisper: Option<String>) -> Self {
        self.whisper = whisper;
        self
    }
    /// sets the roll value for the message (chaining multiple will override each other) 
    pub fn roll(mut self, roll: Option<Vec<RollDialogOption>>) -> Self {
        self.roll = roll;
        self
    }
    /// adds a single roll to the message (chaining multiple will add multiple rolls)
    pub fn with_roll(mut self, roll: RollDialogOption) -> Self {
        if let Some(rs) = &mut self.roll {
            rs.push(roll);
        }
        else {
            self.roll = Some(vec![roll]);
        }
        self
    }
    pub fn roll_target(mut self, target: Option<i32>) -> Self {
        self.roll_target = target;
        self
    }
    /// sets the actions value (chaining multiple will override)
    pub fn actions(mut self, actions: Option<Vec<String>>) -> Self {
        self.actions = actions;
        self
    }
    /// adds a single action to the message (chaining  multiple will add multiple actions)
    pub fn with_action(mut self, action: String) -> Self {
        if let Some(acts) = &mut self.actions {
            acts.push(action);
        }
        else {
            self.actions = Some(vec![action]);
        }
        self
    }
    /// sets the targets value (chaining multiple will override)
    pub fn targets(mut self, targets: Option<Vec<String>>) -> Self {
        self.targets = targets;
        self
    }
    /// adds a single target to the message (chaining  multiple will add multiple targets)
    pub fn with_target(mut self, target: String) -> Self {
        if let Some(targets) = &mut self.targets {
            targets.push(target);
        }
        else {
            self.targets = Some(vec![target]);
        }
        self
    }
    /// Sets the message id
    /// 
    /// WARNING: duplicate message id will cause an overwrite of the original message (and an edit at the client)
    pub fn id(mut self, id: usize) -> Self {
        self.id = id;
        self
    }
    
}

fn default_id() -> usize { 0 }

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct RollDialogOption {
    /// Field name
    pub name: String,
    /// dice size (aka d6, d12, d20)
    pub dice_type: u16,
    /// amount of dice (aka 1d6, 2d12, 10d20)
    pub dice_amount: u16,
    /// Constant amout to add (+7, +3, -1)
    pub constant: i16,
    /// Extra data, like damage type
    pub extra: String,
    /// should be enabled by default
    pub enabled: bool
}