"""
Mathematical Reasoning - Eden can now solve math problems
"""
import re
from sympy import symbols, simplify, solve, diff, integrate, Symbol
from sympy.parsing.sympy_parser import parse_expr

class MathReasoning:
    def __init__(self):
        self.solved_problems = []
        
    def parse_equation(self, equation_str):
        """Parse string equation into sympy format"""
        try:
            expr = parse_expr(equation_str)
            return {"success": True, "expression": expr}
        except Exception as e:
            return {"success": False, "error": str(e)}
    
    def solve_equation(self, equation_str, variable='x'):
        """Solve algebraic equation"""
        try:
            # Parse equation
            if '=' in equation_str:
                left, right = equation_str.split('=')
                expr = parse_expr(f"({left})-({right})")
            else:
                expr = parse_expr(equation_str)
            
            # Solve
            var = Symbol(variable)
            solutions = solve(expr, var)
            
            result = {
                "success": True,
                "equation": equation_str,
                "solutions": [str(sol) for sol in solutions],
                "variable": variable
            }
            
            self.solved_problems.append(result)
            return result
            
        except Exception as e:
            return {"success": False, "error": str(e)}
    
    def calculate_derivative(self, expression_str, variable='x'):
        """Calculate derivative"""
        try:
            expr = parse_expr(expression_str)
            var = Symbol(variable)
            derivative = diff(expr, var)
            
            return {
                "success": True,
                "expression": expression_str,
                "derivative": str(derivative),
                "variable": variable
            }
        except Exception as e:
            return {"success": False, "error": str(e)}
    
    def calculate_integral(self, expression_str, variable='x'):
        """Calculate integral"""
        try:
            expr = parse_expr(expression_str)
            var = Symbol(variable)
            integral = integrate(expr, var)
            
            return {
                "success": True,
                "expression": expression_str,
                "integral": str(integral),
                "variable": variable
            }
        except Exception as e:
            return {"success": False, "error": str(e)}
    
    def simplify_expression(self, expression_str):
        """Simplify mathematical expression"""
        try:
            expr = parse_expr(expression_str)
            simplified = simplify(expr)
            
            return {
                "success": True,
                "original": expression_str,
                "simplified": str(simplified)
            }
        except Exception as e:
            return {"success": False, "error": str(e)}

if __name__ == "__main__":
    print("MATHEMATICAL REASONING TEST")
    
    math = MathReasoning()
    
    # Test solving equation
    print("\n🔢 Solving: x^2 - 4 = 0")
    result = math.solve_equation("x**2 - 4", 'x')
    if result["success"]:
        print(f"   Solutions: {result['solutions']}")
    
    # Test derivative
    print("\n📈 Derivative of: x^2 + 2*x")
    result = math.calculate_derivative("x**2 + 2*x", 'x')
    if result["success"]:
        print(f"   Derivative: {result['derivative']}")
    
    # Test simplification
    print("\n✨ Simplify: (x^2 - 1)/(x - 1)")
    result = math.simplify_expression("(x**2 - 1)/(x - 1)")
    if result["success"]:
        print(f"   Simplified: {result['simplified']}")
    
    print(f"\n📊 Problems solved: {len(math.solved_problems)}")
    
    print("\n🧮 Eden can now:")
    print("   - Solve algebraic equations")
    print("   - Calculate derivatives")
    print("   - Calculate integrals")
    print("   - Simplify expressions")
    
    print("\n✅ MATH REASONING OPERATIONAL")