use std::collections::HashMap;
use reqwest::Client;
use serde::{Deserialize, Deserializer};
pub mod error;
use error::TezaursApiError;


use std::str::FromStr;
use serde_json::Value;

const API: &str = "http://api.tezaurs.lv:8182";

fn deserialize_from_string<'de, D>(deserializer: D) -> Result<usize, D::Error>
    where
        D: Deserializer<'de>,
{
    let s = String::deserialize(deserializer)?;
    usize::from_str(&s).map_err(serde::de::Error::custom)
}


fn deserialize_from_string_option<'de, D>(deserializer: D) -> Result<Option<usize>, D::Error>
    where
        D: Deserializer<'de>,
{
    let s = String::deserialize(deserializer)?;
    let result = usize::from_str(&s).ok();
    Ok(result)
}


pub struct TezaursApi {
    client: Client,
}

impl TezaursApi {
    pub fn new() -> Self {
        Self {
            client: Client::new(),
        }
    }

    pub async fn analyze(&self, word: String) -> Result<Vec<AnalyzedWord>, TezaursApiError> {
        let url = format!("{}/analyze/{}", API, word);
        let response = self.client.get(url).send().await?;
        let response_text = response.text().await?;
        let json: serde_json::Value = serde_json::from_str(&response_text)?;
        let data: Vec<AnalyzedWord> = serde_json::from_value(json.clone())?;

        Ok(data)
    }


    pub async fn tokenize(&self, sentence: String) -> Result<Vec<Token>, TezaursApiError> {
        let url = format!("{}/tokenize/{}", API, sentence);
        let response = self.client.get(url).send().await?;
        let response_text = response.text().await?;
        let json: Value = serde_json::from_str(&response_text)?;
        let data: Vec<Token> = serde_json::from_value(json.clone())?;
        Ok(data)
    }

    pub async fn normalize_phrase(&self, sentence: String) -> Result<String, TezaursApiError> {
        let url = format!("{}/normalize_phrase/{}", API, sentence);
        let response = self.client.get(url).send().await?;
        let response_text = response.text().await?;
        Ok(response_text)
    }

    pub async fn suitable_paradigm(&self, word: String) -> Result<Vec<Paradigm>, TezaursApiError> {
        let url = format!("{}/suitable_paradigm/{}", API, word);
        let response = self.client.get(url).send().await?;
        let response_text = response.text().await?;
        let json: Value = serde_json::from_str(&response_text)?;
        let data: Vec<Paradigm> = serde_json::from_value(json.clone())?;
        Ok(data)
    }

    pub async fn morphotagger(&self, sentence: String) -> Result<String, TezaursApiError> {
        let url = format!("{}/morphotagger/{}", API, sentence);
        let response = self.client.get(url).send().await?;
        let response_text = response.text().await?;
        Ok(response_text)
    }

    pub async fn verbs(&self, word: String) -> Result<Vec<String>, TezaursApiError> {
        let url = format!("{}/verbs/{}", API, word);
        let response = self.client.get(url).send().await?;
        let response_text = response.text().await?;
        let elements: Vec<&str> = response_text[1..response_text.len()-1].split(',').collect();

        let vec: Vec<String> = elements.iter()
            .map(|s| s.trim().replace("\"", ""))
            .collect();
        Ok(vec)
    }

    pub async fn inflect_phrase(&self, sentence: String) -> Result<Vec<Inflection>, TezaursApiError> {
        let url = format!("{}/inflect_phrase/{}", API, sentence);
        let response = self.client.get(url).send().await?;
        let response_text = response.text().await?;
        let json: Value = serde_json::from_str(&response_text)?;
        let map: HashMap<String, String> = serde_json::from_value(json).unwrap();
        let inflections: Vec<Inflection> = map.into_iter().map(|(case, sentence)| {
            let case = match case.as_str() {
                "Akuzatīvs" => Case::Accusative,
                "Ģenitīvs" => Case::Genitive,
                "Datīvs" => Case::Datīvs,
                "Lokatīvs" => Case::Locative,
                "Nominatīvs" => Case::Nominative,
                "Instrumentālis" => Case::Instrumental,
                "Vokatīvs" => Case::Vocative,
                _ => panic!("Unexpected case"), // Handle unexpected cases appropriately
            };
            Inflection { case, sentence }
        }).collect();

        Ok(inflections)
    }
}

#[derive(Deserialize, Debug)]
pub struct Paradigm {
    #[serde(rename = "ID")]
    pub id: u32,
    #[serde(rename = "Description")]
    pub description: String,
}

#[derive(Deserialize, Debug)]
pub struct TokenizeResponse {
    pub tokens: Vec<Token>
}

#[derive(Deserialize, Debug)]
pub struct Token {
    #[serde(rename = "Vārds")]
    pub word: String,
    #[serde(rename = "Marķējums")]
    pub tag: String,
    #[serde(rename = "Pamatforma")]
    pub base_form: String,
}

#[derive(Deserialize, Debug)]
pub struct AnalyzedWord {
    #[serde(rename = "Skaitlis")]
    pub number: Number,
    #[serde(rename = "Šķirkļa ID", default, deserialize_with = "deserialize_from_string_option")]
    pub id: Option<usize>,
    #[serde(rename = "Vārds")]
    pub word: String,
    #[serde(rename = "Šķirkļa cilvēklasāmais ID")]
    pub word_id: Option<String>,
    #[serde(rename = "Leksēmas nr", deserialize_with = "deserialize_from_string")]
    pub lexem: usize,
    #[serde(rename = "FreeText")]
    pub free_text: Option<String>,
    #[serde(rename = "Galotnes nr", deserialize_with = "deserialize_from_string")]
    pub end: usize,
    #[serde(rename = "Avots")]
    pub source: Option<String>,
    #[serde(rename = "Vārdšķira")]
    pub part_of_speech: PartOfSpeech,
    #[serde(rename = "Mija", deserialize_with = "deserialize_from_string")]
    pub swap: usize,
    #[serde(rename = "Minēšana")]
    pub mention: String,
    #[serde(rename = "Pamatforma")]
    pub basic_form: String,
    #[serde(rename = "Locījums")]
    pub case: Case,
    #[serde(rename = "Dzimte")]
    pub gender: Gender,
    #[serde(rename = "Vārdgrupas nr", deserialize_with = "deserialize_from_string")]
    pub group: usize,
    #[serde(rename = "Deklinācija", deserialize_with = "deserialize_from_string")]
    pub declination: usize,

}

#[derive(Deserialize, Debug)]

pub enum Number {
    #[serde(rename = "Vienskaitlis")]
    Singular,
    #[serde(rename = "Daudzskaitlis")]
    Plural,
}

#[derive(Deserialize, Debug)]

pub enum Gender {
    #[serde(rename = "Sieviešu")]
    Female,
    #[serde(rename = "Vīriešu")]
    Male,
}

#[derive(Deserialize, Debug)]

pub enum PartOfSpeech {
    #[serde(rename = "Lietvārds")]
    Noun,
    #[serde(rename = "Īpašības vārds")]
    Adjective,
    #[serde(rename = "Skaitļa vārds")]
    Numeral,
    #[serde(rename = "Darbības vārds")]
    Verb,
}


#[derive(Deserialize, Debug)]
pub struct Inflection {
    pub case: Case,
    pub sentence: String,
}

#[derive(Deserialize, Debug)]

pub enum Case {
    #[serde(rename = "Nominatīvs")]
    Nominative,
    #[serde(rename = "Ģenitīvs")]
    Genitive,
    #[serde(rename = "Datīvs")]
    Datīvs,
    #[serde(rename = "Akuzatīvs")]
    Accusative,
    #[serde(rename = "Instrumentālis")]
    Instrumental ,
    #[serde(rename = "Lokatīvs")]
    Locative,
    #[serde(rename = "Vokatīvs")]
    Vocative,
}



#[cfg(test)]
mod tests {

    use crate::{TezaursApi,};

    #[tokio::test]
    async fn my_test() -> Result<(), Box<dyn std::error::Error>> {

        let api = TezaursApi::new();


        let words = api.analyze("jūra".to_string()).await?;
        println!("{:?}", words);
        // [AnalyzedWord { number: Singular, id: None, word: "jūra", word_id: None, lexem: 1033983, free_text: None, end: 28, source: Some("VVC paplašinātais vārdadienu saraksts 2014-10-31"), part_of_speech: Noun, swap: 1, mention: "Nav", basic_form: "Jūris", case: Genitive, gender: Male, group: 3, declination: 2 }, AnalyzedWord { number: Singular, id: Some(134187), word: "jūra", word_id: Some("jūra:1"), lexem: 138064, free_text: None, end: 75, source: None, part_of_speech: Noun, swap: 0, mention: "Nav", basic_form: "jūra", case: Nominative, gender: Female, group: 7, declination: 4 }]

        let tokens = api.tokenize(String::from("es domāju")).await?; //
        println!("{:?}", tokens);
        // [Token { word: "es", tag: "pp10snn", base_form: "es" }, Token { word: "domāju", tag: "vmnip_21san", base_form: "domāt" }]

        let text = api.normalize_phrase(String::from("Latvijas Universitātes Matemātikas un Informātikas Institūtam")).await?;

        println!("{:?}", text);
        // Latvijas Universitātes Matemātikas un Informātikas Institūts


        let inflections = api.inflect_phrase(String::from("Latvijas Universitātes Matemātikas un Informātikas Institūtam")).await?;
        println!("{:?}", inflections);
        //[Inflection { case: Accusative, sentence: "Latvijas Universitātes Matemātikas un Informātikas Institūtu" }, Inflection { case: Datīvs, sentence: "Latvijas Universitātes Matemātikas un Informātikas Institūtam" }, Inflection { case:Locative, sentence: "Latvijas Universitātes Matemātikas un Informātikas Institūtā" }, Inflection { case: Nominative, sentence: "Latvijas Universitātes Matemātikas un Informātikas Institūts" }, Inflection { case: Genitive, sentence: "Latvijas Universitātes Matemātikas un Informātikas Institūta" }]

        let paradigms = api.suitable_paradigm(String::from("pokemonizators")).await?;
        println!("{:?}", paradigms);
        // [Paradigm { id: 1, description: "noun-1a" }, Paradigm { id: 13, description: "adj-1" }, Paradigm { id: 39, description: "foreign" }]

        let morphs = api.morphotagger(String::from("vīrs ar cirvi.")).await?;
        println!("{:?}", morphs);
        // vīrs    ncmsn1  vīrs
        // ar      spsa    ar
        // cirvi   ncmsa2  cirvis
        // .       zs      .

        let inflcs = api.verbs(String::from("domai")).await?;
        println!("{:?}", inflcs);
        // ["Dat", "Nom", "Gen", "Acc", "Loc"]

        assert!(true);

        Ok(())
    }
}