use structopt::StructOpt;
use u_lib::{
    api::ClientHandler,
    models::JobMeta
};
use std::path::PathBuf;
use uuid::Uuid;

const DELIM: &'static str = "*************\n";

#[derive(StructOpt, Debug)]
struct Args {
    #[structopt(subcommand)]
    cmd: Cmd
}

#[derive(StructOpt, Debug)]
enum Cmd {
    Agents(LD),
    Jobs(JobALD),
    Jobmap(JmALD)
}

#[derive(StructOpt, Debug)]
enum JobALD {
    Add {
        #[structopt(long, parse(try_from_str = parse_uuid))]
        agent: Option<Uuid>,

        #[structopt(subcommand)]
        cmd: JobCmd
    },
    #[structopt(flatten)]
    LD(LD)
}

#[derive(StructOpt, Debug)]
enum JobCmd {
    #[structopt(external_subcommand)]
    Cmd(Vec<String>)
}

#[derive(StructOpt, Debug)]
enum JmALD {
    Add {
        #[structopt(parse(try_from_str = parse_uuid))]
        agent_uid: Uuid,

        #[structopt(parse(try_from_str = parse_uuid))]
        job_uids: Vec<Uuid>
    },
    List {
        #[structopt(parse(try_from_str = parse_uuid))]
        uid: Option<Uuid>,

        #[structopt(short, long)]
        results: bool
    },
    Delete {
        #[structopt(parse(try_from_str = parse_uuid))]
        uid: Uuid
    }
}

#[derive(StructOpt, Debug)]
enum LD {
    List {
        #[structopt(parse(try_from_str = parse_uuid))]
        uid: Option<Uuid>,
    },
    Delete {
        #[structopt(parse(try_from_str = parse_uuid))]
        uid: Uuid
    }
}

fn parse_uuid(src: &str) -> Result<Uuid, String> {
    Uuid::parse_str(src).map_err(|e| e.to_string())
}

#[tokio::main]
async fn main() -> Result<(), &'static str> {
    let args: Args = Args::from_args();
    let cli_handler = ClientHandler::new(None)
        .password("123qwe".to_string());
    match args.cmd {
        Cmd::Agents(action) => match action {
            LD::List {uid} => cli_handler.get_agents(uid.as_ref())
                .await.unwrap().into_iter().for_each(|r| println!("{}{}", DELIM, r)),
            LD::Delete {uid} => {
                println!("{}", cli_handler.del(Some(&uid)).await.unwrap());
            }
        },
        Cmd::Jobs(action) => match action {
            JobALD::Add {cmd: JobCmd::Cmd(cmd), agent} => {
                let job = JobMeta::from_shell(cmd.join(" "));
                let job_uid = job.id;
                cli_handler.upload_jobs(&vec![job]).await.unwrap();
                if agent.is_some() {
                    cli_handler.set_jobs(&vec![job_uid], agent.as_ref()).await.unwrap()
                }
            },
            JobALD::LD(LD::List {uid}) => cli_handler.get_jobs(uid.as_ref())
                .await.unwrap().into_iter().for_each(|r| println!("{}{}", DELIM, r)),
            JobALD::LD(LD::Delete {uid}) => {
                println!("{}", cli_handler.del(Some(&uid)).await.unwrap())
            }
        }
        Cmd::Jobmap(action) => match action {
            JmALD::Add {agent_uid, job_uids} => cli_handler.set_jobs(&job_uids, Some(&agent_uid))
                .await.unwrap(),
            JmALD::List {uid, results} => if results {
                cli_handler.get_results(uid.as_ref())
                    .await.unwrap().into_iter().for_each(|r| println!("{}{}", DELIM, r))
            } else {
                cli_handler.get_agent_jobs(uid.as_ref())
                    .await.unwrap().into_iter().for_each(|r| println!("{}{}", DELIM, r))
            },
            JmALD::Delete {uid} => println!("{}", cli_handler.del(Some(&uid)).await.unwrap())
        }
    }
    Ok(())
}