use nom::{

    branch::alt,

    bytes::complete::{escaped_transform, is_not, tag, take_while, take_while1},

    character::{is_alphanumeric, is_digit, is_space},

    combinator::{map, map_res},

    sequence::{delimited, pair, preceded, separated_pair, terminated},

    ExtendInto, IResult,

};

use std::{

    collections::HashMap,

    fmt::{Display, Error, Formatter},

};

type HaskellResult<'a, T> = IResult<&'a [u8], T>;

#[derive(Debug, PartialEq)]

pub enum HaskellValue {

    Boolean(bool),

    Number(u8),

    String(String),

    Tuple(Vec<HaskellValue>),

    List(Vec<HaskellValue>),

    AnonStruct {

        name: String,

        fields: Vec<HaskellValue>,

    },

    Struct {

        name: String,

        fields: HashMap<String, HaskellValue>,

    },

}

impl HaskellValue {

    pub fn to_number(&self) -> Option<u8> {

        match self {

            HaskellValue::Number(value) => Some(*value),

            _ => None,

        }

    }

    pub fn into_number(self) -> Option<u8> {

        match self {

            HaskellValue::Number(value) => Some(value),

            _ => None,

        }

    }

    pub fn to_string(&self) -> Option<&str> {

        match self {

            HaskellValue::String(value) => Some(value),

            _ => None,

        }

    }

    pub fn into_string(self) -> Option<String> {

        match self {

            HaskellValue::String(value) => Some(value),

            _ => None,

        }

    }

    pub fn into_list(self) -> Option<Vec<HaskellValue>> {

        match self {

            HaskellValue::List(items) => Some(items),

            _ => None,

        }

    }

    pub fn into_tuple(self) -> Option<Vec<HaskellValue>> {

        match self {

            HaskellValue::Tuple(items) => Some(items),

            _ => None,

        }

    }

    pub fn into_anon_struct(self) -> Option<(String, Vec<HaskellValue>)> {

        match self {

            HaskellValue::AnonStruct { name, fields } => Some((name, fields)),

            _ => None,

        }

    }

    pub fn into_struct(self) -> Option<(String, HashMap<String, HaskellValue>)> {

        match self {

            HaskellValue::Struct { name, fields } => Some((name, fields)),

            _ => None,

        }

    }

}

fn write_sequence(

    f: &mut Formatter<'_>,

    brackets: &[u8; 2],

    mut items: std::slice::Iter<HaskellValue>,

) -> Result<(), Error> {

    write!(f, "{}", brackets[0] as char)?;

    while let Some(value) = items.next() {

        write!(f, "{}", value)?;

        if !items.as_slice().is_empty() {

            write!(f, ", ")?;

        }

    }

    if brackets[1] != b'\0' {

        write!(f, "{}", brackets[1] as char)

    } else {

        Ok(())

    }

}

fn write_text(f: &mut Formatter<'_>, text: &str) -> Result<(), Error> {

    write!(f, "\"")?;

    for c in text.chars() {

        if c.is_ascii() && !(c as u8).is_ascii_control() {

            write!(f, "{}", c)?;

        } else {

            let mut bytes = [0u8; 4];

            let size = c.encode_utf8(&mut bytes).len();

            for byte in &bytes[0..size] {

                write!(f, "\\{:03}", byte)?;

            }

        }

    }

    write!(f, "\"")

}

impl Display for HaskellValue {

    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {

        match self {

            HaskellValue::Boolean(value) => write!(f, "{}", if *value { "True" } else { "False" }),

            HaskellValue::Number(value) => write!(f, "{}", value),

            HaskellValue::String(value) => write_text(f, value),

            HaskellValue::Tuple(items) => write_sequence(f, b"()", items.iter()),

            HaskellValue::List(items) => write_sequence(f, b"[]", items.iter()),

            HaskellValue::AnonStruct { name, fields } => {

                write!(f, "{} ", name)?;

                write_sequence(f, b" \0", fields.iter())

            }

            HaskellValue::Struct { name, fields } => {

                write!(f, "{} {{", name)?;

                let fields = fields.iter().collect::<Vec<_>>();

                let mut items = fields.iter();

                while let Some((field_name, value)) = items.next() {

                    write!(f, "{} = {}", field_name, value)?;

                    if !items.as_slice().is_empty() {

                        write!(f, ", ")?;

                    }

                }

                write!(f, "}}")

            }

        }

    }

}

fn comma(input: &[u8]) -> HaskellResult<&[u8]> {

    delimited(take_while(is_space), tag(","), take_while(is_space))(input)

}

fn surrounded<'a, P, O>(

    prefix: &'static str,

    suffix: &'static str,

    parser: P,

) -> impl Fn(&'a [u8]) -> HaskellResult<'a, O>

where

    P: Fn(&'a [u8]) -> HaskellResult<'a, O>,

{

    move |input| {

        delimited(

            delimited(take_while(is_space), tag(prefix), take_while(is_space)),

            |i| parser(i),

            delimited(take_while(is_space), tag(suffix), take_while(is_space)),

        )(input)

    }

}

fn boolean(input: &[u8]) -> HaskellResult<HaskellValue> {

    map(

        alt((map(tag("True"), |_| true), map(tag("False"), |_| false))),

        HaskellValue::Boolean,

    )(input)

}

fn number_raw(input: &[u8]) -> HaskellResult<u8> {

    use std::str::FromStr;

    map_res(take_while(is_digit), |s| {

        std::str::from_utf8(s)

            .map_err(|_| ())

            .and_then(|s| u8::from_str(s).map_err(|_| ()))

    })(input)

}

fn number(input: &[u8]) -> HaskellResult<HaskellValue> {

    map(number_raw, HaskellValue::Number)(input)

}

enum Escape {

    Empty,

    Byte(u8),

}

impl ExtendInto for Escape {

    type Item = u8;

    type Extender = Vec<u8>;

    fn new_builder(&self) -> Self::Extender {

        Vec::new()

    }

    fn extend_into(&self, acc: &mut Self::Extender) {

        if let Escape::Byte(b) = self {

            acc.push(*b);

        }

    }

}

impl Extend<Escape> for Vec<u8> {

    fn extend<T: IntoIterator<Item = Escape>>(&mut self, iter: T) {

        for item in iter {

            item.extend_into(self);

        }

    }

}

fn string_escape(input: &[u8]) -> HaskellResult<Escape> {

    use Escape::*;

    alt((

        map(number_raw, |n| Byte(n)),

        alt((

            map(tag("\\"), |_| Byte(b'\\')),

            map(tag("\""), |_| Byte(b'\"')),

            map(tag("'"), |_| Byte(b'\'')),

            map(tag("n"), |_| Byte(b'\n')),

            map(tag("r"), |_| Byte(b'\r')),

            map(tag("t"), |_| Byte(b'\t')),

            map(tag("a"), |_| Byte(b'\x07')),

            map(tag("b"), |_| Byte(b'\x08')),

            map(tag("v"), |_| Byte(b'\x0B')),

            map(tag("f"), |_| Byte(b'\x0C')),

            map(tag("&"), |_| Empty),

            map(tag("NUL"), |_| Byte(b'\x00')),

            map(tag("SOH"), |_| Byte(b'\x01')),

            map(tag("STX"), |_| Byte(b'\x02')),

            map(tag("ETX"), |_| Byte(b'\x03')),

            map(tag("EOT"), |_| Byte(b'\x04')),

            map(tag("ENQ"), |_| Byte(b'\x05')),

            map(tag("ACK"), |_| Byte(b'\x06')),

        )),

        alt((

            map(tag("SO"), |_| Byte(b'\x0E')),

            map(tag("SI"), |_| Byte(b'\x0F')),

            map(tag("DLE"), |_| Byte(b'\x10')),

            map(tag("DC1"), |_| Byte(b'\x11')),

            map(tag("DC2"), |_| Byte(b'\x12')),

            map(tag("DC3"), |_| Byte(b'\x13')),

            map(tag("DC4"), |_| Byte(b'\x14')),

            map(tag("NAK"), |_| Byte(b'\x15')),

            map(tag("SYN"), |_| Byte(b'\x16')),

            map(tag("ETB"), |_| Byte(b'\x17')),

            map(tag("CAN"), |_| Byte(b'\x18')),

            map(tag("EM"), |_| Byte(b'\x19')),

            map(tag("SUB"), |_| Byte(b'\x1A')),

            map(tag("ESC"), |_| Byte(b'\x1B')),

            map(tag("FS"), |_| Byte(b'\x1C')),

            map(tag("GS"), |_| Byte(b'\x1D')),

            map(tag("RS"), |_| Byte(b'\x1E')),

            map(tag("US"), |_| Byte(b'\x1F')),

            map(tag("DEL"), |_| Byte(b'\x7F')),

        )),

    ))(input)

}

fn string_content(mut input: &[u8]) -> HaskellResult<String> {

    map_res(

        escaped_transform(is_not("\"\\"), '\\', string_escape),

        |bytes| String::from_utf8(bytes).map_err(|_| ()),

    )(input)

}

fn string(input: &[u8]) -> HaskellResult<HaskellValue> {

    map(

        delimited(tag("\""), string_content, tag("\"")),

        HaskellValue::String,

    )(input)

}

fn tuple(input: &[u8]) -> HaskellResult<HaskellValue> {

    map(

        surrounded("(", ")", separated_list(comma, value)),

        HaskellValue::Tuple,

    )(input)

}

fn list(input: &[u8]) -> HaskellResult<HaskellValue> {

    map(

        surrounded("[", "]", separated_list(comma, value)),

        HaskellValue::List,

    )(input)

}

fn identifier(input: &[u8]) -> HaskellResult<String> {

    map_res(take_while1(is_alphanumeric), |s| {

        std::str::from_utf8(s).map_err(|_| ()).map(String::from)

    })(input)

}

fn named_field(input: &[u8]) -> HaskellResult<(String, HaskellValue)> {

    separated_pair(

        identifier,

        delimited(take_while(is_space), tag("="), take_while(is_space)),

        value,

    )(input)

}

fn structure(input: &[u8]) -> HaskellResult<HaskellValue> {

    alt((

        map(

            pair(

                identifier,

                surrounded("{", "}", separated_list(comma, named_field)),

            ),

            |(name, mut fields)| HaskellValue::Struct {

                name,

                fields: fields.drain(..).collect(),

            },

        ),

        map(

            pair(

                identifier,

                preceded(

                    take_while(is_space),

                    many0(terminated(value, take_while(is_space))),

                ),

            ),

            |(name, mut fields)| HaskellValue::AnonStruct {

                name: name.clone(),

                fields,

            },

        ),

    ))(input)

}

fn value(input: &[u8]) -> HaskellResult<HaskellValue> {

    alt((boolean, number, string, tuple, list, structure))(input)

}

#[inline]

pub fn parse(input: &[u8]) -> HaskellResult<HaskellValue> {

    delimited(take_while(is_space), value, take_while(is_space))(input)

}

mod test {

    use super::*;

    #[test]

    fn terminals() {

        use HaskellValue::*;

        matches!(number(b"127"), Ok((_, Number(127))));

        matches!(number(b"adas"), Err(nom::Err::Error(_)));

        assert_eq!(

            string(b"\"Hail \\240\\159\\166\\148!\""),

            Ok((&b""[..], String("Hail \u{1f994}!".to_string())))

        );

    }

    #[test]

    fn sequences() {

        use HaskellValue::*;

        let value = Tuple(vec![

            Number(64),

            String("text\t1".to_string()),

            List(vec![Number(1), Number(2), Number(3)]),

        ]);

        assert_eq!(

            tuple(b"(64, \"text\\t1\", [1 , 2, 3])"),

            Ok((&b""[..], value))

        );

    }

    #[test]

    fn structures() {

        use HaskellValue::*;

        let value = Struct {

            name: "Hog".to_string(),

            fields: vec![

                ("name".to_string(), String("\u{1f994}".to_string())),

                ("health".to_string(), Number(100)),

            ]

            .drain(..)

            .collect(),

        };

        assert_eq!(

            structure(b"Hog {name = \"\\240\\159\\166\\148\", health = 100}"),

            Ok((&b""[..], value))

        );

        let value = AnonStruct {

            name: "Hog".to_string(),

            fields: vec![Boolean(true), Number(100), String("\u{1f994}".to_string())],

        };

        assert_eq!(

            structure(b"Hog True 100 \"\\240\\159\\166\\148\""),

            Ok((&b""[..], value))

        );

    }

}