use core::slice::Iter;
use std::iter::Peekable;

use anyhow::anyhow;

use crate::tokenizer::Token;

#[derive(Debug, Clone)]
pub enum ParserValue {
    SimpleString(String),
    BulkString(String),
    Array(Vec<ParserValue>),
    NullBulkString,
}

impl ParserValue {
    pub fn is_string(self: &ParserValue) -> bool {
        matches!(self, ParserValue::SimpleString(_)) || matches!(self, ParserValue::BulkString(_))
    }

    pub fn is_array(self: &ParserValue) -> bool {
        matches!(self, ParserValue::Array(_))
    }

    pub fn to_string(self: &ParserValue) -> Option<String> {
        match self {
            ParserValue::SimpleString(s) => Some(s.clone()),
            ParserValue::BulkString(s) => Some(s.clone()),
            _ => None,
        }
    }

    pub fn to_vec(self: &ParserValue) -> Option<&Vec<ParserValue>> {
        match self {
            ParserValue::Array(arr) => Some(arr),
            _ => None,
        }
    }

    pub fn to_tokens(self: &ParserValue) -> Vec<Token> {
        match self {
            ParserValue::SimpleString(s) => {
                vec![Token::Plus, Token::String(s.clone()), Token::Separator]
            }
            ParserValue::BulkString(s) => {
                vec![
                    Token::Dollar,
                    Token::Number(s.len() as i64),
                    Token::Separator,
                    Token::String(s.clone()),
                    Token::Separator,
                ]
            }
            ParserValue::Array(arr) => {
                let mut tokens = vec![
                    Token::Asterisk,
                    Token::Number(arr.len() as i64),
                    Token::Separator,
                ];
                for parser_value in arr {
                    tokens.append(&mut parser_value.to_tokens());
                }
                tokens
            }
            ParserValue::NullBulkString => {
                vec![Token::Dollar, Token::Number(-1), Token::Separator]
            }
        }
    }
}

pub fn parse_tokens(tokens: &[Token]) -> Option<ParserValue> {
    if tokens.is_empty() {
        return None;
    }

    let mut tokens_iter = tokens.iter().peekable();
    let first = tokens_iter.peek().expect("must have at least one token");

    eprintln!("First Token {:?}", first);

    match first {
        // Simple String
        Token::Plus => {
            if let Ok(simple_string) = tokens_to_simple_string(&mut tokens_iter) {
                return Some(simple_string);
            }

            None
        }
        // Bulk String
        Token::Dollar => {
            if let Ok(bulk_string) = tokens_to_bulk_string(&mut tokens_iter) {
                return Some(bulk_string);
            }

            None
        }
        // Array
        Token::Asterisk => match tokens_to_array(&mut tokens_iter) {
            Ok(arr) => Some(arr),
            Err(err) => {
                eprintln!("{:?}", err);
                None
            }
        },
        _ => None,
    }
}

fn tokens_to_simple_string(token_iter: &mut Peekable<Iter<Token>>) -> anyhow::Result<ParserValue> {
    if !token_iter.next().is_some_and(|t| t.is_plus()) {
        return Err(anyhow!("first token in simple string must be a plus"));
    }
    let str_token = token_iter
        .next()
        .expect("should have a second token for simple string");

    let separator_token = token_iter
        .next()
        .expect("should have a third token for simple string");

    if !separator_token.is_separator() {
        return Err(anyhow!("third token in simple string must be a separator"));
    }

    Ok(ParserValue::SimpleString(str_token.to_string().expect(
        "should be able to get strings from string tokens",
    )))
}

fn tokens_to_bulk_string(token_iter: &mut Peekable<Iter<Token>>) -> anyhow::Result<ParserValue> {
    if !token_iter.next().is_some_and(|t| t.is_dollar()) {
        return Err(anyhow!("first token in bulk string must be a dollar sign"));
    }
    let size_token = token_iter
        .next()
        .expect("should have  second token for bulk string");
    if !size_token.is_number() {
        return Err(anyhow!("second token in bulk string must be a number"));
    }
    let separator_token = token_iter
        .next()
        .expect("should have a third token for simple string");
    if !separator_token.is_separator() {
        return Err(anyhow!("third token in bulk string must be a separator"));
    }
    let mut str_tokens = Vec::new();
    while token_iter.peek().is_some_and(|t| !t.is_separator()) {
        let str_token = token_iter.next().expect("should str_token");
        str_tokens.push(str_token);
    }

    let separator_token = token_iter
        .next()
        .expect("should have a fifth token for simple string");
    if !separator_token.is_separator() {
        return Err(anyhow!("fifth token in bulk string must be a separator"));
    }
    let mut s = String::with_capacity(size_token.to_usize().expect("size_token must be a usize"));
    for t in str_tokens.iter() {
        match t {
            Token::Plus => {
                s.push('+');
            }
            Token::Hyphen => {
                s.push('-');
            }
            Token::Colon => {
                s.push(':');
            }
            Token::Dollar => {
                s.push('$');
            }
            Token::Asterisk => {
                s.push('*');
            }
            Token::Underscore => {
                s.push('_');
            }
            Token::PoundSign => {
                s.push('#');
            }
            Token::Comma => {
                s.push(',');
            }
            Token::LeftParenthesis => {
                s.push('(');
            }
            Token::Exclamation => {
                s.push('!');
            }
            Token::Equals => {
                s.push('=');
            }
            Token::Percentage => {
                s.push('%');
            }
            Token::Tilda => {
                s.push('~');
            }
            Token::GreaterThan => {
                s.push('>');
            }
            Token::String(ts) => s.push_str(ts),
            Token::Number(n) => s.push_str(n.to_string().as_str()),
            Token::Separator => {}
        }
    }
    if s.len() != size_token.to_usize().expect("size_token must be a usize") {
        return Err(anyhow!("incorrect string size in bulk token"));
    }

    Ok(ParserValue::BulkString(s))
}

fn tokens_to_array(token_iter: &mut Peekable<Iter<Token>>) -> anyhow::Result<ParserValue> {
    if !token_iter.next().is_some_and(|t| t.is_asterisk()) {
        return Err(anyhow!("first token in bulk string must be an asterisk"));
    }
    let length = token_iter.next().expect("should have a length token");
    eprintln!("Length Token: {:?}", length);
    if !length.is_number() {
        return Err(anyhow!("second token in array should be length"));
    }
    let length = length.to_i64().expect("number token should have i64");
    eprintln!("Length: {:?}", length);
    if length < 0 {
        return Err(anyhow!("array length cannot be negative"));
    }

    if length == 0 {
        return Ok(ParserValue::Array(Vec::new()));
    }

    if !token_iter.next().is_some_and(|t| t.is_separator()) {
        return Err(anyhow!("third token in an array must be a separator"));
    }

    let mut values: Vec<ParserValue> = Vec::with_capacity(length as usize);
    for _ in 0..length {
        let first = token_iter.peek().expect("should have next token in array");
        eprintln!("First Array Token: {:?}", first);
        match first {
            Token::Plus => {
                let simple_string = tokens_to_simple_string(token_iter);
                if let Ok(simple_string) = simple_string {
                    values.push(simple_string);
                } else {
                    return Err(simple_string.err().unwrap());
                }
            }
            Token::Dollar => {
                let bulk_string = tokens_to_bulk_string(token_iter);
                if let Ok(bulk_string) = bulk_string {
                    values.push(bulk_string);
                } else {
                    let err = bulk_string.err().unwrap();
                    eprintln!("{:?}", err);
                    return Err(err);
                }
            }
            Token::Asterisk => {
                let arr = tokens_to_array(token_iter);
                if let Ok(arr) = arr {
                    values.push(arr);
                } else {
                    return Err(arr.err().unwrap());
                }
            }
            _ => return Err(anyhow!("unexpected starting token in array")),
        }
    }

    Ok(ParserValue::Array(values))
}

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

    #[test]
    fn test_parses_bulk_string_with_negative_number() {
        let tokens = [
            Token::Dollar,
            Token::Number(2),
            Token::Separator,
            Token::Hyphen,
            Token::Number(1),
            Token::Separator,
        ];
        let result = tokens_to_bulk_string(&mut tokens.iter().peekable());
        assert!(result.is_ok());
        assert_eq!(
            ParserValue::BulkString("-1".to_string())
                .to_string()
                .unwrap(),
            result.unwrap().to_string().unwrap()
        );
    }

    #[test]
    fn test_parses_bulk_string() {
        let tokens = [
            Token::Dollar,
            Token::Number(5),
            Token::Separator,
            Token::String("PSYNC".to_string()),
            Token::Separator,
        ];

        let result = tokens_to_bulk_string(&mut tokens.iter().peekable());
        assert!(result.is_ok());
        assert_eq!(
            ParserValue::BulkString("PSYNC".to_string())
                .to_string()
                .unwrap(),
            result.unwrap().to_string().unwrap()
        );
    }
}