use serde::{Deserialize, Serialize};
use serde_xml_rs::{from_str, to_string};

/// Structure representing a XMLTV channel.
#[derive(Debug, PartialEq, Serialize, Deserialize)]
pub struct Channel {
    pub channel: String,
    pub id: String,
    pub display_names: Vec<ChannelDisplayName>,
    pub icons: Vec<String>,
    pub urls: Vec<String>,
}

/// Structure representing a XMLTV channel display name.
#[derive(Debug, PartialEq, Serialize, Deserialize)]
pub struct ChannelDisplayName {
    pub name: String,
    pub lang: Option<String>,
}

/// Structure representing a XMLTV program element.
///
/// Two fields are mandatory :
/// * start
/// * channel
#[derive(Debug, PartialEq, Serialize, Deserialize)]
pub struct Program {
    // Attributes
    pub start: String,
    pub stop: Option<String>,
    pub pdc_start: Option<String>,
    pub vps_start: Option<String>,
    pub showview: Option<String>,
    pub videoplus: Option<String>,
    pub channel: String,
    pub clumpidx: Option<String>,
    // Childs
    pub titles: Vec<Title>,
    pub sub_titles: Vec<SubTitle>,
    pub descs: Vec<Description>,
    pub credits: Option<Credits>,
    pub date: Option<String>,
    pub categories: Vec<Category>,
    pub keywords: Vec<Keyword>,
    pub language: Option<Language>,
    pub orig_language: Option<OrigLanguage>,
    pub length: Option<Length>,
    pub icons: Vec<Icon>,
    pub countries: Vec<Country>,
    // episode_num: Vec<String>,
    // video: Option<String>,
    // audio: Option<String>,
    // previously_shown: Option<String>,
    // premiere: Option<String>,
    // last_chance: Option<String>,
    // new: Option<String>,
    // subtitles: Vec<String>,
    // rating: Vec<String>,
    // star_rating: Vec<String>,
    // review: Vec<String>
}

/// XMLTV Program actor
#[derive(Debug, PartialEq, Serialize, Deserialize)]
pub struct Actor {
    pub actor: String,
    pub role: Option<String>,
}

/// XMLTV Program category
#[derive(Debug, PartialEq, Serialize, Deserialize)]
pub struct Category {
    pub category: String,
    pub lang: Option<String>,
}

/// XMLTV Program country

#[derive(Debug, PartialEq, Serialize, Deserialize)]
pub struct Country {
    pub country: String,
    pub lang: Option<String>,
}

/// XMLTV Program credits
#[derive(Debug, PartialEq, Serialize, Deserialize)]
pub struct Credits {
    pub directors: Vec<String>,
    pub actors: Vec<Actor>,
    pub writers: Vec<String>,
    pub adapters: Vec<String>,
    pub producers: Vec<String>,
    pub composers: Vec<String>,
    pub editors: Vec<String>,
    pub presenters: Vec<String>,
    pub commentators: Vec<String>,
    pub guests: Vec<String>,
}

/// Structure representing a XMLTV description
#[derive(Debug, PartialEq, Serialize, Deserialize)]
pub struct Description {
    pub desc: String,
    pub lang: Option<String>,
}

#[derive(Debug, PartialEq, Serialize, Deserialize)]
pub struct Icon {
    pub src: String,
    pub width: Option<String>,
    pub height: Option<String>,
}

#[derive(Debug, PartialEq, Serialize, Deserialize)]
pub struct Keyword {
    pub keyword: String,
    pub lang: Option<String>,
}

#[derive(Debug, PartialEq, Serialize, Deserialize)]
pub struct Language {
    pub language: String,
    pub lang: Option<String>,
}

#[derive(Debug, PartialEq, Serialize, Deserialize)]
pub struct Length {
    pub length: u16,
    pub units: Units,
}

#[derive(Debug, PartialEq, Serialize, Deserialize)]
pub enum Units {
    Seconds,
    Minutes,
    Hours,
}
impl Length {
    /// Get a tuple of hours, minutes and seconds
    pub fn to_hms(&self) -> (u8, u8, u8) {
        match self.units {
            Units::Seconds => {
                let (m, s) = divmod(self.length,60);
                let (h, m) = divmod(m.try_into().unwrap(), 60);
                (h, m, s)
            },
            Units::Minutes => {
                let (h, m) = divmod(self.length, 60);
                (h, m, 0)
            },
            Units::Hours => (self.length.try_into().unwrap(), 0, 0),
        }
    }
}

impl ToString for Units {
    fn to_string(&self) -> String {
        match self {
            Units::Seconds => String::from("seconds"),
            Units::Minutes => String::from("minutes"),
            Units::Hours => String::from("hours"),
        }
    }
}

/// Takes two numbers as arguments and returns their quotient and remainder when using integer division.
fn divmod(x: u16, y: u16) -> (u8, u8) {
    let quotient = x / y;
    let remainder = x % y;
    (quotient.try_into().unwrap(), remainder.try_into().unwrap())
}

#[derive(Debug, PartialEq, Serialize, Deserialize)]
pub struct OrigLanguage {
    pub orig_language: String,
    pub lang: Option<String>,
}

/// Structure representing a XMLTV sub title
#[derive(Debug, PartialEq, Serialize, Deserialize)]
pub struct SubTitle {
    pub title: String,
    pub lang: Option<String>,
}

/// Structure representing a XMLTV title
#[derive(Debug, PartialEq, Serialize, Deserialize)]
pub struct Title {
    pub title: String,
    pub lang: Option<String>,
}

#[cfg(test)]
mod tests {

    use super::*;

    #[test]
    fn test_divmod() {
        // test secondes
        let time = Length{ length: 100, units: Units::Seconds };
        assert_eq!(time.to_hms(), (0, 1, 40));
        let time = Length{ length: 7000, units: Units::Seconds };
        assert_eq!(time.to_hms(), (1, 56, 40));
        //test minutes
        let time = Length{ length: 112, units: Units::Minutes };
        assert_eq!(time.to_hms(), (1, 52, 0));
        //test hours
        let time = Length{ length: 2, units: Units::Hours };
        assert_eq!(time.to_hms(), (2, 0, 0));
    }
}