from .. import TypeEnum, Environment, Arg, Builtin, evaluate, InterpretPanic, MultiFunction
from ..structs import *
import math

MATH = Environment()

def interpretLessThanEqual(symbol, args, env, ns):
    return Bool(args[0].value <= args[1].value)

compare_arg = Arg("num", TypeEnum.NUMBER)
MATH.register("<=", Builtin("<=", interpretLessThanEqual, [compare_arg, compare_arg], return_type=Type(":bool")))

def interpretGreaterThan(symbol, args, env, ns):
    return Bool(args[0].value > args[1].value)

compare_arg = Arg("num", TypeEnum.NUMBER)
MATH.register(">", Builtin(">", interpretGreaterThan, [compare_arg, compare_arg], return_type=Type(":bool")))

def interpretGreaterThanEqual(symbol, args, env, ns):
    return Bool(args[0].value >= args[1].value)

MATH.register(">=", Builtin(">=", interpretGreaterThanEqual, [compare_arg, compare_arg], return_type=Type(":bool")))

def interpretLessThan(symbol, args, env, ns):
    return Bool(args[0].value < args[1].value)

lt_func = Builtin("<", interpretLessThan, [compare_arg, compare_arg], return_type=Type(":bool"))
lt_multi = MultiFunction("<")
lt_multi.register(lt_func)
MATH.register("<", lt_multi)

def interpretAddition(symbol, args, env, ns):
    res = 0
    for arg in args:
        res += arg.value
    if isinstance(res, float):
        return Float(res)
    else:
        return Int(res)

term_arg = Arg("term", TypeEnum.NUMBER)
add_func = Builtin("+", interpretAddition, [term_arg], term_arg, Type(":number"))
add_multi = MultiFunction("+")
add_multi.register(add_func)
MATH.register("+", add_multi)

def interpretSubtraction(symbol, args, env, ns):
    if len(args) == 1:
        res = -args[0].value
    else:
        res = args[0].value
    for arg in args[1:]:
        res -= arg.value
    if isinstance(res, float):
        return Float(res)
    else:
        return Int(res)

sub_func = Builtin("-", interpretSubtraction, [term_arg], term_arg, Type(":number"))
sub_multi = MultiFunction("-")
sub_multi.register(sub_func)
MATH.register("-", sub_multi)

def interpretMultiplication(symbol, args, env, ns):
    res = args[0].value
    for arg in args[1:]:
        res = res * arg.value
    if isinstance(res, float):
        return Float(res)
    else:
        return Int(res)

factor_arg = Arg("factor", TypeEnum.NUMBER)
MATH.register("*", Builtin("*", interpretMultiplication, [factor_arg, factor_arg], factor_arg, Type(":number")))

def interpretDivision(symbol, args, env, ns):
    ret = args[0].value / args[1].value
    if int(ret) == ret:
        return Int(int(ret))
    else:
        return Float(ret)

MATH.register("/", Builtin("/", interpretDivision, [factor_arg, factor_arg], return_type=Type(":number")))

def interpretFloor(symbol, args, env, ns):
    return Int(math.floor(args[0].value))

MATH.register("floor", Builtin("floor", interpretFloor, [Arg("floor", TypeEnum.NUMBER)], return_type=Type(":int")))