use core::fmt;

use chrono::{DateTime, Utc};
use serde::{de::Visitor, Deserialize};

#[derive(Deserialize)]
pub struct LatestVersions {
    release: String,
    snapshot: String
}

impl LatestVersions {
    pub fn get_release(&self) -> &String {
        &self.release
    }

    pub fn get_snapshot(&self) -> &String {
        &self.snapshot
    }
}

#[derive(Debug)]
pub enum VersionType {
    Snapshot,
    Release,
    OldBeta,
    OldAlpha,
    Other(String)
}

struct VersionTypeVisitor;

impl<'de> Visitor<'de> for VersionTypeVisitor {
    type Value = VersionType;

    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> fmt::Result {
        formatter.write_str("a Minecraft release type")
    }

    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
        where
            E: serde::de::Error, {
        match v {
            "snapshot" => Ok(VersionType::Snapshot),
            "release" => Ok(VersionType::Release),
            "old_beta" => Ok(VersionType::OldBeta),
            "old_alpha" => Ok(VersionType::OldAlpha),
            _ => Ok(VersionType::Other(v.to_owned()))
        }
    }
}

impl<'de> Deserialize<'de> for VersionType {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
        where
            D: serde::Deserializer<'de> {
        deserializer.deserialize_string(VersionTypeVisitor)
    }
}

// https://piston-meta.mojang.com/mc/game/version_manifest_v2.json
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct VersionManifestVersion {
    id: String,
    #[serde(rename = "type")]
    version_type: VersionType,
    url: String,
    time: DateTime<Utc>,
    release_time: DateTime<Utc>,
    sha1: String,
    compliance_level: u32
}

impl VersionManifestVersion {
    pub fn get_id(&self) -> &String {
        &self.id
    }

    pub fn get_version_type(&self) -> &VersionType {
        &self.version_type
    }

    pub fn get_url(&self) -> &String {
        &self.url
    }

    pub fn get_time(&self) -> &DateTime<Utc> {
        &self.time
    }

    pub fn get_release_time(&self) -> &DateTime<Utc> {
        &self.release_time
    }

    pub fn get_sha1(&self) -> &String {
        &self.sha1
    }

    pub fn get_compliance_level(&self) -> u32 {
        self.compliance_level
    }
}

#[derive(Deserialize)]
pub struct VersionManifest {
    latest: LatestVersions,
    versions: Vec<VersionManifestVersion>
}

impl VersionManifest {
    pub fn get_latest(&self) -> &LatestVersions {
        &self.latest
    }

    pub fn get_versions(&self) -> &Vec<VersionManifestVersion> {
        &self.versions
    }
}