// See LICENSE file for copyright and license details.

//! Parse the socket info.
//!
//! For now this module will have 2 methods. One for inmediate execution and
//! other for add a bindind.

use x11::xlib;
use x11::keysym;

use command::*;
use dotwm::DotWM;

fn str_to_modifier<'a>(s: &'a str) -> Result<u32, ()> {
    match s {
        "Mod1Mask" => Ok(xlib::Mod4Mask),
        "Mod2Mask" => Ok(xlib::Mod4Mask),
        "Mod3Mask" => Ok(xlib::Mod4Mask),
        "Mod4Mask" => Ok(xlib::Mod4Mask),
        "ControlMask" => Ok(xlib::ControlMask),
        "ShiftMask" => Ok(xlib::ShiftMask),
        _ => Err(()),
    }
}

fn str_to_key<'a>(s: &'a str) -> Result<u32, ()> {
    match s {
        "h" => Ok(keysym::XK_h),
        "j" => Ok(keysym::XK_j),
        "k" => Ok(keysym::XK_k),
        "l" => Ok(keysym::XK_l),
        "Tab" => Ok(keysym::XK_Tab),
        "p" => Ok(keysym::XK_p),
        "Return" => Ok(keysym::XK_Return),
        "q" => Ok(keysym::XK_q),
        _ => Err(()),
    }
}

fn str_to_func<'a>(s: &'a str) -> Result<ExecFn,()> {
    match s {
        "exec" => Ok(exec),
        "move_win" => Ok(move_win),
        "resize_win" => Ok(resize_win),
        _ => Err(()),
    }
}

pub fn parse<'a>(dotwm: &mut DotWM, bindings: &mut BindingHash, input: &'a str) -> &'a str {
    let args: Vec<&str> = input.split_whitespace().collect();

    match args.first() {
        Some(cmd) => {
            match cmd {
                &"add-binding" => {
                     let modifier = str_to_modifier(args[1]).unwrap();
                     let key = str_to_key(args[2]).unwrap();
                     let func = str_to_func(args[3]).unwrap();
                     let arguments = &args[4..];

                     add_binding(dotwm, bindings, key, modifier, func, arguments);
                },
                &"exec" => { println!("exec"); },
                _ => { println!("anotherthing ._."); },
            }
        },
        None => println!("error"),
    }
    "ok"
}