use std::sync::Arc;

use applib::DictRepository;
use applib::SqliteDictRepository;
use applib::SystemDecoder;
use applib::SystemEncoder;
use applib::sys_major as major;

#[derive(Clone)]
pub struct Container;

impl Container {
    pub async fn new() -> anyhow::Result<Self> {
        Ok(Self)
    }

    pub async fn create_dict_repo(
        &self,
        dict_name: &str,
    ) -> anyhow::Result<Arc<dyn DictRepository>> {
        let mut dict_repo = SqliteDictRepository::new("sqlite:app.db").await?;
        dict_repo.use_dict(dict_name);
        Ok(Arc::new(dict_repo))
    }

    pub fn create_decoder(&self) -> anyhow::Result<Box<dyn SystemDecoder>> {
        Ok(Box::new(major::Decoder::new(major::rules_pl::get_rules())))
    }

    pub async fn create_encoder(&self, dict_name: &str) -> anyhow::Result<Box<dyn SystemEncoder>> {
        let dict = self.create_dict_repo(dict_name).await?;
        let decoder = self.create_decoder()?;
        let words_stream = dict.stream_batches(1000).await.unwrap();
        let lvmap = major::LenValueMap::from_stream(words_stream, &(*decoder))
            .await
            .unwrap();
        let encoder = major::Encoder::new(lvmap);
        Ok(Box::new(encoder))
    }
}