// 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;

use nom::{IResult,alpha,multispace};
use nom::IResult::*;
use std::str;

named!(token<&str>,
       map_res!(
           alpha, str::from_utf8));

fn slice2str(input: Vec<&[u8]>) -> Vec<&str> {
    let res: Vec<&str> = input.iter()
                              .map(|x| str::from_utf8(x).unwrap())
                              .collect();
    res
}

named!(args<Vec<&str> >,
       map!(
           separated_list!(
               multispace, alpha),
           slice2str));

fn 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 = 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"
}

#[test]
fn parse_test() {
    assert_eq!(token(&b"exec"[..]), IResult::Done(&b""[..], "exec"));
}

#[test]
fn parse_args() {
    assert_eq!(args(&b"hola chau"[..]),
               IResult::Done(&b""[..], vec!["hola", "chau"]));
}