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)
lte_func = Builtin("<=", interpretLessThanEqual, [compare_arg, compare_arg], return_type=Type(":bool"))
lte_multi = MultiFunction("<=")
lte_multi.register(lte_func)
MATH.register("<=", lte_multi)

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

gt_func = Builtin(">", interpretGreaterThan, [compare_arg, compare_arg], return_type=Type(":bool"))
gt_multi = MultiFunction(">")
gt_multi.register(gt_func)
MATH.register(">", gt_multi)

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

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

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)
mult_func = Builtin("*", interpretMultiplication, [factor_arg, factor_arg], factor_arg, Type(":number"))
mult_multi = MultiFunction("*")
mult_multi.register(mult_func)
MATH.register("*", mult_multi)

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)

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

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

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