from .. import TypeEnum, Environment, Arg, Builtin, evaluate
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]))

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]))

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

MATH.register(">=", Builtin(interpretGreaterThanEqual, [compare_arg, compare_arg]))

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

MATH.register("<", Builtin(interpretLessThan, [compare_arg, compare_arg]))

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)
MATH.register("+", Builtin(interpretAddition, [term_arg], term_arg))

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)

MATH.register("-", Builtin(interpretSubtraction, [term_arg], term_arg))

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))

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]))

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

MATH.register("floor", Builtin(interpretFloor, [Arg("floor", TypeEnum.NUMBER)]))