use std::{env, ops::Add};

use anyhow::anyhow;
use hypher::hyphenate;
use itertools::Itertools;

use crate::save::Save;

async fn call_inference_service(word: &str) -> anyhow::Result<String> {
    let server: Result<String, anyhow::Error> =
        env::var("PHONEMIZER").or_else(|_| Ok("http://localhost:8000/".to_string()));
    Ok(
        reqwest::get(format!("{}?grapheme={}", server.unwrap(), word))
            .await?
            .text()
            .await?,
    )
}

impl Save<'_> {
    pub async fn inference(&self, prefix: &str) -> anyhow::Result<String> {
        let phonemes = call_inference_service(prefix).await?;

        let completion = self
            .trie
            .random_starting_with(&phonemes)
            .ok_or_else(|| anyhow!("no matches"))?;

        let infered = phonemes.clone().add(&completion);
        let word = self.reverse_index.get(&infered).ok_or_else(|| {
            anyhow!(
                "matched value is not in dictionary {} {}",
                infered,
                phonemes
            )
        })?;

        println!("Matching {} by adding {}", word, completion);

        let mut completed_syllabes: Vec<&str> = hyphenate(word, hypher::Lang::French).into_iter().collect_vec();
        let source_word_syllabes: Vec<&str> = hyphenate(prefix, hypher::Lang::French).into_iter().collect_vec();

        // input:           test
        // output found:    testames
        // out syl:         tes - tames
        // output expect:   tames
        // we just need to remove the prefix


        let mut i = 0;
        for (index, syl) in source_word_syllabes.iter().enumerate() {
            if *source_word_syllabes[index] == **syl {
                i = index
            } else {
                break;
            }
        }

        completed_syllabes.drain(0..i);        // we finally just need to compute the end of the word which matches the sound
        let found = completed_syllabes.join("");
        println!("{} is equivalent to {}", completion, found);

        Ok(format!("{} ({})", found, word))
    }
}