# calculator.py
import re
import math
import operator
from typing import List, Dict, Optional
from contextlib import contextmanager
import signal
from functools import reduce
from fractions import Fraction


# TIMEOUT 
@contextmanager
def timeout(duration: int = 1):
    def handler(signum, frame):
        raise TimeoutError(f"Timeout after {duration}s")

    signal.signal(signal.SIGALRM, handler)
    signal.alarm(duration)
    try:
        yield
    finally:
        signal.alarm(0)


# SAFE EVAL  
def safe_eval(expr: str) -> Optional[float]:
    expr = expr.strip().replace(",", "").replace("^", "**")

    # SECURITY: BLOCK __class__, .., .x
    if ".." in expr or "__" in expr:
        return None
    if re.search(r'\.\w', expr) and not re.search(r'\d\.', expr):
        return None

    # BLOCK GIANT EXPONENTS
    if "**" in expr:
        try:
            _, exp_str = expr.split("**", 1)
            exp = float(re.split(r'[\s+\-*/)]', exp_str)[0])
            if abs(exp) > 20:
                return None
        except:
            pass

    # BLOCK SCIENTIFIC NOTATION OVERFLOW
    sci_match = re.search(r'\d+e[+\-]?\d+', expr, re.IGNORECASE)
    if sci_match:
        try:
            exp = int(re.search(r'e([+\-]?\d+)', sci_match.group(0), re.IGNORECASE).group(1))
            if abs(exp) > 50:
                return None
        except:
            return None

    # FRACTION SIMPLIFICATION
    if "/" in expr and not re.search(r'//', expr):
        try:
            parts = [p.strip() for p in expr.split("/", 1)]
            if len(parts) == 2 and parts[0].isdigit() and parts[1].isdigit():
                return float(Fraction(int(parts[0]), int(parts[1])))
        except:
            pass

    # ALLOW % (modulo)
    expr = expr.replace("%", " % ")

    if not re.match(r'^[0-9+\-*/().%\s\*\^]+$', expr):
        return None

    try:
        with timeout(1):
            result = eval(expr, {"__builtins__": {}})
            return float(result)
    except:
        return None


# EXTRACT << (GREEDY RIGHTMOST) 
def extract_calc(text: str) -> Optional[str]:
    match = re.search(r'<<([^>]*)(?:>>|$)', text)
    if not match:
        return None
    expr = match.group(1).strip()
    return expr if expr else None


# VARIABLE REPLACEMENT (longest first) 
def substitute_variables(expr: str, context: Dict[str, float]) -> str:
    for var in sorted(context.keys(), key=len, reverse=True):
        expr = re.sub(rf'\b{re.escape(var)}\b', str(context[var]), expr)
    return expr


#  NESTED FUNCTION PARSER  
def parse_nested_func(expr: str, allowed_funcs: set = None) -> Optional[float]:
    if allowed_funcs is None:
        allowed_funcs = {"sqrt", "log", "pow", "max", "min", "abs", "sin", "cos", "tan", "exp"}

    def eval_inner(inner: str) -> float:
        inner = inner.strip()
        if inner.startswith("(") and inner.endswith(")"):
            inner = inner[1:-1]
        return parse_nested_func(inner, allowed_funcs) or safe_eval(inner) or 0.0

    match = re.match(r'^([a-zA-Z_]\w*)\((.+)\)$', expr.strip())
    if not match:
        return None
    func_name, args_str = match.groups()

    if func_name not in allowed_funcs:
        return None

    # Split top-level commas
    args = []
    depth = 0
    current = ""
    for char in args_str:
        if char == "," and depth == 0:
            args.append(current)
            current = ""
        else:
            current += char
            if char == "(": depth += 1
            if char == ")": depth -= 1
    if current:
        args.append(current)

    try:
        arg_vals = [eval_inner(a) for a in args]

        # BLOCK GIANT pow() AND exp()
        if func_name == "pow" and len(arg_vals) >= 2 and abs(arg_vals[1]) > 20:
            return None
        if func_name == "exp" and arg_vals and abs(arg_vals[0]) > 20:
            return None

        func_map = {
            "sqrt": lambda x: math.sqrt(x[0]),
            "log": lambda x: math.log(x[0], x[1]) if len(x) > 1 else math.log(x[0]),
            "pow": lambda x: x[0] ** x[1],
            "max": lambda x: max(x),
            "min": lambda x: min(x),
            "abs": lambda x: abs(x[0]),
            "sin": lambda x: math.sin(x[0]),
            "cos": lambda x: math.cos(x[0]),
            "tan": lambda x: math.tan(x[0]),
            "exp": lambda x: math.exp(x[0]),
        }
        return func_map[func_name](arg_vals)
    except:
        return None


# === SEQUENCE + RANGE (NESTED) ===
def parse_range(range_str: str) -> List[float]:
    match = re.match(r'(-?\d+)\.\.(-?\d+)', range_str.strip())
    if not match:
        return []
    start, end = map(int, match.groups())
    step = 1 if start <= end else -1
    return list(range(start, end + step, step))


def evaluate_sequence(expr: str) -> Optional[float]:
    match = re.match(r'(sum|prod|mean)\((.*)\)', expr.replace(" ", ""))
    if not match:
        return None
    op, args_str = match.groups()

    def parse_arg(arg: str):
        arg = arg.strip()
        if ".." in arg:
            return parse_range(arg)
        val = parse_nested_func(arg) or safe_eval(arg)
        return [val] if val is not None else []

    args = []
    depth = 0
    current = ""
    for char in args_str:
        if char == "," and depth == 0:
            args.extend(parse_arg(current))
            current = ""
        else:
            current += char
            if char == "(": depth += 1
            if char == ")": depth -= 1
    if current:
        args.extend(parse_arg(current))

    if not args:
        return None

    if op == "sum": return sum(args)
    if op == "prod": return reduce(operator.mul, args, 1)
    if op == "mean": return sum(args) / len(args)
    return None


# CALCULATOR 
def calculate(expr: str, context: Dict[str, float] = None) -> Optional[str]:
    if context is None:
        context = {}
    expr = substitute_variables(expr, context)

    seq = evaluate_sequence(expr)
    if seq is not None:
        return f"{expr}={seq}>>"

    func = parse_nested_func(expr)
    if func is not None:
        return f"{expr}={func}>>"

    basic = safe_eval(expr)
    if basic is not None:
        return f"{expr}={basic}>>"

    return None


# PUBLIC API 
def use_calculator(text: str, context: Dict[str, float] = None) -> Optional[str]:
    expr = extract_calc(text)
    if not expr:
        return None
    return calculate(expr, context)