phomnemic/apps/app_cli/src/container.rs

use std::sync::Arc;

// use crate::config::AppConfig;
use applib::DictImporter;
use applib::DictRepository;
use applib::SqliteDictRepository;
use applib::SystemDecoder;
use applib::SystemEncoder;
use applib::sys_major as major;

use crate::commands::decode;
use crate::commands::encode;
use crate::config::System;

#[derive(Clone)]
pub struct Container;

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

    pub async fn create_dict_importer(&self, dict_name: &str) -> anyhow::Result<DictImporter> {
        let repo = self.create_dict_repo(dict_name).await?;
        Ok(DictImporter::new(repo))
    }

    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,
        config: &decode::Config,
    ) -> anyhow::Result<Box<dyn SystemDecoder>> {
        Ok(match config.system {
            System::MajorPl => Box::new(major::Decoder::new(major::rules_pl::get_rules())),
            System::MajorEn => Box::new(major::Decoder::new(major::rules_en::get_rules())),
        })
    }

    pub async fn create_encoder(
        &self,
        config: &encode::Config,
    ) -> anyhow::Result<Box<dyn SystemEncoder>> {
        let dict = self.create_dict_repo(&config.dict_name).await?;

        let dec_config = decode::Config {
            system: config.system.clone(),
            input: String::new(),
        };
        let decoder = self.create_decoder(&dec_config)?;

        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))
    }
}