path: root/src/version.rs

use core::fmt;
use std::{collections::BTreeMap, convert::Infallible, marker::PhantomData, ops::Deref, str::FromStr};

use chrono::{DateTime, Utc};
use regex::Regex;
use serde::{de::{self, Visitor}, Deserialize, Deserializer};

pub mod manifest;
use manifest::*;

#[derive(Deserialize, Debug, Clone, Copy)]
#[serde(rename_all = "lowercase")]
pub enum RuleAction {
    Allow,
    Disallow
}

// must derive an order on this because it's used as a key for a btreemap
#[derive(Deserialize, Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
#[serde(rename_all = "lowercase")]
pub enum OperatingSystem {
    Linux,   // "linux"
    Windows, // "windows"

    #[serde(alias = "osx")] // not technically correct but it works
    MacOS,   // "osx"

    #[serde(other)]
    Unknown  // (not used in official jsons)
}

#[derive(Debug)]
struct WrappedRegex(Regex);

impl Deref for WrappedRegex {
    type Target = Regex;

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

struct RegexVisitor;
impl<'de> Visitor<'de> for RegexVisitor {
    type Value = WrappedRegex;

    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
        formatter.write_str("a valid regular expression")
    }

    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
        where
            E: de::Error, {
        Regex::new(v).map_err(de::Error::custom).map(|r| WrappedRegex(r))
    }
}

impl<'de> Deserialize<'de> for WrappedRegex {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
        where
            D: Deserializer<'de> {
        deserializer.deserialize_any(RegexVisitor)
    }
}

#[derive(Deserialize, Debug)]
pub struct OSRestriction {
    pub name: Option<OperatingSystem>,

    pub version: Option<WrappedRegex>,
    pub arch: Option<WrappedRegex>
}

#[derive(Deserialize, Debug)]
pub struct CompatibilityRule {
    pub action: RuleAction,
    pub features: Option<BTreeMap<String, bool>>,
    pub os: Option<OSRestriction>
}

impl CompatibilityRule {
    pub fn features_match(&self, checker: fn(&str) -> bool) -> bool {
        if let Some(m) = self.features.as_ref() {
            for (feat, expect) in m {
                if checker(feat) != *expect {
                    return false;
                }
            }
        }

        true
    }
}

#[derive(Deserialize, Debug)]
pub struct Argument {
    #[serde(default)]
    pub rules: Option<Vec<CompatibilityRule>>,

    #[serde(default)]
    #[serde(deserialize_with = "string_or_array")]
    pub value: Vec<String>
}

#[derive(Debug)]
pub struct WrappedArgument(Argument);

impl FromStr for Argument {
    type Err = Infallible;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Ok(Argument {
            value: vec![s.to_owned()],
            rules: None
        })
    }
}

impl Deref for WrappedArgument {
    type Target = Argument;
    
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl<'de> Deserialize<'de> for WrappedArgument {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
        where
            D: Deserializer<'de> {
        Ok(WrappedArgument(string_or_struct(deserializer)?))
    }
}

#[derive(Deserialize, Debug)]
pub struct Arguments {
    pub game: Option<Vec<WrappedArgument>>,
    pub jvm: Option<Vec<WrappedArgument>>
}

#[derive(Deserialize, Debug, PartialEq, Eq, PartialOrd, Ord)]
#[serde(rename_all = "snake_case")]
pub enum DownloadType {
    Client,
    ClientMappings,
    Server,
    ServerMappings,
    WindowsServer
}

#[derive(Deserialize, Debug)]
pub struct DownloadInfo {
    pub sha1: Option<String>,
    pub size: Option<usize>,
    pub total_size: Option<usize>, // available for asset index
    pub url: Option<String>, // may not be present for libraries
    pub id: Option<String>,
    pub path: Option<String>
}

#[derive(Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct JavaVersionInfo {
    pub component: String,
    pub major_version: u32
}

#[derive(Deserialize, Debug)]
pub struct LibraryDownloads {
    pub artifact: Option<DownloadInfo>,
    pub classifiers: Option<BTreeMap<String, DownloadInfo>>
}

#[derive(Deserialize, Debug)]
pub struct LibraryExtractRule {
    #[serde(default)]
    pub exclude: Vec<String>
}

#[derive(Deserialize, Debug)]
pub struct Library {
    pub downloads: Option<LibraryDownloads>,
    pub name: String,
    pub extract: Option<LibraryExtractRule>,
    pub natives: Option<BTreeMap<OperatingSystem, String>>,
    pub rules: Option<Vec<CompatibilityRule>>,
    pub url: Option<String> // old format
}

#[derive(Deserialize, Debug)]
pub struct ClientLogging {
    pub argument: String,

    #[serde(rename = "type")]
    pub logger_type: String,
    pub file: DownloadInfo
}

#[derive(Deserialize, Debug)]
pub struct Logging {
    pub client: ClientLogging // other fields unknown
}

#[derive(Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct CompleteVersion {
    pub arguments: Option<Arguments>,
    pub minecraft_arguments: Option<String>,

    pub asset_index: Option<DownloadInfo>,
    pub assets: Option<String>,

    pub compliance_level: Option<u32>,

    pub java_version: Option<JavaVersionInfo>,

    #[serde(default)]
    pub downloads: BTreeMap<DownloadType, DownloadInfo>,

    #[serde(default)]
    pub libraries: Vec<Library>,

    pub id: String,
    pub jar: Option<String>, // used as the jar filename if specified? (no longer used officially)
    
    pub logging: Option<Logging>,

    pub main_class: Option<String>,
    pub minimum_launcher_version: Option<u32>,
    pub release_time: Option<DateTime<Utc>>,
    pub time: Option<DateTime<Utc>>,

    #[serde(rename = "type")]
    pub version_type: Option<VersionType>,

    pub compatibility_rules: Option<Vec<CompatibilityRule>>, //
    pub incompatibility_reason: Option<String>, // message shown when compatibility rules fail for this version

    pub inherits_from: Option<String>

    /* omitting field `savableVersion' because it seems like a vestigial part from old launcher versions
     * (also it isn't even a string that is present in modern liblauncher.so, so I assume it will never be used.)
     */
}

// https://serde.rs/string-or-struct.html
fn string_or_struct<'de, T, D>(deserializer: D) -> Result<T, D::Error>
where
    T: Deserialize<'de> + FromStr<Err = Infallible>,
    D: Deserializer<'de>,
{
    struct StringOrStruct<T>(PhantomData<fn() -> T>);

    impl<'de, T> Visitor<'de> for StringOrStruct<T>
    where
        T: Deserialize<'de> + FromStr<Err = Infallible>,
    {
        type Value = T;

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

        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
            where
                E: serde::de::Error, {
            Ok(FromStr::from_str(v).unwrap())
        }

        fn visit_map<A>(self, map: A) -> Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>, {
            // wizardry (check comment in link)
            Deserialize::deserialize(de::value::MapAccessDeserializer::new(map))
        }
    }

    deserializer.deserialize_any(StringOrStruct(PhantomData))
}

// adapted from above
fn string_or_array<'de, T, D>(deserializer: D) -> Result<Vec<T>, D::Error>
where
    T: Deserialize<'de> + FromStr<Err = Infallible>,
    D: Deserializer<'de>,
{
    struct StringOrVec<T>(PhantomData<fn() -> T>);

    impl<'de, T> Visitor<'de> for StringOrVec<T>
    where
        T: Deserialize<'de> + FromStr<Err = Infallible>,
    {
        type Value = Vec<T>;

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

        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
            where
                E: de::Error, {
            Ok(vec![FromStr::from_str(v).unwrap()])
        }

        fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error>
            where
                A: de::SeqAccess<'de>, {
            Deserialize::deserialize(de::value::SeqAccessDeserializer::new(seq))
        }
    }

    deserializer.deserialize_any(StringOrVec(PhantomData))
}

#[cfg(test)]
mod tests {
    use std::fs;

    use super::*;

    #[test]
    fn test_it() {
        let s = fs::read_to_string("./test_stuff/versions/1.7.10.json");

        let arg: CompleteVersion = serde_json::from_str(s.unwrap().as_str()).unwrap();
        dbg!(arg);
    }
    
    #[test]
    fn test_it2() {
        let s = fs::read_to_string("./test_stuff/version_manifest_v2.json");

        let arg: VersionManifest = serde_json::from_str(s.unwrap().as_str()).unwrap();
        dbg!(arg);
    }
}