package value

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

type Value struct {
	t      Type
	d      Data
	outlet mem.Ptr
}

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, error) {
	t := Type{Kind: StringType}

	ptr, err := m.Allocate(mem.CellKindString)
	if err != nil {
		return Value{}, err
	}

	m.Set(ptr, StringCell(str))

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

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

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

	ptr, err := m.Allocate(mem.CellKindArray)
	if err != nil {
		return Value{}, err
	}

	m.Set(ptr, ArrayCell(arr))

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

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) WithData(d Data) Value {
	return Value{t: v.t, d: d, outlet: v.outlet}
}

func (v Value) Outlet() mem.Ptr {
	return v.outlet
}

func (v Value) WithOutlet(outlet mem.Ptr) Value {
	return Value{t: v.t, d: v.d, outlet: outlet}
}

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

	if v.t.Kind == FunctionType {
		fn := v.d.(FunctionData)
		m.Retain(fn.env)
	}

	return v
}

func (v Value) Drop(m *mem.Mem) {
	// If value has an outlet, don't drop it and instead move it to the outlet.
	if !v.outlet.IsNull() {
		m.Set(v.outlet, OutletCell(v))
		return
	}

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

	if v.t.Kind == FunctionType {
		f := v.d.(FunctionData)
		m.Release(f.env)
	}
}