use serde::{
    de::{self, MapAccess, Visitor},
    Deserialize, Deserializer,
};
use std::{
    collections::{BTreeMap, HashMap},
    iter::zip,
};

use torn_api_macros::{ApiCategory, IntoOwned};

use crate::de_util;

pub use crate::common::{Attack, AttackFull, LastAction, Status};

#[derive(Debug, Clone, Copy, ApiCategory)]
#[api(category = "user")]
#[non_exhaustive]
pub enum UserSelection {
    #[api(type = "Basic", flatten)]
    Basic,
    #[api(type = "Profile", flatten)]
    Profile,
    #[api(type = "Discord", field = "discord")]
    Discord,
    #[api(type = "PersonalStats", field = "personalstats")]
    PersonalStats,
    #[api(type = "CriminalRecord", field = "criminalrecord")]
    Crimes,
    #[api(type = "BTreeMap<i32, Attack>", field = "attacks")]
    AttacksFull,
    #[api(type = "BTreeMap<i32, AttackFull>", field = "attacks")]
    Attacks,
    #[api(type = "HashMap<Icon, &str>", field = "icons")]
    Icons,
    #[api(type = "Awards<Medals>", flatten)]
    Medals,
    #[api(type = "Awards<Honors>", flatten)]
    Honors,
}

pub type Selection = UserSelection;

#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Eq, Hash)]
pub enum Gender {
    Male,
    Female,
    Enby,
}

#[derive(Debug, IntoOwned)]
pub struct Faction<'a> {
    pub faction_id: i32,
    pub faction_name: &'a str,
    pub days_in_faction: i16,
    pub position: &'a str,
    pub faction_tag: Option<&'a str>,
    pub faction_tag_image: Option<&'a str>,
}

fn deserialize_faction<'de, D>(deserializer: D) -> Result<Option<Faction<'de>>, D::Error>
where
    D: Deserializer<'de>,
{
    #[derive(Deserialize)]
    #[serde(rename_all = "snake_case")]
    enum Field {
        FactionId,
        FactionName,
        DaysInFaction,
        Position,
        FactionTag,
        FactionTagImage,
    }

    struct FactionVisitor;

    impl<'de> Visitor<'de> for FactionVisitor {
        type Value = Option<Faction<'de>>;

        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
            formatter.write_str("struct Faction")
        }

        fn visit_map<V>(self, mut map: V) -> Result<Self::Value, V::Error>
        where
            V: MapAccess<'de>,
        {
            let mut faction_id = None;
            let mut faction_name = None;
            let mut days_in_faction = None;
            let mut position = None;
            let mut faction_tag = None;
            let mut faction_tag_image = None;

            while let Some(key) = map.next_key()? {
                match key {
                    Field::FactionId => {
                        faction_id = Some(map.next_value()?);
                    }
                    Field::FactionName => {
                        faction_name = Some(map.next_value()?);
                    }
                    Field::DaysInFaction => {
                        days_in_faction = Some(map.next_value()?);
                    }
                    Field::Position => {
                        position = Some(map.next_value()?);
                    }
                    Field::FactionTag => {
                        faction_tag = map.next_value()?;
                    }
                    Field::FactionTagImage => {
                        faction_tag_image = map.next_value()?;
                    }
                }
            }
            let faction_id = faction_id.ok_or_else(|| de::Error::missing_field("faction_id"))?;
            let faction_name =
                faction_name.ok_or_else(|| de::Error::missing_field("faction_name"))?;
            let days_in_faction =
                days_in_faction.ok_or_else(|| de::Error::missing_field("days_in_faction"))?;
            let position = position.ok_or_else(|| de::Error::missing_field("position"))?;

            if faction_id == 0 {
                Ok(None)
            } else {
                Ok(Some(Faction {
                    faction_id,
                    faction_name,
                    days_in_faction,
                    position,
                    faction_tag,
                    faction_tag_image,
                }))
            }
        }
    }

    const FIELDS: &[&str] = &[
        "faction_id",
        "faction_name",
        "days_in_faction",
        "position",
        "faction_tag",
    ];
    deserializer.deserialize_struct("Faction", FIELDS, FactionVisitor)
}

#[derive(Debug, IntoOwned, Deserialize)]
pub struct Basic<'a> {
    pub player_id: i32,
    pub name: &'a str,
    pub level: i16,
    pub gender: Gender,
    pub status: Status<'a>,
}

#[derive(Debug, Clone, IntoOwned, PartialEq, Eq, Deserialize)]
#[into_owned(identity)]
pub struct Discord {
    #[serde(
        rename = "userID",
        deserialize_with = "de_util::empty_string_int_option"
    )]
    pub user_id: Option<i32>,
    #[serde(rename = "discordID", deserialize_with = "de_util::string_is_long")]
    pub discord_id: Option<i64>,
}

#[derive(Debug, Clone, Deserialize)]
pub struct LifeBar {
    pub current: i16,
    pub maximum: i16,
    pub increment: i16,
}

#[derive(Debug, Clone, Copy, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum EliminationTeam2022 {
    Firestarters,
    HardBoiled,
    QuackAddicts,
    RainMen,
    TotallyBoned,
    RawringThunder,
    DirtyCops,
    LaughingStock,
    JeanTherapy,
    #[serde(rename = "satants-soldiers")]
    SatansSoldiers,
    WolfPack,
    Sleepyheads,
}

#[derive(Debug, Clone, Copy, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum EliminationTeam {
    Backstabbers,
    Cheese,
    DeathsDoor,
    RegularHumanPeople,
    FlowerRangers,
    ReligiousExtremists,
    Hivemind,
    CapsLockCrew,
}

#[derive(Debug, Clone, IntoOwned)]
#[into_owned(identity)]
pub enum Competition {
    Elimination {
        score: i32,
        attacks: i16,
        team: EliminationTeam,
    },
    DogTags {
        score: i32,
        position: Option<i32>,
    },
    Unknown,
}

fn deserialize_comp<'de, D>(deserializer: D) -> Result<Option<Competition>, D::Error>
where
    D: Deserializer<'de>,
{
    #[derive(Deserialize)]
    #[serde(rename_all = "camelCase")]
    enum Field {
        Name,
        Score,
        Team,
        Attacks,
        TeamName,
        Position,
        #[serde(other)]
        Ignore,
    }

    #[derive(Deserialize)]
    enum CompetitionName {
        Elimination,
        #[serde(rename = "Dog Tags")]
        DogTags,
        #[serde(other)]
        Unknown,
    }

    struct CompetitionVisitor;

    impl<'de> Visitor<'de> for CompetitionVisitor {
        type Value = Option<Competition>;

        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
            formatter.write_str("struct Competition")
        }

        fn visit_none<E>(self) -> Result<Self::Value, E>
        where
            E: de::Error,
        {
            Ok(None)
        }

        fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
        where
            D: Deserializer<'de>,
        {
            deserializer.deserialize_map(self)
        }

        fn visit_map<V>(self, mut map: V) -> Result<Self::Value, V::Error>
        where
            V: MapAccess<'de>,
        {
            let mut team = None;
            let mut score = None;
            let mut attacks = None;
            let mut name = None;
            let mut position = None;

            while let Some(key) = map.next_key()? {
                match key {
                    Field::Name => {
                        name = Some(map.next_value()?);
                    }
                    Field::Score => {
                        score = Some(map.next_value()?);
                    }
                    Field::Attacks => {
                        attacks = Some(map.next_value()?);
                    }
                    Field::Position => {
                        position = Some(map.next_value()?);
                    }
                    Field::Team => {
                        let team_raw: &str = map.next_value()?;
                        team = if team_raw.is_empty() {
                            None
                        } else {
                            Some(match team_raw {
                                "backstabbers" => EliminationTeam::Backstabbers,
                                "cheese" => EliminationTeam::Cheese,
                                "deaths-door" => EliminationTeam::DeathsDoor,
                                "regular-human-people" => EliminationTeam::RegularHumanPeople,
                                "flower-rangers" => EliminationTeam::FlowerRangers,
                                "religious-extremists" => EliminationTeam::ReligiousExtremists,
                                "hivemind" => EliminationTeam::Hivemind,
                                "caps-lock-crew" => EliminationTeam::CapsLockCrew,
                                _ => Err(de::Error::unknown_variant(team_raw, &[]))?,
                            })
                        }
                    }
                    _ => (),
                }
            }

            let name = name.ok_or_else(|| de::Error::missing_field("name"))?;

            match name {
                CompetitionName::Elimination => {
                    if let Some(team) = team {
                        let score = score.ok_or_else(|| de::Error::missing_field("score"))?;
                        let attacks = attacks.ok_or_else(|| de::Error::missing_field("attacks"))?;
                        Ok(Some(Competition::Elimination {
                            team,
                            score,
                            attacks,
                        }))
                    } else {
                        Ok(None)
                    }
                }
                CompetitionName::DogTags => {
                    let score = score.ok_or_else(|| de::Error::missing_field("score"))?;
                    let position = position.ok_or_else(|| de::Error::missing_field("position"))?;

                    Ok(Some(Competition::DogTags { score, position }))
                }
                CompetitionName::Unknown => Ok(Some(Competition::Unknown)),
            }
        }
    }

    deserializer.deserialize_option(CompetitionVisitor)
}

#[derive(Debug, IntoOwned, Deserialize)]
pub struct Profile<'a> {
    pub player_id: i32,
    pub name: &'a str,
    pub rank: &'a str,
    pub level: i16,
    pub gender: Gender,
    pub age: i32,

    pub life: LifeBar,
    pub last_action: LastAction,
    #[serde(deserialize_with = "deserialize_faction")]
    pub faction: Option<Faction<'a>>,
    pub job: EmploymentStatus,
    pub status: Status<'a>,

    #[serde(deserialize_with = "deserialize_comp")]
    pub competition: Option<Competition>,

    #[serde(deserialize_with = "de_util::int_is_bool")]
    pub revivable: bool,
}

#[derive(Debug, Clone, Deserialize)]
pub struct PersonalStats {
    #[serde(rename = "attackswon")]
    pub attacks_won: i32,
    #[serde(rename = "attackslost")]
    pub attacks_lost: i32,
    #[serde(rename = "defendswon")]
    pub defends_won: i32,
    #[serde(rename = "defendslost")]
    pub defends_lost: i32,
    #[serde(rename = "statenhancersused")]
    pub stat_enhancers_used: i32,
    pub refills: i32,
    #[serde(rename = "drugsused")]
    pub drugs_used: i32,
    #[serde(rename = "xantaken")]
    pub xanax_taken: i32,
    #[serde(rename = "lsdtaken")]
    pub lsd_taken: i32,
    #[serde(rename = "networth")]
    pub net_worth: i64,
    #[serde(rename = "energydrinkused")]
    pub cans_used: i32,
    #[serde(rename = "boostersused")]
    pub boosters_used: i32,
    pub awards: i16,
    pub elo: i16,
    #[serde(rename = "daysbeendonator")]
    pub days_been_donator: i16,
    #[serde(rename = "bestdamage")]
    pub best_damage: i32,
}

#[derive(Deserialize)]
pub struct Crimes1 {
    pub selling_illegal_products: i32,
    pub theft: i32,
    pub auto_theft: i32,
    pub drug_deals: i32,
    pub computer_crimes: i32,
    pub murder: i32,
    pub fraud_crimes: i32,
    pub other: i32,
    pub total: i32,
}

#[derive(Deserialize)]
pub struct Crimes2 {
    pub vandalism: i32,
    pub theft: i32,
    pub counterfeiting: i32,
    pub fraud: i32,
    #[serde(rename = "illicitservices")]
    pub illicit_services: i32,
    #[serde(rename = "cybercrime")]
    pub cyber_crime: i32,
    pub extortion: i32,
    #[serde(rename = "illegalproduction")]
    pub illegal_production: i32,
    pub total: i32,
}

#[derive(Deserialize)]
#[serde(untagged)]
pub enum CriminalRecord {
    Crimes1(Crimes1),
    Crimes2(Crimes2),
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Icon(i16);

impl Icon {
    pub const SUBSCRIBER: Self = Self(4);
    pub const LEVEL_100: Self = Self(5);
    pub const GENDER_MALE: Self = Self(6);
    pub const GENDER_FEMALE: Self = Self(7);
    pub const MARITAL_STATUS: Self = Self(8);
    pub const FACTION_MEMBER: Self = Self(9);
    pub const PLAYER_COMMITTEE: Self = Self(10);
    pub const STAFF: Self = Self(11);

    pub const COMPANY: Self = Self(27);
    pub const BANK_INVESTMENT: Self = Self(29);
    pub const PROPERTY_VAULT: Self = Self(32);
    pub const DUKE_LOAN: Self = Self(33);

    pub const DRUG_COOLDOWN: Self = Self(53);

    pub const FEDDED: Self = Self(70);
    pub const TRAVELLING: Self = Self(71);
    pub const FACTION_LEADER: Self = Self(74);
    pub const TERRITORY_WAR: Self = Self(75);

    pub const FACTION_RECRUIT: Self = Self(81);
    pub const STOCK_MARKET: Self = Self(84);
}

impl<'de> Deserialize<'de> for Icon {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct IconVisitor;

        impl<'de> Visitor<'de> for IconVisitor {
            type Value = Icon;

            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                write!(formatter, "struct Icon")
            }

            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
            where
                E: de::Error,
            {
                if let Some(suffix) = v.strip_prefix("icon") {
                    Ok(Icon(suffix.parse().map_err(|_e| {
                        de::Error::invalid_value(de::Unexpected::Str(suffix), &"&str \"IconXX\"")
                    })?))
                } else {
                    Err(de::Error::invalid_value(
                        de::Unexpected::Str(v),
                        &"&str \"iconXX\"",
                    ))
                }
            }
        }

        deserializer.deserialize_str(IconVisitor)
    }
}

#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum Job {
    Director,
    Employee,
    Education,
    Army,
    Law,
    Casino,
    Medical,
    Grocer,
    #[serde(other)]
    Other,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Company {
    PlayerRun {
        name: String,
        id: i32,
        company_type: u8,
    },
    CityJob,
}

impl<'de> Deserialize<'de> for Company {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct CompanyVisitor;

        impl<'de> Visitor<'de> for CompanyVisitor {
            type Value = Company;

            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("enum Company")
            }

            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
            where
                A: MapAccess<'de>,
            {
                #[allow(clippy::enum_variant_names)]
                #[derive(Deserialize)]
                #[serde(rename_all = "snake_case")]
                enum Field {
                    CompanyId,
                    CompanyName,
                    CompanyType,
                    #[serde(other)]
                    Other,
                }

                let mut id = None;
                let mut name = None;
                let mut company_type = None;

                while let Some(key) = map.next_key()? {
                    match key {
                        Field::CompanyId => {
                            id = Some(map.next_value()?);
                            if id == Some(0) {
                                return Ok(Company::CityJob);
                            }
                        }
                        Field::CompanyType => company_type = Some(map.next_value()?),
                        Field::CompanyName => {
                            name = Some(map.next_value()?);
                        }
                        Field::Other => (),
                    }
                }

                let id = id.ok_or_else(|| de::Error::missing_field("company_id"))?;
                let name = name.ok_or_else(|| de::Error::missing_field("company_name"))?;
                let company_type =
                    company_type.ok_or_else(|| de::Error::missing_field("company_type"))?;

                Ok(Company::PlayerRun {
                    name,
                    id,
                    company_type,
                })
            }
        }

        deserializer.deserialize_map(CompanyVisitor)
    }
}

#[derive(Debug, Clone, Deserialize)]
pub struct EmploymentStatus {
    pub job: Job,
    #[serde(flatten)]
    pub company: Company,
}

#[derive(Debug, Clone, Copy)]
pub struct Award {
    pub award_time: chrono::DateTime<chrono::Utc>,
}

pub trait AwardMarker {
    fn award_key() -> &'static str;
    fn time_key() -> &'static str;
}

#[derive(Debug, Clone)]
pub struct Awards<T>
where
    T: AwardMarker,
{
    pub inner: BTreeMap<i32, Award>,
    marker: std::marker::PhantomData<T>,
}

impl<T> std::ops::Deref for Awards<T>
where
    T: AwardMarker,
{
    type Target = BTreeMap<i32, Award>;

    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}

impl<T> std::ops::DerefMut for Awards<T>
where
    T: AwardMarker,
{
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}

impl<T> Awards<T>
where
    T: AwardMarker,
{
    pub fn into_inner(self) -> BTreeMap<i32, Award> {
        self.inner
    }
}

pub struct Medals;

impl AwardMarker for Medals {
    #[inline(always)]
    fn award_key() -> &'static str {
        "medals_awarded"
    }
    #[inline(always)]
    fn time_key() -> &'static str {
        "medals_time"
    }
}

pub struct Honors;

impl AwardMarker for Honors {
    #[inline(always)]
    fn award_key() -> &'static str {
        "honors_awarded"
    }
    #[inline(always)]
    fn time_key() -> &'static str {
        "honors_time"
    }
}

impl<'de, T> Deserialize<'de> for Awards<T>
where
    T: AwardMarker,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct AwardVisitor<T>(std::marker::PhantomData<T>)
        where
            T: AwardMarker;

        impl<'de, T> Visitor<'de> for AwardVisitor<T>
        where
            T: AwardMarker,
        {
            type Value = Awards<T>;

            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct awards")
            }

            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
            where
                A: MapAccess<'de>,
            {
                let mut awards: Option<Vec<i32>> = None;
                let mut times: Option<Vec<_>> = None;

                while let Some(key) = map.next_key::<&'de str>()? {
                    if key == T::award_key() {
                        awards = map.next_value()?;
                    } else if key == T::time_key() {
                        times = map.next_value()?;
                    }
                }

                let awards = awards.ok_or_else(|| de::Error::missing_field(T::award_key()))?;
                let times = times.ok_or_else(|| de::Error::missing_field(T::time_key()))?;

                Ok(Awards {
                    inner: zip(
                        awards,
                        times.into_iter().map(|t| Award {
                            award_time: chrono::DateTime::from_timestamp(t, 0).unwrap_or_default(),
                        }),
                    )
                    .collect(),
                    marker: Default::default(),
                })
            }
        }

        deserializer.deserialize_map(AwardVisitor(Default::default()))
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::tests::{async_test, setup, Client, ClientTrait};

    #[async_test]
    async fn user() {
        let key = setup();

        let response = Client::default()
            .torn_api(key)
            .user(|b| {
                b.selections([
                    Selection::Basic,
                    Selection::Discord,
                    Selection::Profile,
                    Selection::PersonalStats,
                    Selection::Crimes,
                    Selection::Attacks,
                    Selection::Medals,
                    Selection::Honors,
                ])
            })
            .await
            .unwrap();

        response.basic().unwrap();
        response.discord().unwrap();
        response.profile().unwrap();
        response.personal_stats().unwrap();
        response.crimes().unwrap();
        response.attacks().unwrap();
        response.attacks_full().unwrap();
        response.medals().unwrap();
        response.honors().unwrap();
    }

    #[async_test]
    async fn not_in_faction() {
        let key = setup();

        let response = Client::default()
            .torn_api(key)
            .user(|b| b.id(28).selections([Selection::Profile]))
            .await
            .unwrap();

        let faction = response.profile().unwrap().faction;

        assert!(faction.is_none());
    }

    #[async_test]
    async fn bulk() {
        let key = setup();

        let response = Client::default()
            .torn_api(key)
            .users([1, 2111649, 374272176892674048i64], |b| {
                b.selections([Selection::Basic])
            })
            .await;

        response.get(&1).as_ref().unwrap().as_ref().unwrap();
        response.get(&2111649).as_ref().unwrap().as_ref().unwrap();
    }

    #[async_test]
    async fn discord() {
        let key = setup();

        let response = Client::default()
            .torn_api(key)
            .user(|b| b.id(374272176892674048i64).selections([Selection::Basic]))
            .await
            .unwrap();

        assert_eq!(response.basic().unwrap().player_id, 2111649);
    }

    #[async_test]
    async fn fedded() {
        let key = setup();

        let response = Client::default()
            .torn_api(key)
            .user(|b| b.id(1900654).selections([Selection::Icons]))
            .await
            .unwrap();

        let icons = response.icons().unwrap();

        assert!(icons.contains_key(&Icon::FEDDED))
    }
}