package value

import (
	"fmt"
	"jinx/pkg/lang/vm/mem"
	"strconv"
	"strings"
)

type Data interface {
	String(*mem.Mem) string
}

type IntData int64

func (i IntData) Get() int64 {
	return int64(i)
}

func (i IntData) String(_ *mem.Mem) string {
	return strconv.FormatInt(int64(i), 10)
}

type FloatData float64

func (f FloatData) Get() float64 {
	return float64(f)
}

func (f FloatData) String(_ *mem.Mem) string {
	return strconv.FormatFloat(float64(f), 'f', -1, 64)
}

type StringData struct {
	data mem.Ptr
}

func (s StringData) String(m *mem.Mem) string {
	data := m.Get(s.data)
	return "\"" + data.(string) + "\""
}

type BoolData bool

func (b BoolData) Get() bool {
	return bool(b)
}

func (b BoolData) String(_ *mem.Mem) string {
	return strconv.FormatBool(bool(b))
}

type ArrayData struct {
	data mem.Ptr
}

func (a ArrayData) String(m *mem.Mem) string {
	arr := m.Get(a.data).([]Value)

	builder := strings.Builder{}
	builder.WriteString("[")
	for i, v := range arr {
		if i > 0 {
			builder.WriteString(", ")
		}
		builder.WriteString(v.Data().String(m))
	}
	builder.WriteString("]")
	return builder.String()
}

func (a ArrayData) Len(m *mem.Mem) int {
	data := m.Get(a.data)
	arr := data.([]Value)
	return len(arr)
}

func (a ArrayData) At(m *mem.Mem, i int) Value {
	data := m.Get(a.data)
	arr := data.([]Value)
	return arr[i]
}

func (a ArrayData) Push(m *mem.Mem, v Value) {
	data := m.Get(a.data)
	arr := data.([]Value)
	arr = append(arr, v)
	m.Set(a.data, arr)
}

type NullData struct{}

type FunctionData struct {
	pc  int
	env mem.Ptr
}

func (f FunctionData) Pc() int {
	return f.pc
}

func (f FunctionData) Env() mem.Ptr {
	return f.env
}

func (f FunctionData) WithEnv(env mem.Ptr) FunctionData {
	return FunctionData{pc: f.pc, env: env}
}

func (f FunctionData) String(_ *mem.Mem) string {
	return fmt.Sprintf("<fn %d>", f.pc)
}

type ObjectData struct{} // TODO