use clap::{Parser, Subcommand};
use comfy_table::Table;
use std::process;
use thiserror::Error as TeError;
use wfassoc::{Error as WfError, FileExt, Scope, View};

// region: Basic Types

/// All errors occurs in this executable.
#[derive(TeError, Debug)]
enum Error {
    /// Error from wfassoc core.
    #[error("{0}")]
    Core(#[from] WfError),
}

/// Result type used in this executable.
type Result<T> = std::result::Result<T, Error>;

// endregion

// region: Command Line Parser

/// Simple program to manage Windows file associations
#[derive(Parser)]
#[command(name = "Windows File Association Operator", version, about)]
struct Cli {
    /// The toml file introducing the complete program
    #[arg(
        short = 'c',
        long = "config",
        value_name = "PROG_CONFIG",
        required = true
    )]
    config_file: String,

    /// The scope where wfassoc operate
    #[arg(short = 'f', long = "for", value_name = "TARGET", value_enum, default_value_t = ForTarget::User)]
    for_which: ForTarget,

    #[command(subcommand)]
    command: Commands,
}

#[derive(clap::ValueEnum, Clone)]
enum ForTarget {
    #[value(name = "user")]
    User,
    #[value(name = "system")]
    System,
}

// impl From<ForTarget> for RegisterKind {
//     fn from(target: ForTarget) -> Self {
//         match target {
//             ForTarget::User => RegisterKind::User,
//             ForTarget::System => RegisterKind::System,
//         }
//     }
// }

#[derive(Subcommand)]
enum Commands {
    /// Register the program
    #[command(name = "register")]
    Register,
    /// Unregister the program
    #[command(name = "unregister")]
    Unregister,
    /// Query file associations
    #[command(name = "query")]
    Query,
}

// endregion

// region: Correponding Runner

fn run_register(cli: Cli) -> Result<()> {
    // let program = Program::new();
    // let kind: RegisterKind = cli.for_which.into();
    // program.register(kind)?;
    Ok(())
}

fn run_unregister(cli: Cli) -> Result<()> {
    // let program = Program::new();
    // program.unregister()?;
    Ok(())
}

fn run_query(cli: Cli) -> Result<()> {
    let exts = [
        ".jpg", ".jfif", ".gif", ".bmp", ".png", ".ico", ".jpeg", ".tif", ".tiff", ".webp", ".svg",
        ".kra", ".xcf", ".avif", ".qoi", ".apng", ".exr",
    ];

    for ext in exts.iter().map(|e| FileExt::new(e).unwrap()) {
        if let Some(ext_assoc) = ext.query(View::Hybrid) {
            println!("{:?}", ext_assoc)
        }
    }

    // let mut table = Table::new();
    // table.set_header(["Extension", "Default Open", "Open With"]);
    // for ext in exts.iter().map(|e| FileExt::new(e).unwrap()) {
    //     if let Some(ext_assoc) = ext.query(View::Hybrid) {
    //         if ext_assoc.len_open_with_progid() == 0 {
    //             table.add_row([ext.to_string().as_str(), ext_assoc.get_default(), ""]);
    //         } else {
    //             for (i, open_with_entry) in ext_assoc.iter_open_with_progids().enumerate() {
    //                 if i == 0 {
    //                     table.add_row([
    //                         ext.to_string().as_str(),
    //                         ext_assoc.get_default(),
    //                         open_with_entry,
    //                     ]);
    //                 } else {
    //                     table.add_row(["", "", open_with_entry]);
    //                 }
    //             }
    //         }
    //     } else {
    //         table.add_row([ext.to_string().as_str(), "", ""]);
    //     }
    // }
    // println!("{table}");

    // let program = Program::new();
    // program.query()?;
    //println!("Has privilege: {}", wfassoc::has_privilege());
    Ok(())
}

// endregion

fn main() {
    let cli = Cli::parse();

    let rv = match &cli.command {
        Commands::Register => run_register(cli),
        Commands::Unregister => run_unregister(cli),
        Commands::Query => run_query(cli),
    };
    rv.unwrap_or_else(|e| {
        eprintln!("Runtime error: {}.", e);
        process::exit(1)
    });
}