#![allow(dead_code)]

use std::collections::HashMap;

use reqwest;
use serde::Deserialize;

use crate::{constants::VERSION_MANIFEST_URL, errors::McError};

#[derive(Debug, Deserialize)]
pub struct Version {
    pub id: String,

    #[serde(rename = "mainClass")]
    pub main_class: String,

    pub downloads: Downloads,
    pub libraries: Vec<Library>,

    #[serde(rename = "assetIndex")]
    pub asset_index: Option<AssetIndex>,
}

#[derive(Debug, Deserialize)]
pub struct AssetIndex {
    pub id: String,
    pub sha1: String,
    pub size: u64,
    pub url: String,
}

#[derive(Debug, Deserialize)]
pub struct Downloads {
    pub client: DownloadInfo,
}

#[derive(Debug, Deserialize)]
pub struct DownloadInfo {
    pub url: String,
    pub sha1: String,
    pub size: u64,
}

#[derive(Debug, Deserialize)]
pub struct Library {
    pub name: Option<String>,
    pub downloads: LibraryDownloads,

    #[serde(default)]
    pub natives: Option<HashMap<String, String>>,

    #[serde(default)]
    pub rules: Option<Vec<Rule>>,
}

#[derive(Debug, Deserialize)]
pub struct LibraryDownloads {
    pub artifact: Option<LibraryArtifact>,

    #[serde(default)]
    pub classifiers: Option<HashMap<String, LibraryArtifact>>,
}

#[derive(Debug, Deserialize)]
pub struct LibraryArtifact {
    pub path: String,
    pub url: String,
    pub sha1: String,
    pub size: u64,
}

#[derive(Debug, Deserialize)]
pub struct Rule {
    pub action: String,
    pub os: Option<OsRule>,
}

#[derive(Debug, Deserialize)]
pub struct OsRule {
    pub name: String,
}

pub async fn load_version(
    cfg: &crate::config::Config,
) -> Result<Version, McError> {
    let manifest_text = reqwest::get(VERSION_MANIFEST_URL)
        .await?
        .text()
        .await?;
    let root: serde_json::Value = serde_json::from_str(&manifest_text)?;
    let version_id = if cfg.version == "latest" {
        root["latest"]["release"]
            .as_str()
            .ok_or_else(|| McError::Config("missing latest.release".into()))?
            .to_string()
    } else {
        cfg.version.clone()
    };

    let versions = root["versions"]
        .as_array()
        .ok_or_else(|| McError::Config("missing versions array".into()))?;

    let version_entry = versions
        .iter()
        .find(|v| v["id"].as_str() == Some(&version_id))
        .ok_or_else(|| {
            McError::Config(format!("version '{}' not found", version_id))
        })?;

    let url = version_entry["url"]
        .as_str()
        .ok_or_else(|| McError::Config("missing version url".into()))?;

    let version_text = reqwest::get(url).await?.text().await?;
    let version: Version = serde_json::from_str(&version_text)?;

    Ok(version)
}