package scope

import "jinx/pkg/lang/vm/code"

type ScopeID int

type ScopeKind int

const (
	ScopeKindNormal ScopeKind = iota
	ScopeKindFunction
	ScopeKindLoop
)

type SymbolScope struct {
	variableSymbols []Symbol[SymbolVariable]
}

func NewSymbolScope() SymbolScope {
	return SymbolScope{
		variableSymbols: make([]Symbol[SymbolVariable], 0),
	}
}

type FunctionScope struct {
	id           ScopeID
	unit         code.Marker
	subUnitCount int

	outsideSymbolsInEnv []SymbolID
}

func NewFunctionScope(id ScopeID, unit code.Marker) FunctionScope {
	return FunctionScope{
		id:           id,
		unit:         unit,
		subUnitCount: 0,

		outsideSymbolsInEnv: make([]SymbolID, 0),
	}
}

func (sf FunctionScope) ID() ScopeID {
	return sf.id
}

func (sf FunctionScope) Unit() code.Marker {
	return sf.unit
}

func (sf FunctionScope) OutsideSymbolsInEnv() []SymbolID {
	return sf.outsideSymbolsInEnv
}

func (sf FunctionScope) IsRootScope() bool {
	return sf.ID() == ScopeID(0)
}

type LoopScope struct {
	id             ScopeID
	breakMarker    code.Marker
	continueMarker code.Marker
}

func NewLoopScope(id ScopeID, breakMarker code.Marker, continueMarker code.Marker) LoopScope {
	return LoopScope{
		id:             id,
		breakMarker:    breakMarker,
		continueMarker: continueMarker,
	}
}

func (sl LoopScope) ID() ScopeID {
	return sl.id
}

func (sl LoopScope) BreakMarker() code.Marker {
	return sl.breakMarker
}

func (sl LoopScope) ContinueMarker() code.Marker {
	return sl.continueMarker
}