package value

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

type ArrayCell []Value

func (a ArrayCell) DropCell(m mem.Mem) error {
	for _, v := range a {
		if err := v.Drop(m); err != nil {
			return err
		}
	}

	return nil
}

func (a ArrayCell) MatchingCellKind() mem.CellKind {
	return mem.CellKindArray
}

func (a ArrayCell) Get() []Value {
	return a
}

type StringCell string

func (s StringCell) DropCell(m mem.Mem) error {
	return nil
}

func (s StringCell) MatchingCellKind() mem.CellKind {
	return mem.CellKindString
}

func (s StringCell) Get() string {
	return string(s)
}

type ObjectCell struct {
	Members map[string]Value
}

func (o ObjectCell) DropCell(m mem.Mem) error {
	for _, v := range o.Members {
		if err := v.Drop(m); err != nil {
			return err
		}
	}

	return nil
}

func (o ObjectCell) MatchingCellKind() mem.CellKind {
	return mem.CellKindObject
}

func (o ObjectCell) Get() map[string]Value {
	return o.Members
}

type TypeCell Type

func (t TypeCell) DropCell(m mem.Mem) error {
	typ := t.Get()
	for _, f := range typ.Methods {
		// Wrap data in a Value to drop it.
		val := FromData(f)
		if err := val.Drop(m); err != nil {
			return err
		}
	}

	for _, v := range typ.Statics {
		if err := v.Drop(m); err != nil {
			return err
		}
	}

	return nil
}

func (t TypeCell) MatchingCellKind() mem.CellKind {
	return mem.CellKindType
}

func (t TypeCell) Get() Type {
	return Type(t)
}

type OutletCell Value

func (o OutletCell) DropCell(m mem.Mem) error {
	return Value(o).Drop(m)
}

func (o OutletCell) MatchingCellKind() mem.CellKind {
	return mem.CellKindOutlet
}

func (o OutletCell) Get() Value {
	return Value(o)
}

type EnvCell Env

func (e EnvCell) DropCell(m mem.Mem) error {
	for _, v := range e.references {
		if err := m.Release(v.outlet); err != nil {
			return err
		}
	}

	return nil
}

func (e EnvCell) MatchingCellKind() mem.CellKind {
	return mem.CellKindEnv
}

func (e EnvCell) Get() Env {
	return Env(e)
}

type GlobalCell Value

func (g GlobalCell) DropCell(m mem.Mem) error {
	return fmt.Errorf("global cell cannot be dropped")
}

func (g GlobalCell) MatchingCellKind() mem.CellKind {
	return mem.CellKindGlobal
}

func (g GlobalCell) Get() Value {
	return Value(g)
}