use reqwest::blocking;

const COMMANDS : [&str; 7] = [
    "help",
    "version",
    "show",
    "add",
    "rm",
    "mv",
    "setdb"
];

fn dbgprint(s: &str) {
    if false {
        println!("{}", s);
    }   
}

// todo:
// * add desc
// * add multiple tags support
// * add "inbox default"
// * add nice layout printout
fn help_menu() -> String {
    let cmds = vec![
        "./todo help | --help | -h",
        "./todo version | --version",
        "./todo show [-b]" ,
        "./todo add taskname",
        "./todo rm taskname",
        // "./todo add taskname [desc] [tag]          (use to edit, collision --force)",
        // "./todo add -b bucketname [category]          (used to edit, collision --force)",
        // "./todo rm -b bucketname                      (also removes tasks)",
        // "./todo rm -b bucketname -s target-bucket",
        // "./todo mv taskname bucketname",
        // "./todo mv bucketname newbucketname"
        // "./todo setdb filepath",
    ];

    cmds.join("\n")
}

fn send_get(url: &String) -> Result<String, String> {
    println!("Sending get: {}", url);
    let body = match reqwest::blocking::get(url) {
        Ok(res) => {
            if let Ok(inner) = res.text() {
                inner
            } else {
                format!("error getting test")  
            }
        }
        Err(err) => format!("Failed to get")
    };
    Ok(body)
}

fn send_post(url: &String, data: &String) -> Result<String, String> {
    let client = reqwest::blocking::Client::new();
    if let Ok(res) = client.post(url)
        .body(data.clone())
        .send() {
        return Ok(format!(""))
    }
    Err(format!("failed to post"))
}

struct Command {
    cmd: String,
    args: Vec<String>, 
}

fn parser(args: Vec<String>) -> Result<Command,String> {
    if !COMMANDS.contains(&&args[1].as_str()) {
        println!("UNKNOWN COMMAND, try one of the following");
        return Err(format!("Unknown command"));
    }

    Ok(Command { cmd: args[1].clone(), args: args.to_vec()})
}

fn handler(command: &Command, url: &String) -> Result<String,String> {
    // these commands do not require db access
    if command.cmd == "help"
            || command.args.contains(&String::from("--help"))
            || command.args.contains(&String::from("-h")) {
        return Ok(help_menu());
    } else if command.cmd == "version" 
            || command.args.contains(&String::from("--version")) {
        let version = env!("CARGO_PKG_VERSION");
        return Ok(format!("{}", version));
    } 

    // probably need to hit the server
    if command.cmd == "show" { 
        let url_with_query = url.clone() + &format!("?action=show");
        send_get(&url_with_query)
    } else if command.cmd == "add" {
        if command.args.len() < 3 {
            return Err(format!("ERR: Not enough args for adding")); 
        }
        let name = &command.args[2];
        // let mut bucket = "";
        // if command.args.len() > 3 {
        //     bucket = &command.args[3];
        // }
        let url_with_query = url.clone() + &format!("?action=add");
        send_post(&url_with_query, &format!("{}", name))
    } else if command.cmd == "rm" {
        if command.args.len() < 3 {
            println!("ERR: Not enough args for removing"); 
            return Err(format!("Err: Not enough args for removing"));
        }
        let name = &command.args[2];
        let url_with_query = url.clone() + &format!("?action=rm");
        send_post(&url_with_query, &format!("{}", name))
    } else {
        Ok(help_menu())
    }
}

fn main() {
    let args : Vec<String> = std::env::args().collect();
    let url = format!("http://localhost:8001/");
    let parsed = parser(args);
    if let Ok(cmd) = parsed {
        println!("{}", handler(&cmd, &url).unwrap());
        return;        
    }
    println!("parsing failed");
    println!("{}", help_menu());
}