//! Models for malie.io exports

use std::borrow::Cow;
use std::collections::HashMap;

use anyhow::Context;
use serde::{Deserialize, de};
use tracing::warn;

use crate::editions::EditionCode;

pub type RawIndex = HashMap<Lang, HashMap<String, RawEdition>>;
pub type Index = HashMap<Lang, Vec<Edition>>;

#[derive(Debug, Deserialize, Eq, PartialEq, Hash)]
pub enum Lang {
    #[serde(rename = "de-DE")]
    De,
    #[serde(rename = "en-US")]
    En,
    #[serde(rename = "es-ES")]
    Es,
    #[serde(rename = "es-419")]
    EsLa,
    #[serde(rename = "it-IT")]
    It,
    #[serde(rename = "fr-FR")]
    Fr,
    #[serde(rename = "pt-BR")]
    Pt,
}

#[derive(Debug, Deserialize)]
pub struct RawEdition {
    path: String,
    #[serde(deserialize_with = "deserialize_edition_code")]
    abbr: Option<EditionCode>,
}

pub struct Edition {
    path: String,
    abbr: EditionCode,
}

fn deserialize_edition_code<'de, D>(deserializer: D) -> Result<Option<EditionCode>, D::Error>
where
    D: de::Deserializer<'de>,
{
    let buf = Cow::<'de, str>::deserialize(deserializer)?;

    if buf.is_empty() {
        return Ok(None);
    }

    let result = serde_json::from_str::<EditionCode>(&format!("\"{buf}\""))
        .with_context(|| format!("couldn't deserialize edition code {buf}"))
        .inspect_err(|e| warn!("{e}"));
    Ok(result.ok())
}

fn filter_invalid_editions(index: RawIndex) -> Index {
    index
        .into_iter()
        .map(|(k, v)| {
            let v = v
                .into_values()
                .map(|e| match e.abbr {
                    Some(abbr) => Some(Edition { path: e.path, abbr }),
                    None => None,
                })
                .flatten()
                .collect();
            (k, v)
        })
        .collect()
}