package object

import "fmt"

// Type represents the type of an object
type Type int

const (
	NullType = iota
	IntegerType
	StringType
	BooleanType
	ReturnType
	ErrorType
	FunctionType
	CFunctionType
	BuiltinType
	ClosureType
	ArrayType
	HashType
	ModuleType
)

func (t Type) String() string {
	switch t {
	case NullType:
		return "null"
	case IntegerType:
		return "int"
	case StringType:
		return "str"
	case BooleanType:
		return "bool"
	case ReturnType:
		return "Return"
	case ErrorType:
		return "error"
	case FunctionType:
		return "fn"
	case CFunctionType:
		return "CFunction"
	case BuiltinType:
		return "Builtin"
	case ClosureType:
		return "Closure"
	case ArrayType:
		return "array"
	case HashType:
		return "hash"
	case ModuleType:
		return "module"
	default:
		return "???"
	}
}

// Comparable is the interface for comparing two Object and their underlying
// values. It is the responsibility of the caller (left) to check for types.
// Returns `true` iif the types and values are identical, `false` otherwise.
type Comparable interface {
	Compare(other Object) int
}

// Sizeable is the interface for returning the size of an Object.
// Object(s) that have a valid size must implement  this interface and the
// Len() method.
type Sizeable interface {
	Len() int
}

// Immutable is the interface for all immutable objects which must implement
// the Clone() method used by binding names to values.
type Immutable interface {
	Clone() Object
}

// Object represents a value and implementations are expected to implement
// `Type()` and `Inspect()` functions
type Object interface {
	fmt.Stringer
	Type() Type
	Bool() bool
	Inspect() string
}

// Hashable is the interface for all hashable objects which must implement
// the HashKey() method which returns a HashKey result.
type Hashable interface {
	HashKey() HashKey
}

// BuiltinFunction represents the builtin function type
type BuiltinFunction func(args ...Object) Object