package value

import (
	"jinx/pkg/lang/vm/mem"
)

type Value struct {
	t Type
	d Data
}

func NewInt(x int64) Value {
	t := Type{Kind: IntType}
	return Value{t: t, d: IntData(x)}
}

func NewFloat(x float64) Value {
	t := Type{Kind: FloatType}
	return Value{t: t, d: FloatData(x)}
}

func NewString(m *mem.Mem, str string) Value {
	t := Type{Kind: StringType}

	ptr := m.Allocate(mem.CellKindString)
	m.Set(ptr, str)

	return Value{t: t, d: StringData{data: ptr}}
}

func NewBool(b bool) Value {
	t := Type{Kind: BoolType}
	return Value{t: t, d: BoolData(b)}
}

func NewArray(m *mem.Mem, arr []Value) Value {
	t := Type{Kind: ArrayType}

	ptr := m.Allocate(mem.CellKindArray)
	m.Set(ptr, arr)

	return Value{t: t, d: ArrayData{data: ptr}}
}

func NewNull() Value {
	t := Type{Kind: NullType}
	return Value{t: t}
}

func NewFunction(pc int) Value {
	t := Type{Kind: FunctionType}
	return Value{t: t, d: FunctionData{pc: pc}}
}

func NewObject() Value {
	panic("not implemented")
}

func (v Value) Type() Type {
	return v.t
}

func (v Value) Data() Data {
	return v.d
}

func (v Value) Clone(m *mem.Mem) Value {
	if v.t.Kind == StringType {
		str := v.d.(StringData)
		m.Retain(str.data)
	}

	if v.t.Kind == ArrayType {
		arr := v.d.(ArrayData)
		m.Retain(arr.data)
	}

	return v
}

func (v Value) Drop(m *mem.Mem) {
	if v.t.Kind == StringType {
		str := v.d.(StringData)
		m.Release(str.data)
	}

	if v.t.Kind == ArrayType {
		arr := v.d.(ArrayData)
		m.Release(arr.data)
	}
}