use clap::{CommandFactory, Parser};
use directories::ProjectDirs;
use figment::{
    Figment,
    providers::{Env, Serialized},
};
use lib_sync_core::task_manager::{TaskManager, TaskStatus};
use cli::config::{Command, Config};
use cli::{Error, Result};
use std::fs::File;
use tabled::Table;
use tracing_subscriber;
use crate::external_interface::DocumentPayload;

mod external_interface;

#[tokio::main]
async fn main() -> Result<()> {
    let cli = Config::parse();
    let args: Config = Figment::new()
        .merge(Serialized::defaults(&cli))
        .merge(Env::prefixed("APP_"))
        .extract()?;

    tracing_subscriber::fmt()
        .with_max_level(args.log_level())
        .init();

    run(&cli.command).await?;

    Ok(())
}

async fn run(command: &Command) -> Result<()> {
    let project_dir = ProjectDirs::from("", "", "synchronizator_readwise").ok_or(
        lib_sync_core::error::Error::Unhandled("Could not get standard directories"),
    )?;

    let task_manager = TaskManager::new(project_dir.data_dir()).await?;

    match command {
        Command::LoadTasks { path } => {
            let file = File::open(path).map_err(|_| {
                Error::Runtime(format!(
                    r#"The file "{}" could not be open"#,
                    path.display()
                ))
            })?;

            let documents: Vec<DocumentPayload> = serde_json::from_reader(file)?;

            task_manager.load_tasks(documents).await?;
        }
        Command::Query => {
            let tasks = task_manager
                .get_tasks::<DocumentPayload>(None, Some(25))
                .await?;

            println!("{}", Table::new(tasks));
        }
        Command::Run => {
            task_manager
                .run_tasks::<DocumentPayload>(|task| {
                    println!("{}", task.get_key());

                    TaskStatus::Completed
                })
                .await?;
        }
        Command::None => {
            Config::command().print_help()?;
        }
    }

    Ok(())
}