use std::io::Cursor;

use neotoma::{
    cache::ParsingCache,
    literal::Literal,
    optional::Optional,
    parser::{Parser, Source, parse},
    recursive::Recursive,
    result::{Error, ParseResult},
    utf8class::Utf8Class,
};

// Arithmetic expression AST
#[derive(Debug, Clone, PartialEq)]
enum ArithmeticExpr {
    Number(String),
    Variable(String),
    Real(String, String), // integer part, fractional part
    BinaryOp {
        left: Box<ArithmeticExpr>,
        op: String,
        right: Box<ArithmeticExpr>,
    },
    Parenthesized(Box<ArithmeticExpr>),
}

// Number parser
#[derive(Clone)]
struct NumberParser;

impl<Ctx> Parser<Ctx> for NumberParser {
    type Output = ArithmeticExpr;

    fn read<S>(
        &self,
        source: &mut Source<S>,
        cache: &mut impl ParsingCache,
        _context: &mut Ctx,
    ) -> ParseResult<Self::Output>
    where
        S: neotoma::parser::Parsable,
    {
        let integer = Utf8Class::with_min("0123456789", 1);
        if let Ok(digits) = integer.parse(source, cache, _context) {
            return Ok(ArithmeticExpr::Number(digits));
        }
        Err(Error::NoMatch)
    }
}

// Variable parser
#[derive(Clone)]
struct VariableParser;

impl<Ctx> Parser<Ctx> for VariableParser {
    type Output = ArithmeticExpr;

    fn read<S>(
        &self,
        source: &mut Source<S>,
        cache: &mut impl ParsingCache,
        _context: &mut Ctx,
    ) -> ParseResult<Self::Output>
    where
        S: neotoma::parser::Parsable,
    {
        let alpha = Utf8Class::from_predicate_min(|c| c.is_ascii_alphabetic(), 1);
        if let Ok(var) = alpha.parse(source, cache, _context) {
            return Ok(ArithmeticExpr::Variable(var));
        }
        Err(Error::NoMatch)
    }
}

// Real number parser (integer.integer)
#[derive(Clone)]
struct RealParser;

impl<Ctx> Parser<Ctx> for RealParser {
    type Output = ArithmeticExpr;

    fn read<S>(
        &self,
        source: &mut Source<S>,
        cache: &mut impl ParsingCache,
        _context: &mut Ctx,
    ) -> ParseResult<Self::Output>
    where
        S: neotoma::parser::Parsable,
    {
        let integer = Utf8Class::with_min("0123456789", 1);
        let point = Literal::from_bytes_const(b".");

        if let Ok(int_part) = integer.parse(source, cache, _context) {
            if point.parse(source, cache, _context).is_ok() {
                if let Ok(frac_part) = integer.parse(source, cache, _context) {
                    return Ok(ArithmeticExpr::Real(int_part, frac_part));
                }
            }
        }
        Err(Error::NoMatch)
    }
}

// Factor parser - handles numbers, variables, reals, and parenthesized expressions
struct FactorParser {
    expr_parser: Recursive<ArithmeticExpression>,
}

impl FactorParser {
    fn new() -> Self {
        Self {
            expr_parser: Recursive::new(),
        }
    }
}

impl<Ctx> Parser<Ctx> for FactorParser {
    type Output = ArithmeticExpr;

    fn read<S>(
        &self,
        source: &mut Source<S>,
        cache: &mut impl ParsingCache,
        _context: &mut Ctx,
    ) -> ParseResult<Self::Output>
    where
        S: neotoma::parser::Parsable,
    {
        let whitespace = Optional::new(Utf8Class::whitespace());

        let oparen = Literal::from_bytes_const(b"(");
        if oparen.parse(source, cache, _context).is_ok() {
            let _ = whitespace.parse(source, cache, _context);
            if let Ok(inner_expr) = self.expr_parser.parse(source, cache, _context) {
                let _ = whitespace.parse(source, cache, _context);
                let cparen = Literal::from_bytes_const(b")");
                if cparen.parse(source, cache, _context).is_ok() {
                    return Ok(ArithmeticExpr::Parenthesized(Box::new(inner_expr)));
                }
            }
        }

        // Try real number first (more specific than integer)
        let real_parser = RealParser;
        if let Ok(real_expr) = real_parser.parse(source, cache, _context) {
            return Ok(real_expr);
        }

        // Try variable
        let var_parser = VariableParser;
        if let Ok(var_expr) = var_parser.parse(source, cache, _context) {
            return Ok(var_expr);
        }

        // Try integer
        let num_parser = NumberParser;
        if let Ok(num_expr) = num_parser.parse(source, cache, _context) {
            return Ok(num_expr);
        }

        Err(Error::NoMatch)
    }
}

// Term parser - handles multiplication and division
struct TermParser {
    factor_parser: FactorParser,
}

impl TermParser {
    fn new() -> Self {
        Self {
            factor_parser: FactorParser::new(),
        }
    }
}

impl<Ctx> Parser<Ctx> for TermParser {
    type Output = ArithmeticExpr;

    fn read<S>(
        &self,
        source: &mut Source<S>,
        cache: &mut impl ParsingCache,
        _context: &mut Ctx,
    ) -> ParseResult<Self::Output>
    where
        S: neotoma::parser::Parsable,
    {
        let whitespace = Optional::new(Utf8Class::whitespace());
        let multiply = Literal::from_bytes_const(b"*");
        let divide = Literal::from_bytes_const(b"/");

        // Parse first factor
        if let Ok(mut left) = self.factor_parser.parse(source, cache, _context) {
            // Try to parse operator and second factor
            let _ = whitespace.parse(source, cache, _context);

            // Check for multiply
            if multiply.parse(source, cache, _context).is_ok() {
                let _ = whitespace.parse(source, cache, _context);
                if let Ok(right) = self.factor_parser.parse(source, cache, _context) {
                    left = ArithmeticExpr::BinaryOp {
                        left: Box::new(left),
                        op: "*".to_string(),
                        right: Box::new(right),
                    };
                }
            }
            // Check for divide (if multiply didn't match)
            else if divide.parse(source, cache, _context).is_ok() {
                let _ = whitespace.parse(source, cache, _context);
                if let Ok(right) = self.factor_parser.parse(source, cache, _context) {
                    left = ArithmeticExpr::BinaryOp {
                        left: Box::new(left),
                        op: "/".to_string(),
                        right: Box::new(right),
                    };
                }
            }

            return Ok(left);
        }

        Err(Error::NoMatch)
    }
}

// Main expression parser - handles addition and subtraction
struct ArithmeticExpression {
    term_parser: TermParser,
}

impl ArithmeticExpression {
    fn new() -> Self {
        ArithmeticExpression {
            term_parser: TermParser::new(),
        }
    }
}

impl Default for ArithmeticExpression {
    fn default() -> Self {
        Self::new()
    }
}

impl<Ctx> Parser<Ctx> for ArithmeticExpression {
    type Output = ArithmeticExpr;

    fn read<S>(
        &self,
        source: &mut Source<S>,
        cache: &mut impl ParsingCache,
        _context: &mut Ctx,
    ) -> ParseResult<Self::Output>
    where
        S: neotoma::parser::Parsable,
    {
        let whitespace = Optional::new(Utf8Class::whitespace());
        let plus = Literal::from_bytes_const(b"+");
        let minus = Literal::from_bytes_const(b"-");

        // Parse first term
        if let Ok(mut left) = self.term_parser.parse(source, cache, _context) {
            // Try to parse operator and second term
            let _ = whitespace.parse(source, cache, _context);

            // Check for plus
            if plus.parse(source, cache, _context).is_ok() {
                let _ = whitespace.parse(source, cache, _context);
                if let Ok(right) = self.term_parser.parse(source, cache, _context) {
                    left = ArithmeticExpr::BinaryOp {
                        left: Box::new(left),
                        op: "+".to_string(),
                        right: Box::new(right),
                    };
                }
            }
            // Check for minus (if plus didn't match)
            else if minus.parse(source, cache, _context).is_ok() {
                let _ = whitespace.parse(source, cache, _context);
                if let Ok(right) = self.term_parser.parse(source, cache, _context) {
                    left = ArithmeticExpr::BinaryOp {
                        left: Box::new(left),
                        op: "-".to_string(),
                        right: Box::new(right),
                    };
                }
            }

            return Ok(left);
        }

        Err(Error::NoMatch)
    }
}

#[test]
fn hardcoded_arithmetic_parser() {
    let expression = ArithmeticExpression::new();

    let cursor = Cursor::new(br#"1 + 2 * 3"#);
    let mut source = Source::new(cursor);

    let result = parse(expression, &mut source);

    // Just verify it parses without error for now
    assert!(result.is_ok());

    // We can also check the structure
    if let Ok(expr) = result {
        match expr {
            ArithmeticExpr::BinaryOp { left, op, right } => {
                assert_eq!(op, "+");
                // Left should be "1"
                if let ArithmeticExpr::Number(n) = *left {
                    assert_eq!(n, "1");
                }
                // Right should be "2 * 3"
                if let ArithmeticExpr::BinaryOp {
                    left: l2,
                    op: op2,
                    right: r2,
                } = *right
                {
                    assert_eq!(op2, "*");
                    if let (ArithmeticExpr::Number(n2), ArithmeticExpr::Number(n3)) = (*l2, *r2) {
                        assert_eq!(n2, "2");
                        assert_eq!(n3, "3");
                    }
                }
            }
            _ => panic!("Expected binary operation"),
        }
    }
}

#[test]
fn arithmetic_with_parentheses() {
    let expression = ArithmeticExpression::new();
    let cursor = Cursor::new(br#"(1 + 2) * 3"#);
    let mut source = Source::new(cursor);

    let result = parse(expression, &mut source);
    assert!(result.is_ok());
}

#[test]
fn arithmetic_with_variables() {
    let expression = ArithmeticExpression::new();
    let cursor = Cursor::new(br#"x + y * z"#);
    let mut source = Source::new(cursor);

    let result = parse(expression, &mut source);
    assert!(result.is_ok());
}

#[test]
fn complex_expression() {
    let expression = ArithmeticExpression::new();
    let cursor = Cursor::new(br#"1 + 2 + 3 * 3"#);
    let mut source = Source::new(cursor);

    let result = parse(expression, &mut source);
    assert!(
        result.is_ok(),
        "Complex expression should parse successfully"
    );
}

#[test]
fn two_levels_of_nesting() {
    let expression = ArithmeticExpression::new();
    let cursor = Cursor::new(br#"((1 + 2))"#);
    let mut source = Source::new(cursor);

    let result = parse(expression, &mut source);
    println!("Two levels result: {result:?}");
    assert!(
        result.is_ok(),
        "Two levels of nesting should parse successfully"
    );
}

#[test]
fn three_levels_of_nesting() {
    let expression = ArithmeticExpression::new();
    let cursor = Cursor::new(br#"(((1 + 2)))"#);
    let mut source = Source::new(cursor);

    let result = parse(expression, &mut source);
    assert!(
        result.is_ok(),
        "Three levels of nesting should parse successfully"
    );
}

#[test]
fn five_levels_of_nesting() {
    let expression = ArithmeticExpression::new();
    let cursor = Cursor::new(br#"((((1 + 2))))"#);
    let mut source = Source::new(cursor);

    let result = parse(expression, &mut source);
    assert!(
        result.is_ok(),
        "Five levels of nesting should parse successfully"
    );

    // Verify the structure has the right nesting
    if let Ok(expr) = result {
        let mut current = &expr;
        let mut depth = 0;

        // Count how deep the parentheses nesting goes
        while let ArithmeticExpr::Parenthesized(inner) = current {
            depth += 1;
            current = inner;
        }

        assert_eq!(depth, 4, "Should have 4 levels of parentheses nesting");
    }
}

#[test]
fn ten_levels_of_nesting() {
    let expression = ArithmeticExpression::new();
    let cursor = Cursor::new(br#"(((((((((1 + 2)))))))))"#);
    let mut source = Source::new(cursor);

    let result = parse(expression, &mut source);
    assert!(
        result.is_ok(),
        "Ten levels of nesting should parse successfully"
    );

    // Verify the structure has the right nesting
    if let Ok(expr) = result {
        let mut current = &expr;
        let mut depth = 0;

        // Count how deep the parentheses nesting goes
        while let ArithmeticExpr::Parenthesized(inner) = current {
            depth += 1;
            current = inner;
        }

        assert_eq!(depth, 9, "Should have 9 levels of parentheses nesting");
    }
}