use chrono::{DateTime, Utc};
use itertools::Itertools;
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
pub enum ConsentType {
    Fight,
    Medicine,
    Gifts,
    Visit,
    Share,
}

impl ConsentType {
    pub fn from_str(inp: &str) -> Option<ConsentType> {
        use ConsentType::*;
        match inp {
            "fight" => Some(Fight),
            "medicine" => Some(Medicine),
            "gifts" => Some(Gifts),
            "visit" => Some(Visit),
            "share" => Some(Share),
            _ => None,
        }
    }

    pub fn to_str(&self) -> &'static str {
        use ConsentType::*;
        match self {
            Fight => "fight",
            Medicine => "medicine",
            Gifts => "gifts",
            Visit => "visit",
            Share => "share",
        }
    }
}

#[derive(Serialize, Deserialize, PartialEq, Clone, Debug)]
pub enum ConsentStatus {
    PendingAdd,    // Added but awaiting other party to ratify by giving matching consent.
    Active,        // Consent in force, no delete pending.
    PendingDelete, // Pending cancellation but other party has to also disallow to ratify.
}

#[derive(Serialize, Deserialize, PartialEq, Clone, Debug)]
pub struct FightConsent {
    pub status: ConsentStatus,
    pub pending_change: Option<Box<Consent>>,
    pub allow_pick: bool,
    pub freely_revoke: bool,
}

impl Default for FightConsent {
    fn default() -> Self {
        Self {
            status: ConsentStatus::PendingAdd,
            pending_change: None,
            allow_pick: false,
            freely_revoke: false,
        }
    }
}

#[derive(Serialize, Deserialize, PartialEq, Clone, Debug)]
pub struct Consent {
    pub fight_consent: Option<FightConsent>,
    pub expires: Option<DateTime<Utc>>,
    pub only_in: Vec<String>,
    pub allow_private: bool,
    pub until_death: bool,
}

impl Default for Consent {
    fn default() -> Self {
        Self {
            fight_consent: None,
            expires: None,
            only_in: vec![],
            allow_private: false,
            until_death: false,
        }
    }
}

impl Consent {
    pub fn to_str(&self) -> String {
        let mut details = vec![];
        if let Some(ref fc) = self.fight_consent {
            match fc.status {
                ConsentStatus::PendingAdd => {
                    details.push("pending acceptance".to_owned());
                }
                ConsentStatus::PendingDelete => {
                    details.push("pending agreement to delete".to_owned());
                }
                _ => {}
            }
            match fc.pending_change.as_ref() {
                None => {}
                Some(new_self) => {
                    details.push(format!("pending amendment to [{}]", &new_self.to_str()));
                }
            }
            if fc.allow_pick {
                details.push("allow pick".to_owned());
            }
            if fc.freely_revoke {
                details.push("allow revoke".to_owned());
            }
        }
        if self.allow_private {
            details.push("allow private".to_owned());
        } else {
            details.push("disallow private".to_owned());
        }
        if self.until_death {
            details.push("until death".to_owned());
        }
        for in_place in self.only_in.iter() {
            details.push(format!("in {}", in_place))
        }
        if let Some(exp) = self.expires {
            details.push(format!(
                "valid for {}",
                humantime::format_duration(std::time::Duration::from_secs(
                    (exp - Utc::now()).num_seconds() as u64
                ))
            ));
        }
        return details.into_iter().join(", ");
    }
}