//! Main source: rae-api.com, which serves the DLE content as JSON.
//!
//! It carries less than the DLE page (no conjugation) and allows 10 requests
//! per minute, but its format is stable and, unlike dle.rae.es, it answers
//! automated clients.

use anyhow::{Context, Result};
use serde::Deserialize;

use crate::client::{percent_encode, Http};
use crate::model::{Abbr, Entry, Sense};

const BASE: &str = "https://rae-api.com/api";

#[derive(Deserialize)]
struct Response {
    data: Option<Data>,
}

#[derive(Deserialize)]
struct Data {
    word: String,
    #[serde(default)]
    meanings: Vec<Meaning>,
}

#[derive(Deserialize)]
struct Meaning {
    origin: Option<Origin>,
    #[serde(default)]
    senses: Vec<ApiSense>,
}

#[derive(Deserialize)]
struct Origin {
    raw: Option<String>,
}

#[derive(Deserialize)]
struct ApiSense {
    /// The sense as the dictionary prints it, marks included:
    /// `"1. intr. Emitir palabras."`
    raw: Option<String>,
    meaning_number: Option<u32>,
    description: Option<String>,
    category: Option<String>,
    gender: Option<String>,
    usage: Option<String>,
    #[serde(default)]
    examples: Vec<String>,
    synonyms: Option<Vec<String>>,
    antonyms: Option<Vec<String>>,
}

/// Looks up a word. `Ok(None)` if the API says it does not exist.
pub fn lookup(http: &Http, word: &str) -> Result<Option<Entry>> {
    let url = format!("{BASE}/words/{}", percent_encode(word));
    let (status, body) = http.get(&url, crate::client::CLIENT_UA)?;
    if status == 404 {
        return Ok(None);
    }
    if status == 429 {
        anyhow::bail!(
            "rae-api limita a 10 consultas por minuto y se alcanzó el tope; \
             espera un momento (lo ya consultado sigue disponible en la caché)"
        );
    }
    if status != 200 {
        anyhow::bail!("rae-api respondió {status}");
    }
    let res: Response =
        serde_json::from_str(&body).context("rae-api devolvió un JSON inesperado")?;
    Ok(res.data.map(into_entry))
}

/// The word of the day published by the RAE.
pub fn word_of_the_day(http: &Http) -> Result<String> {
    single_word(http, &format!("{BASE}/daily"))
}

/// A random word from the dictionary.
pub fn random_word(http: &Http) -> Result<String> {
    single_word(http, &format!("{BASE}/random"))
}

fn single_word(http: &Http, url: &str) -> Result<String> {
    #[derive(Deserialize)]
    struct Wrapper {
        data: Inner,
    }
    #[derive(Deserialize)]
    struct Inner {
        word: String,
    }
    let (status, body) = http.get(url, crate::client::CLIENT_UA)?;
    if status == 429 {
        anyhow::bail!("rae-api limita a 10 consultas por minuto y se alcanzó el tope");
    }
    if status != 200 {
        anyhow::bail!("rae-api respondió {status}");
    }
    let w: Wrapper = serde_json::from_str(&body).context("rae-api devolvió un JSON inesperado")?;
    Ok(w.data.word)
}

fn into_entry(d: Data) -> Entry {
    let etymology = d
        .meanings
        .iter()
        .find_map(|m| m.origin.as_ref().and_then(|o| o.raw.clone()))
        .filter(|s| !s.trim().is_empty());
    let senses = d
        .meanings
        .iter()
        .flat_map(|m| m.senses.iter())
        .map(into_sense)
        .collect();
    Entry {
        word: d.word,
        etymology,
        senses,
        locutions: vec![],
        conjugation: None,
        source: "rae-api".into(),
    }
}

fn into_sense(s: &ApiSense) -> Sense {
    // The API labels in English; translate to the DLE abbreviations so the
    // output looks the same whatever the source.
    let description = s.description.as_deref().unwrap_or_default().trim();

    // The `raw` field holds the sense as printed, with the exact dictionary
    // marks («intr.», «p. us.»). That beats rebuilding them from the English
    // labels, which are coarser: they say «verb» where the dictionary tells
    // transitive from intransitive.
    if let Some(marks) = s.raw.as_deref().and_then(|r| printed_marks(r, description)) {
        let grammar = expand_marks(&marks);
        return Sense {
            number: s.meaning_number.map(|n| n.to_string()),
            grammar,
            text: close_sentence(&format!("{marks} {description}")),
            examples: s.examples.clone(),
            synonyms: s.synonyms.clone().unwrap_or_default(),
            antonyms: s.antonyms.clone().unwrap_or_default(),
        };
    }

    let mut grammar = Vec::new();
    // The dictionary writes «f.», not «s. f.»: the gender mark already says
    // the word is a noun, so the category is redundant.
    let gendered = s.gender.as_deref().is_some_and(|g| !g.is_empty());
    let category = match s.category.as_deref() {
        Some("noun") if gendered => None,
        other => other.map(str::to_string),
    };
    for (value, table) in [
        (&category, CATEGORIES),
        (&s.gender, GENDERS),
        (&s.usage, USAGES),
    ] {
        let Some(v) = value.as_deref().filter(|v| !v.is_empty()) else {
            continue;
        };
        if let Some((short, long)) = table
            .iter()
            .find(|(k, _, _)| *k == v)
            .map(|(_, s, l)| (*s, *l))
        {
            grammar.push(Abbr {
                short: short.into(),
                long: long.into(),
            });
        }
    }
    // The API returns the bare definition, without the marks or the final
    // dot the dictionary prints. Put them back so the output reads the same
    // whatever the source.
    let text = printed_form(&grammar, s.description.as_deref().unwrap_or_default());

    Sense {
        number: s.meaning_number.map(|n| n.to_string()),
        grammar,
        text,
        examples: s.examples.clone(),
        synonyms: s.synonyms.clone().unwrap_or_default(),
        antonyms: s.antonyms.clone().unwrap_or_default(),
    }
}

/// Builds the definition as the dictionary prints it: grammar marks in front
/// and a dot at the end.
fn printed_form(grammar: &[Abbr], description: &str) -> String {
    let description = description.trim();
    if description.is_empty() {
        return String::new();
    }
    let marks: Vec<&str> = grammar.iter().map(|a| a.short.as_str()).collect();
    let joined = if marks.is_empty() {
        description.to_string()
    } else {
        format!("{} {description}", marks.join(" "))
    };
    close_sentence(&joined)
}

/// Adds the final dot unless the definition already ends closed.
fn close_sentence(text: &str) -> String {
    let text = text.trim();
    if text.is_empty() {
        return String::new();
    }
    match text.chars().next_back() {
        Some(c) if ".!?…".contains(c) => text.to_string(),
        _ => format!("{text}."),
    }
}

/// Cuts the marks out of the printed text: whatever sits between the sense
/// number and the start of the definition.
fn printed_marks(raw: &str, description: &str) -> Option<String> {
    if description.is_empty() {
        return None;
    }
    let head = &raw[..raw.find(description)?];
    let head = head.trim_start_matches(|c: char| c.is_ascii_digit());
    let marks = head.trim_start().strip_prefix('.').unwrap_or(head).trim();
    (!marks.is_empty()).then(|| marks.to_string())
}

/// Expands dictionary abbreviations. Tries the longest first, because
/// «p. us.» starts like a one-letter abbreviation.
fn expand_marks(marks: &str) -> Vec<Abbr> {
    let mut out: Vec<Abbr> = Vec::new();
    let mut rest = marks.trim();
    while !rest.is_empty() {
        match ABBREVIATIONS.iter().find(|(s, _)| rest.starts_with(s)) {
            Some((short, long)) => {
                if !out.iter().any(|a| a.short == *short) {
                    out.push(Abbr {
                        short: (*short).into(),
                        long: (*long).into(),
                    });
                }
                rest = rest[short.len()..].trim_start();
            }
            // Unknown mark: skip it without breaking the rest.
            None => match rest.find(' ') {
                Some(i) => rest = rest[i + 1..].trim_start(),
                None => break,
            },
        }
    }
    out
}

/// Dictionary abbreviations, longest first so prefix matching never splits
/// one in two.
const ABBREVIATIONS: &[(&str, &str)] = &[
    ("p. us.", "poco usado"),
    ("interj.", "interjección"),
    ("prnl.", "verbo pronominal"),
    ("coloq.", "coloquial"),
    ("desus.", "desusado"),
    ("intr.", "verbo intransitivo"),
    ("prep.", "preposición"),
    ("pron.", "pronombre"),
    ("conj.", "conjunción"),
    ("adj.", "adjetivo"),
    ("adv.", "adverbio"),
    ("amb.", "nombre ambiguo"),
    ("com.", "nombre común"),
    ("vulg.", "vulgar"),
    ("cult.", "culto"),
    ("art.", "artículo"),
    ("tr.", "verbo transitivo"),
    ("f.", "nombre femenino"),
    ("m.", "nombre masculino"),
    ("U.", "usado"),
];

type Lex = &'static [(&'static str, &'static str, &'static str)];

const CATEGORIES: Lex = &[
    ("noun", "s.", "sustantivo"),
    ("adjective", "adj.", "adjetivo"),
    ("verb", "v.", "verbo"),
    ("transitive verb", "tr.", "verbo transitivo"),
    ("intransitive verb", "intr.", "verbo intransitivo"),
    ("pronominal verb", "prnl.", "verbo pronominal"),
    ("adverb", "adv.", "adverbio"),
    ("interjection", "interj.", "interjección"),
    ("preposition", "prep.", "preposición"),
    ("conjunction", "conj.", "conjunción"),
    ("pronoun", "pron.", "pronombre"),
    ("article", "art.", "artículo"),
];

const GENDERS: Lex = &[
    ("feminine", "f.", "nombre femenino"),
    ("masculine", "m.", "nombre masculino"),
    ("ambiguous", "amb.", "nombre ambiguo"),
    ("common", "com.", "nombre común"),
];

const USAGES: Lex = &[
    ("rare", "p. us.", "poco usado"),
    ("colloquial", "coloq.", "coloquial"),
    ("vulgar", "vulg.", "vulgar"),
    ("obsolete", "desus.", "desusado"),
    ("formal", "cult.", "culto"),
];

#[cfg(test)]
mod tests {
    use super::*;

    fn abbrs(list: &[(&str, &str)]) -> Vec<Abbr> {
        list.iter()
            .map(|(s, l)| Abbr {
                short: (*s).into(),
                long: (*l).into(),
            })
            .collect()
    }

    #[test]
    fn restores_marks_and_final_stop() {
        let g = abbrs(&[("f.", "nombre femenino")]);
        assert_eq!(
            printed_form(&g, "Edificio para habitar"),
            "f. Edificio para habitar."
        );
    }

    #[test]
    fn does_not_double_the_final_stop() {
        assert_eq!(printed_form(&[], "Edificio."), "Edificio.");
        assert_eq!(printed_form(&[], "¿Qué?"), "¿Qué?");
    }

    #[test]
    fn closes_a_definition_that_ends_in_a_parenthesis() {
        assert_eq!(printed_form(&[], "piso (‖ vivienda)"), "piso (‖ vivienda).");
    }

    #[test]
    fn joins_several_marks() {
        let g = abbrs(&[("f.", "nombre femenino"), ("p. us.", "poco usado")]);
        assert_eq!(printed_form(&g, "Casa"), "f. p. us. Casa.");
    }

    fn api_sense(category: &str, gender: &str) -> ApiSense {
        ApiSense {
            raw: None,
            meaning_number: Some(1),
            description: Some("Edificio para habitar".into()),
            category: Some(category.into()),
            gender: Some(gender.into()),
            usage: Some(String::new()),
            examples: vec![],
            synonyms: None,
            antonyms: None,
        }
    }

    #[test]
    fn a_gender_mark_replaces_the_noun_category() {
        // The DLE prints «f.», not «s. f.».
        let s = into_sense(&api_sense("noun", "feminine"));
        assert_eq!(s.text, "f. Edificio para habitar.");
        assert_eq!(s.grammar.len(), 1);
        assert_eq!(s.grammar[0].short, "f.");
    }

    #[test]
    fn a_category_without_gender_is_kept() {
        let s = into_sense(&api_sense("intransitive verb", ""));
        assert_eq!(s.text, "intr. Edificio para habitar.");
    }

    #[test]
    fn takes_the_marks_from_the_printed_text() {
        // The API only says «verb»; the printed text says intransitive.
        let raw = "1. intr. Emitir palabras.Sin.:comunicar, expresar.";
        assert_eq!(
            printed_marks(raw, "Emitir palabras").as_deref(),
            Some("intr.")
        );
    }

    #[test]
    fn printed_marks_handle_several_marks_and_two_digit_numbers() {
        let raw = "12. m. p. us. Cosa vieja.";
        assert_eq!(
            printed_marks(raw, "Cosa vieja").as_deref(),
            Some("m. p. us.")
        );
    }

    #[test]
    fn printed_marks_are_none_when_there_are_none() {
        assert_eq!(
            printed_marks("1. Emitir palabras.", "Emitir palabras"),
            None
        );
        assert_eq!(
            printed_marks("1. intr. Otra cosa.", "Emitir palabras"),
            None
        );
    }

    #[test]
    fn a_whole_sense_uses_the_printed_marks() {
        let mut s = api_sense("verb", "");
        s.raw = Some("1. intr. Emitir palabras.".into());
        s.description = Some("Emitir palabras".into());
        let out = into_sense(&s);
        assert_eq!(out.text, "intr. Emitir palabras.");
        assert_eq!(out.grammar[0].long, "verbo intransitivo");
    }

    #[test]
    fn expands_multi_token_abbreviations_first() {
        let g = expand_marks("m. p. us.");
        let shorts: Vec<&str> = g.iter().map(|a| a.short.as_str()).collect();
        assert_eq!(shorts, ["m.", "p. us."], "must not split «p. us.»");
    }

    #[test]
    fn unknown_marks_are_skipped_without_losing_the_rest() {
        let g = expand_marks("zz. f.");
        assert_eq!(g.len(), 1);
        assert_eq!(g[0].short, "f.");
    }

    #[test]
    fn empty_description_stays_empty() {
        assert_eq!(printed_form(&abbrs(&[("f.", "x")]), "  "), "");
    }
}