use std::str;

use nom::branch::alt;
use nom::bytes::streaming::*;
use nom::combinator::*;
use nom::error::{ErrorKind, ParseError};
use nom::multi::*;
use nom::number::streaming::*;
use nom::sequence::{pair, preceded, terminated, tuple};
use nom::{Err, IResult, Parser};

use crate::messages::{
    ConfigEngineMessage::*, EngineMessage::*, KeystrokeAction::*, SyncedEngineMessage::*,
    UnorderedEngineMessage::*, *,
};

fn eof_slice<I>(i: I) -> IResult<I, I>
where
    I: nom::InputLength + Clone,
{
    if i.input_len() == 0 {
        Ok((i.clone(), i))
    } else {
        Err(Err::Error(nom::error::Error::new(i, ErrorKind::Eof)))
    }
}
fn unrecognized_message(input: &[u8]) -> IResult<&[u8], EngineMessage> {
    map(rest, |i: &[u8]| Unknown(i.to_owned()))(input)
}

fn string_tail(input: &[u8]) -> IResult<&[u8], String> {
    map_res(rest, str::from_utf8)(input).map(|(i, s)| (i, s.to_owned()))
}

fn length_without_timestamp(input: &[u8]) -> IResult<&[u8], usize> {
    map_opt(rest_len, |l| if l > 2 { Some(l - 2) } else { None })(input)
}

fn synced_message(input: &[u8]) -> IResult<&[u8], SyncedEngineMessage> {
    alt((
        alt((
            map(tag(b"L"), |_| Left(Press)),
            map(tag(b"l"), |_| Left(Release)),
            map(tag(b"R"), |_| Right(Press)),
            map(tag(b"r"), |_| Right(Release)),
            map(tag(b"U"), |_| Up(Press)),
            map(tag(b"u"), |_| Up(Release)),
            map(tag(b"D"), |_| Down(Press)),
            map(tag(b"d"), |_| Down(Release)),
            map(tag(b"Z"), |_| Precise(Press)),
            map(tag(b"z"), |_| Precise(Release)),
            map(tag(b"A"), |_| Attack(Press)),
            map(tag(b"a"), |_| Attack(Release)),
            map(tag(b"N"), |_| NextTurn),
            map(tag(b"j"), |_| LongJump),
            map(tag(b"J"), |_| HighJump),
            map(tag(b"S"), |_| Switch),
        )),
        alt((
            map(tag(b","), |_| Skip),
            map(tag(b"1"), |_| Timer(1)),
            map(tag(b"2"), |_| Timer(2)),
            map(tag(b"3"), |_| Timer(3)),
            map(tag(b"4"), |_| Timer(4)),
            map(tag(b"5"), |_| Timer(5)),
            map(tuple((tag(b"p"), be_i24, be_i24)), |(_, x, y)| Put(x, y)),
            map(tuple((tag(b"P"), be_i24, be_i24)), |(_, x, y)| {
                CursorMove(x, y)
            }),
            map(preceded(tag(b"f"), string_tail), TeamControlLost),
            map(preceded(tag(b"g"), string_tail), TeamControlGained),
            map(preceded(tag(b"t"), be_u8), Taunt),
            map(preceded(tag(b"w"), be_u8), SetWeapon),
            map(preceded(tag(b"~"), be_u8), Slot),
            map(tag(b"+"), |_| Heartbeat),
        )),
    ))(input)
}

fn unsynced_message(input: &[u8]) -> IResult<&[u8], UnsyncedEngineMessage> {
    alt((
        map(
            preceded(tag(b"F"), string_tail),
            UnsyncedEngineMessage::TeamControlLost,
        ),
        map(
            preceded(tag(b"G"), string_tail),
            UnsyncedEngineMessage::TeamControlGained,
        ),
        map(
            preceded(tag(b"h"), string_tail),
            UnsyncedEngineMessage::HogSay,
        ),
        map(
            preceded(tag(b"s"), string_tail),
            UnsyncedEngineMessage::ChatMessage,
        ),
        map(
            preceded(tag(b"b"), string_tail),
            UnsyncedEngineMessage::TeamMessage,
        ),
    ))(input)
}

fn unordered_message(input: &[u8]) -> IResult<&[u8], UnorderedEngineMessage> {
    alt((
        map(tag(b"?"), |_| Ping),
        map(tag(b"!"), |_| Pong),
        map(preceded(tag(b"E"), string_tail), Error),
        map(preceded(tag(b"W"), string_tail), Warning),
        map(preceded(tag(b"M"), string_tail), GameSetupChecksum),
        map(tag(b"o"), |_| StopSyncing),
        map(tag(b"I"), |_| PauseToggled),
    ))(input)
}

fn config_message(input: &[u8]) -> IResult<&[u8], ConfigEngineMessage> {
    alt((
        map(tag(b"C"), |_| ConfigRequest),
        map(preceded(tag(b"eseed "), string_tail), SetSeed),
        map(preceded(tag(b"e$feature_size "), string_tail), |s| {
            SetFeatureSize(s.parse().unwrap_or_default())
        }),
    ))(input)
}

fn timestamped_message(input: &[u8]) -> IResult<&[u8], (SyncedEngineMessage, u16)> {
    terminated(pair(synced_message, be_u16), eof_slice)(input)
}
fn unwrapped_message(input: &[u8]) -> IResult<&[u8], EngineMessage> {
    alt((
        map(timestamped_message, |(m, t)| {
            EngineMessage::Synced(m, t as u32)
        }),
        map(tag(b"#"), |_| Synced(TimeWrap, 65535u32)),
        map(unordered_message, Unordered),
        map(unsynced_message, Unsynced),
        map(config_message, Config),
        unrecognized_message,
    ))(input)
}

fn length_specifier(input: &[u8]) -> IResult<&[u8], u16> {
    alt((
        verify(map(take(1usize), |a: &[u8]| a[0] as u16), |&l| l < 64),
        map(take(2usize), |a: &[u8]| {
            (a[0] as u16 - 64) * 256 + a[1] as u16 + 64
        }),
    ))(input)
}

fn empty_message(input: &[u8]) -> IResult<&[u8], EngineMessage> {
    map(tag(b"\0"), |_| Empty)(input)
}

fn non_empty_message(input: &[u8]) -> IResult<&[u8], EngineMessage> {
    map_parser(length_data(length_specifier), unwrapped_message)(input)
}

fn message(input: &[u8]) -> IResult<&[u8], EngineMessage> {
    alt((empty_message, non_empty_message))(input)
}

pub fn extract_messages(input: &[u8]) -> IResult<&[u8], Vec<EngineMessage>> {
    many0(complete(message))(input)
}

pub fn extract_message(buf: &[u8]) -> Option<(usize, EngineMessage)> {
    let parse_result = message(buf);
    match parse_result {
        Ok((tail, msg)) => {
            let consumed = buf.len() - tail.len();

            Some((consumed, msg))
        }
        Err(Err::Incomplete(_)) => None,
        Err(Err::Error(_)) | Err(Err::Failure(_)) => unreachable!(),
    }
}

#[cfg(test)]
mod tests {
    use crate::messages::UnsyncedEngineMessage::*;
    use crate::parser::*;

    #[test]
    fn parse_length() {
        assert_eq!(length_specifier(b"\x01"), Ok((&b""[..], 1)));
        assert_eq!(length_specifier(b"\x00"), Ok((&b""[..], 0)));
        assert_eq!(length_specifier(b"\x3f"), Ok((&b""[..], 63)));
        assert_eq!(length_specifier(b"\x40\x00"), Ok((&b""[..], 64)));
        assert_eq!(
            length_specifier(b"\xff\xff"),
            Ok((&b""[..], EngineMessage::MAX_LEN))
        );
    }

    #[test]
    fn parse_synced_messages() {
        assert_eq!(
            message(b"\x03L\x01\x02"),
            Ok((&b""[..], Synced(Left(Press), 258)))
        );

        assert_eq!(message(b"\x01#"), Ok((&b""[..], Synced(TimeWrap, 65535))));

        assert_eq!(
            message(&vec![9, b'p', 255, 133, 151, 1, 0, 2, 0, 0]),
            Ok((&b""[..], Synced(Put(-31337, 65538), 0)))
        );
    }

    #[test]
    fn parse_unsynced_messages() {
        assert_eq!(
            message(b"\x06shello"),
            Ok((&b""[..], Unsynced(ChatMessage(String::from("hello")))))
        );
    }

    #[test]
    fn parse_incorrect_messages() {
        assert_eq!(message(b"\x00"), Ok((&b""[..], Empty)));
        assert_eq!(message(b"\x01\x00"), Ok((&b""[..], Unknown(vec![0]))));

        // garbage after correct message
        assert_eq!(
            message(b"\x04La\x01\x02"),
            Ok((&b""[..], Unknown(vec![76, 97, 1, 2])))
        );
    }

    #[test]
    fn parse_config_messages() {
        assert_eq!(message(b"\x01C"), Ok((&b""[..], Config(ConfigRequest))));
    }

    #[test]
    fn parse_test_general() {
        assert_eq!(string_tail(b"abc"), Ok((&b""[..], String::from("abc"))));

        assert_eq!(extract_message(b"\x02#"), None);

        assert_eq!(synced_message(b"L"), Ok((&b""[..], Left(Press))));

        assert_eq!(
            extract_message(b"\x01#"),
            Some((2, Synced(TimeWrap, 65535)))
        );
    }
}