use nom::{
    bytes::streaming::is_not,
    character::streaming::char,
    combinator::{complete, cut, map_res},
    multi::many0,
    sequence::terminated,
};

pub fn parse(input: &[u8]) -> IResult<&[u8], Vec<CommandRequest>> {
    use serde_json::from_slice;
    many0(complete(terminated(
        map_res(is_not("\0"), from_slice::<CommandRequest>),
        char('\0'),
    )))(input)
}

pub fn parse_several_users(input: &str) -> IResult<&str, Vec<User>> {
    many0(complete(terminated(
        map_res(is_not("\n"), serde_json::from_str::<User>),
        nom::character::complete::char('\n'),
    )))(input)
}

pub struct CustomError {
    kind: ErrorKind,
    serde_json_error: Option<serde_json::Error>,
}

impl FromExternalError<&str, serde_json::Error> for CustomError {
    // boilerplate
}

impl nom::error::ParseError<&str> for CustomError {
    // boilerplate
}

pub fn parse_one_user(input: &str) -> IResult<&str, User, CustomError> {
    let (i, json_data) = is_not("\n")(input)?;

    let user = match serde_json::from_str::<User>(json_data) {
        Ok(user) => user,
        Err(serde_error) => {
            return Err(nom::Err::Failure(CustomError::from_external_error(
                input,
                ErrorKind::MapRes,
                serde_error,
            )))
        }
    };

    let (next_input, _) = nom::character::complete::char('\n')(i)?;

    Ok((next_input, user))
}

pub fn parse_several_users(input: &str) -> IResult<&str, Vec<User>, CustomError> {
    many0(parse_one_user)(input)
}