phomnemic/app/src/commands/encode.rs

use applib::core::sys_major::encoder::Encoder;
use applib::core::sys_major::{self as major, LenValueMap};
use applib::core::traits::SystemEncoder;
use applib::system::System;
use tracing::debug;

use crate::commands::{ClapArgs, CommandExecutor, ConfigurableCommand};
use crate::config::AppConfig;
use crate::container::Container;

use crate::defaults;
use anyhow::Result;
use async_trait::async_trait;
use config::ConfigBuilder;
use config::builder::DefaultState;

#[derive(ClapArgs, Debug, Clone)]
pub struct EncodeArgs {
    #[arg(long, help = defaults::HELP_ENC_SYSTEM)]
    pub system: Option<String>,

    #[arg(long, help = defaults::HELP_ENC_INPUT)]
    pub input: String,
}

impl ConfigurableCommand for EncodeArgs {
    fn apply_defaults(
        &self,
        builder: ConfigBuilder<DefaultState>,
    ) -> Result<ConfigBuilder<DefaultState>> {
        builder
            .set_default("encoder.system", defaults::SYSTEM_NAME)?
            .set_default("encoder.input", "")
            .map_err(Into::into)
    }

    fn apply_overrides(
        &self,
        builder: ConfigBuilder<DefaultState>,
    ) -> Result<ConfigBuilder<DefaultState>> {
        let mut builder = builder;
        if let Some(ref system) = self.system {
            builder = builder.set_override("encoder.system", system.clone())?;
        }
        builder = builder.set_override("encoder.input", self.input.clone())?;
        Ok(builder)
    }
}

#[async_trait]
impl CommandExecutor for EncodeArgs {
    async fn execute(&self, config: &AppConfig, container: &Container) -> Result<()> {
        let config = config.encoder.as_ref().expect("Encoder config not set");
        let repo = container.create_dict_repo("demo_pl").await?;

        debug!("Running encoder with config {:?}", config);

        let system_encoder: Box<dyn SystemEncoder> = match config.system {
            System::MajorPl | System::MajorEn => {
                let decoder = major::Decoder::new(match config.system {
                    System::MajorPl => major::rules_pl::get_rules(),
                    System::MajorEn => major::rules_en::get_rules(),
                    // _ => unreachable!(),
                });
                let stream = repo.stream_batches(100).await.unwrap();
                let lvmap = LenValueMap::from_stream(stream, &decoder).await.unwrap();
                Box::new(Encoder::new(lvmap))
            }
        };

        let result = system_encoder.encode(&config.input);

        match result {
            Ok(res) => {
                let json = serde_json::to_string_pretty(&res).expect("JSON serialization failed");
                println!("{}", json);
            }
            Err(e) => eprintln!("Error encoding: {:?}", e),
        }

        Ok(())
    }
}