package muesli

import "fmt"
import "log"

type LogTracer struct {
}

func (t LogTracer) Trace(vm VM, ast Ast, val ... Value) bool {
	log.Printf("Trace: %s -> %v", ast.String(), val)
	return false
}


type FmtTracer struct {
}

func (t FmtTracer) Trace(vm VM, ast Ast, args ... Value) bool {
	arg  := args[0]
	rest := args[1:len(args)]
	fmt.Printf("Trace: %s: %v -> ", ast.String(), arg)
	for _, v := range rest {
		fmt.Printf("%v, ", v)
	}
	fmt.Printf("<-\n ")
	return false
}

func printf(vm *VM, args ...Value) []Value {
	var format string
	rest, err := ParseArgs(args, &format)
	if err != nil {
		return Return(ErrorValue{err})
	}
	fmt.Printf(format, rest...)
	return []Value{EmptyValue{}}
}

func println(vm *VM, args ...Value) []Value {
	var msg string
	_, err := ParseArgs(args, &msg)
	if err != nil {
		return Return(ErrorValue{err})
	} else {
		fmt.Println(msg)
	}
	return Return(EmptyValue{})
}

func p(vm *VM, args ...Value) []Value {	
	for _, arg := range args {
		fmt.Printf("%v\n", arg)
	}	
	return Return(EmptyValue{})
}

func trace(vm *VM, args ...Value) []Value {
	var b bool = true
	fmt.Printf("command trace: %v\n", args)
	_, err := ParseArgs(args, &b)
	if err != nil {
		fmt.Printf("Error: %s\n", err.Error())
		return Return(ErrorValue{err})
	}
	fmt.Printf("command trace: bool: %v\n", b)
	if b {
		vm.Tracer = FmtTracer{}
	} else {
		vm.Tracer = nil
	}
	return Return(BoolValue(b))
}

func addi(vm *VM, args ...Value) []Value {
	var i1, i2 int
	_, err := ParseArgs(args, &i1, &i2)
	if err != nil {
		fmt.Printf("Error: %s\n", err.Error())
		return Return(ErrorValue{err})
	}
	return Return(IntValue(i1 + i2))
}

func addf(vm *VM, args ...Value) []Value {
	var f1, f2 float64
	_, err := ParseArgs(args, &f1, &f2)
	if err != nil {
		fmt.Printf("Error: %s\n", err.Error())
		return Return(ErrorValue{err})
	}
	return Return(FloatValue(f1 + f2))
}

func val(vm *VM, args ...Value) []Value {
	if len(args) < 1 {
		return []Value{NewErrorValuef("val requres at least one argument.")}
	}
	return args
}


func (vm *VM) RegisterBuiltins() {
	vm.RegisterBuiltin("addi", addi)
	vm.RegisterBuiltin("addf", addf)
	// vm.RegisterCover("add")
	vm.RegisterBuiltin("p", p)
	vm.RegisterBuiltin("println", println)
	vm.RegisterBuiltin("printf", printf)
	vm.RegisterBuiltin("trace", trace)
	vm.RegisterBuiltin("val", val)
}