use crate::error::{Error, ErrorKind};

use crate::error::*;

// Relays error back to a function which knowns the token. (chars indented relative to root key)
struct InnerBadIndent(usize);

impl InnerBadIndent {
    fn from_inner(token: &Token, line: Line) -> std::result::Result<u32, Error> {
        bad_indent
    
                    let indent = indent(
                        &mut root_indent,
                        line_start,
                        start_key
                    ).map_err(|err| err.from_inner(&token, line))?;
}

                Err(Error::new(ErrorKind::FirstTokenMustBeKey(token.to_string())))

                Err(first_token_must_be_key(token.to_string()))

                    return Err(Error::new(ErrorKind::NonRootNoIndent(

                    return Err(non_root_indent(

                    )))

                    ))

        if s == "" { return Err(Error::new(ErrorKind::EmptyString)) };

        if s == "" { return Err(empty_string()) };

                    ).map_err(|e| e.from_inner(&token, line))?;

                    ).map_err(|err| err.from_inner(&token, line))?;

                    return Err(Error::new(
                        ErrorKind::NoColonAfterKey(

                    return Err(
                        no_colon_after_key(

                    ));

                    );

                    return Err(Error::new(

                    return Err(

                    ));

                    )

                    return Err(Error::new(
                        ErrorKind::NoSpaceAfterKey)
                    );

                    return Err(non_space_after_key());

                    return Err(Error::new(
                        ErrorKind::IncompleteLine(

                    return Err(
                        incomplete_line(

                    ))

                    )

                    return Err(Error::new(
                        ErrorKind::IncompleteLine(

                    return Err(
                        incomplete_line(

                    ));

                    );

                    return Err(Error::new(
                        ErrorKind::ColonBeforeKey)
                    );

                    return Err(colon_before_key())

                    return Err(Error::new(
                        ErrorKind::ColonBeforeKey)
                    );

                    return Err(colon_before_key())

                    return Err(Error::new(
                        ErrorKind::NoSpaceAfterKey
                    ));

                    return Err(no_space_after_key())

                    return Err(Error::new(
                        ErrorKind::NoSpaceAfterKey)
                    );

                    return Err(no_space_after_key)

                return Err(Error::new(
                    ErrorKind::IncompleteCommentOrKey(

                return Err(
                    incomplete_comment_or_key(

                ));

                )

                return Err(Error::new(
                    ErrorKind::IncompleteLine(

                return Err(
                    incomplete_line(

                ));

                )

    start_key:      usize) -> Result<usize>

    start_key:      usize) -> std::result::Result<usize, InnerBadIndent>

                return Err(Error::new(
                    ErrorKind::InnerBadIndent(
                        chars_indent
                    )
                ));

                return Err(InnerBadIndent(chars_indent))

                        ErrorKind::EKeyFKeyValue

                        ErrorKind::Expected_key_found_keyvalue

                    | ErrorKind::EKeyFKeyValue => {

                    | ErrorKind::Expected_key_found_keyvalue => {

                    Some(i) => Err(Error::new(ErrorKind::EUniqueKeyValueFMany(String::from("todo"), *i))),

                    Some(i) => Err(Error::new(ErrorKind::Expected_unique_keyvalue_found_multi(String::from("todo"), *i))),

            Token::Key { .. } => Err(Error::new(ErrorKind::EKeyValueFKey)),

            Token::Key { .. } => Err(Error::new(ErrorKind::Expected_keyvalue_found_key)),

// `ErrorKind` uses only owned strings or copy types as parameters. This means
// that `Error`s in client code do not require a lifetime, which could cause
// trouble if the error is wrapped and passed around.

pub struct Error(pub Box<ErrorKind>);

pub struct Error(String);

impl Error {
    pub fn new(kind: ErrorKind) -> Error {
        Error(Box::new(kind))
    }

    pub fn kind(&self) -> ErrorKind {
        *self.0.clone()

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.0)

    // Maps InnerBadIndent to BadIndent
    pub fn from_inner<T: Display>(
        self,
        token: T,
        line: usize) -> Error
    {
        match self.kind() {
            ErrorKind::InnerBadIndent(indent) => {
                Error::new(ErrorKind::BadIndent(token.to_string(), line, indent))
            },
            _ => self,
        }
    }

#[derive(Clone, Debug)]
pub enum ErrorKind {
    // Can be used by client code.
    User(String),
    // Expected key, found key/value pair.
    EKeyFKeyValue,
    // Expected key/value pair, found key.
    EKeyValueFKey,
    // Expected a key/value pair, found many (token, pos)
    EUniqueKeyValueFMany(String, usize),
    EUniqueTokenFMany,
    // `FromStr(keyval, pos)
    FromStr(String, String),
    NoChildWithSegment(String, String, String),
    // Use adjective_noun for error names.
    EmptyString,
    // BadIndent(token as string, line, chars indented relative to root key)
    BadIndent(String, usize, usize),
    // Relays error back to a function which knowns the token.
    // InnerBadIndent(chars indented relative to root key)
    InnerBadIndent(usize),
    ColonBeforeKey,
    // FirstTokenMustBeKey(token as string)
    FirstTokenMustBeKey(String),
    // IncompleteCommentOrkey(token as string)
    IncompleteCommentOrKey(String, Line),
    // IncompleteLine(token as string)
    IncompleteLine(String, Line),
    // NoColonAfterKey(token as string)
    NoColonAfterKey(String),
    // Occurs if the top key of the keytree is different from the search segment.
    // BadFirstSegment(token, pos, key path)
    BadFirstSegment(String, String, String),
    // Occurs if a token other than the root token has zero indent.
    // NonRootNoIndent(token, line)
    NonRootNoIndent(String, Line),
    NoSpaceAfterKey,
    NoTokens,
    EmptyPath,

pub fn expected_key_found_keyvalue() -> Error {
    Error(String::from("[01] Expected [key:] but found [key: value]."))

// Equal if they are the same kind.
impl PartialEq for ErrorKind {
    fn eq(&self, other: &Self) -> bool {
        mem::discriminant(self) == mem::discriminant(other)
    }  

pub fn expected_keyvalue_found_key() -> Error {
    Error(String::from("[02] Expected [key: value] but found [key:]."))

impl StdError for Error {
    fn source(&self) -> Option<&(dyn StdError + 'static)> {
        match *self.0 {
            ErrorKind::User(_)                      => None,
            ErrorKind::EKeyFKeyValue                => None,
            ErrorKind::EKeyValueFKey                => None,
            ErrorKind::EUniqueKeyValueFMany(_,_)    => None,
            ErrorKind::EUniqueTokenFMany            => None,
            ErrorKind::FromStr(_, _)                => None,
            ErrorKind::NoChildWithSegment(_, _, _)  => None,
            ErrorKind::EmptyString                  => None,
            ErrorKind::BadIndent(_, _, _)           => None,
            ErrorKind::InnerBadIndent(_)            => None,
            ErrorKind::ColonBeforeKey               => None,
            ErrorKind::FirstTokenMustBeKey(_)       => None,
            ErrorKind::IncompleteCommentOrKey(_, _) => None,
            ErrorKind::IncompleteLine(_, _)         => None,
            ErrorKind::NoColonAfterKey(_)           => None,
            ErrorKind::BadFirstSegment(_, _, _)     => None,
            ErrorKind::NonRootNoIndent(_, _)        => None,
            ErrorKind::NoSpaceAfterKey              => None,
            ErrorKind::NoTokens                     => None,
    
            ErrorKind::EmptyPath                    => None,
        }
    }

pub fn expected_unique_found_multi(token: &Token, pos: usize) -> Error {
    Error(
        format!(
            "[03] Line {}, token {}. Expected unique token but found multiple tokens.",
            pos,
            token.to_string(),
        )
    )

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match &*self.0 {
            ErrorKind::User(msg) => {
                write!(
                    f, 
                    "Error: Client error: \"{}\".",
                    msg,
                )
            }
            ErrorKind::FromStr(token, pos) => {
                write!(
                    f,
                    "Error: Couldn't parse string  at {}: \"{}\".",
                    pos,
                    token, 
                )
            },
            ErrorKind::EKeyFKeyValue => {
                write!(f, "{}", "expected_key_found_key_value")
            },
            ErrorKind::EKeyValueFKey => {
                write!(f, "{}", "expected_key_value_found_key")
            },
            ErrorKind::EUniqueKeyValueFMany(token, pos) => {
                write!(
                    f,
                    "token: {}, pos: {}",
                    token,
                    pos,
                )
                //        "expected_unique_key_value_found_many")
            },
            ErrorKind::EUniqueTokenFMany        => {
                write!(f, "{}", "expected_unique_token_found_many")
            },
            ErrorKind::NoChildWithSegment(token, line, child)       => {
                write!(
                    f,
                    "Error: Tried to follow child segment \"{}\" but found line {}: \"{}\".",
                    child,
                    line,
                    token,
                )
            },
            ErrorKind::BadFirstSegment(token, line, path) => {
                write!(f,
                    "Err: Tried to follow segment \"{}\" but found line {}: \"{}\".",
                    path,
                    line,
                    token,
                )
            },
            ErrorKind::BadIndent(token, line, indent) => {
                write!(f,
                    "Indent of \"{}: {}\" on relative to root key is {} but must be multiple of 4.",
                    line,
                    token,
                    indent
                )
            },
            // ErrorKind::Bincode(ref err) => Some(err),
            ErrorKind::EmptyString              => {
                write!(f, "{}", "String is empty.")
            },
            ErrorKind::InnerBadIndent(_) => {
                write!(f, "bug")
            },
            ErrorKind::ColonBeforeKey           => {
                write!(f, "{}", "colon before key")
            },
            ErrorKind::FirstTokenMustBeKey(token) => {
                write!(f, "Expected first token to be key but was \"{}\"", token)
            },
            ErrorKind::IncompleteCommentOrKey(token, line) => {
                write!(
                    f,
                    "\"{}\" at line {} is an incomplete comment or key.",
                    token,
                    line,
                )
            },
            ErrorKind::IncompleteLine(token, line) => {
                write!(
                    f,
                    "\"{}\" at line {} is incomplete.",
                    token,
                    line,
                )
            },

pub fn expected_unique_token_found_multi() -> Error {
    Error(
        String::from("[04] Expected a unique token but found multiple.")
    )
}

            ErrorKind::NoColonAfterKey(token) => {
                write!(f, "Expected a colon after key \"{}\"", token)
            },

pub fn failed_to_parse_value(token: &Token, pos: usize) -> Error {
    Error(
        format!(
            "[05] Line {}, token {}. Failed to parse value.",
            pos,
            token.to_string(),
        )
    )
}

            ErrorKind::NonRootNoIndent(token, line) => {
                write!(
                    f,
                    "\"{}\" at line {} has zero indent.",
                    token,
                    line,
                )
            },

pub fn no_child_with_segment(a: &str, b: &str, c: &str) -> Error {
    Error(
        format!(
            "[06]"
        )
    )
}

            ErrorKind::NoSpaceAfterKey          => {
                write!(f, "{}", "no space after key")
            },

pub fn empty_string() -> Error {
    Error(String::from("String is empty."))
}

            ErrorKind::NoTokens                 => {
                write!(f, "{}", "no tokens")
            },

pub fn bad_indent(token: &Token, pos: usize, indent: usize) -> Error {
    Error(
        format!(
            "[07] Line {}, token {}. Indentation of {} is incorrect.",
            line,
            pos,
            indent,
        )
    )
}

            ErrorKind::EmptyPath                => {
                write!(f, "{}", "empty path")
            },

        }
    }

pub fn colon_before_key() -> Error {
    Error(String::from("Colon before key."))

#[cfg(test)]
mod test {
    use super::*;
    use crate::{KeyTree, KeyTreeRef};
    use std::convert::TryInto;

pub fn first_token_must_be_key(token: &Token) -> Error {
    Error(String::from("First token must be [key:]."
}

pub fn incomplete_comment_or_key(token: &Token, line: usize) -> Error {
    Error(String::from("Incomplete comment or key."))
}

    #[test]
    fn is_empty() {
        assert_eq!(
            KeyTree::parse("")
                .expect_err("")
                .kind(),
            ErrorKind::EmptyString,
        );
        assert_eq!(
            KeyTree::parse("")
                .expect_err("")
                .to_string(),
            "String is empty."    
        );
    }

pub fn incomplete_line(token: &Token, line: usize) -> Error {
    Error(String::from("Incomplete line."))
}

    #[test]
    fn first_token_is_kv() {
        assert_eq!(
            KeyTree::parse("key1: value")
                .expect_err("")
                .to_string(),
            "Expected first token to be key but was \"key1: value\"",
        )
    }

pub fn no_colon_after_key(token: &Token) -> Error {
    Error(String::from("No colon after key.")
}

    #[test]
    fn colon_before_key() {
        assert_eq!(
            KeyTree::parse("key1:\n    :key2")
                .expect_err("")
                .kind(),
            ErrorKind::ColonBeforeKey,
        )
    }
    
    #[test]
    fn incomplete_comment_or_key() {
        assert_eq!(
            KeyTree::parse("key:\n    / text")
                .expect_err("")
                .to_string(),
            "\"/\" at line 2 is an incomplete comment or key.",

pub fn bad_first_segment(token: &Token, pos: usize, key_path: &KeyPath) -> Error {
    Error(
        format!(
            "Bad first segment"

    }
    #[test]
    fn indented_comment_parses() {
        assert!(KeyTree::parse("key:\n    // comment").is_ok());
    }

}

    #[test]
    fn non_indented_comment_parses() {
        assert!(KeyTree::parse("key:\n// comment").is_ok());
    }
    
    #[test]
    fn line_finishes_in_key() {
        assert_eq!(
            KeyTree::parse("key\n")
                .expect_err("")
                .to_string(),
            "Line \"key\" is incomplete.",
        )
    }

pub fn non_root_has_zero_indent(token: &Token line: usize) -> Error {
    Error(String::from("Token other than root token as zero indent."))
}

    #[test]
    fn line_finishes_after_slash() {
        assert_eq!(
            KeyTree::parse("key:\n/")
                .expect_err("")
                .to_string(),
            "\"/\" at line 1 is an incomplete comment or key.",
        )
    }
    
    #[test]
    fn no_colon_after_key() {
        assert_eq!(
            KeyTree::parse("key1:\n    key2 value")
                .expect_err("")
                .to_string(),
            "Expected a colon after key \"key2\"",
        )
    }
    
    #[test]
    fn no_space_after_key() {
        assert_eq!(
            KeyTree::parse("key1:\n    key2:value")
                .expect_err("")
                .kind(),
            ErrorKind::NoSpaceAfterKey,
        )
    }
    
    #[derive(Debug)]
    struct TestU32(u32);
    
    impl<'a> TryInto<TestU32> for KeyTreeRef<'a> {
        type Error = Error;
    
        fn try_into(self) -> Result<TestU32, Error> {
            Ok(TestU32(self.at("key::val")?))
        }
    }
    
    #[test]
    fn expected_u32() {
        let kt = KeyTree::parse("key:\n    val: abc").unwrap();
        let t: Result<TestU32, Error> = kt.to_ref().try_into();
        if let Err(err) = t {
            assert_eq!(
                err.kind(),
                ErrorKind::FromStr(String::new(), String::new(), String::new()),
            )
        } else {
            assert!(false)
        }
    }
    
    #[test]
    fn expected_kv() {
        let kt = KeyTree::parse("key:\n    val:").unwrap();
        let t: Result<TestU32, Error> = kt.to_ref().try_into();
        if let Err(err) = t {
            assert_eq!(
                err.kind(),
                ErrorKind::EKeyValueFKey
            )
        } else {
            assert!(false)
        };
    }
    
    #[test]
    fn bad_indent() {
        assert_eq!(
            KeyTree::parse("key:\n     key1: val") // 5 spaces
                .expect_err("")
                .to_string(),
            "Indent of \"key1: val\" relative to root key is 5 but must be multiple of 4.",
        )
    }

pub fn no_space_after_key() -> Error {
    Error(String::from("No space after key."))
}

    // Try to properly handle hard to debug errors.
    // This fails with:
    // "thread 'test::same_indent' panicked at 'attempt to subtract with overflow', src/parser.rs:132:53"
    //
    # [test]
    fn same_indent() {
        assert_eq!(
            KeyTree::parse("key1:\nkey2: val1")
                .expect_err("")
                .to_string(),
            "\"key2: val1\" at line 2 has zero indent.",
        )
        
    }

pub fn no_tokens() -> Error {
    Error(String::from("No tokens."))

pub fn empty_path() -> Error {
    Error(String::from("Empty path."))
}