ast

type Argument struct {
	Name string
	Type Type
}

type ArrayType struct {
	ValueType Type `yaml:"value_type"`
}

type Assignment struct {
	// Where
	Path Path

	// What
	Value AssignmentValue

	// How
	Method AssignmentMethod

	Constraints []TypeConstraint `json:",omitempty"`
}

type AssignmentEnvelope struct {
	Type   Type // Should be a ref or a struct only
	Values []EnvelopeFieldValue
}

type AssignmentMethod string

type AssignmentOpt func(assignment *Assignment)

type AssignmentValue struct {
	Argument *Argument           `json:",omitempty"`
	Constant any                 `json:",omitempty"`
	Envelope *AssignmentEnvelope `json:",omitempty"`
}

type Builder struct {
	// Original data used to derive the builder, stored for read-only access
	// for the jennies and veneers.
	Schema *Schema
	For    Object

	// The builder itself
	// These fields are completely derived from the fields above and can be freely manipulated
	// by veneers.
	Package         string
	Name            string
	Properties      []StructField `json:",omitempty"`
	Options         []Option
	Initializations []Assignment `json:",omitempty"`
	VeneerTrail     []string     `json:",omitempty"`
}

type BuilderGenerator struct {
}

type Builders []Builder

type ComposableSlotType struct {
	Variant SchemaVariant
}

type DisjunctionType struct {
	Branches Types

	// If the branches are references to structs, some languages will need
	// extra context to be able to distinguish between them. Golang, for
	// example, doesn't support sum types (disjunctions of fixed types).
	// To emulate sum types for these languages, we need a way to
	// discriminate against every possible type.
	//
	// To do that, we need two things:
	//	- a discriminator: the name of a field that is present in all types.
	//	  The value of which identifies the type being used.
	//  - a mapping: associating a "discriminator value" to a type.
	Discriminator        string            `json:",omitempty"`
	DiscriminatorMapping map[string]string `json:",omitempty"`
}

type EnumType struct {
	Values []EnumValue // possible values. Value types might be different
}

type EnumValue struct {
	Type  Type
	Name  string
	Value any
}

type EnvelopeFieldValue struct {
	Path  Path            // where to assign within the struct/ref
	Value AssignmentValue // what to assign
}

type IntersectionType struct {
	Branches []Type
}

type JenniesHints map[string]any

type Kind string

type MapType struct {
	IndexType Type
	ValueType Type
}

type Object struct {
	Name        string
	Comments    []string `json:",omitempty"`
	Type        Type
	SelfRef     RefType
	PassesTrail []string `json:",omitempty"`
}

type Op string

type Option struct {
	Name             string
	Comments         []string `json:",omitempty"`
	VeneerTrail      []string `json:",omitempty"`
	Args             []Argument
	Assignments      []Assignment
	Default          *OptionDefault `json:",omitempty"`
	IsConstructorArg bool
}

type OptionDefault struct {
	ArgsValues []any
}

type Path []PathItem

type PathItem struct {
	Identifier string
	Type       Type // any
	// useful mostly for composability purposes, when a field Type is "any"
	// and we're trying to "compose in" something of a known type.
	TypeHint *Type `json:",omitempty"`
}

type RefType struct {
	ReferredPkg  string `yaml:"referred_pkg"`
	ReferredType string `yaml:"referred_type"`
}

type ScalarKind string

type ScalarType struct {
	ScalarKind  ScalarKind       `yaml:"scalar_kind"` // bool, bytes, string, int, float, ...
	Value       any              `json:",omitempty"`  // if value isn't nil, we're representing a constant scalar
	Constraints []TypeConstraint `json:",omitempty"`
}

type Schema struct {
	Package    string
	Metadata   SchemaMeta `json:",omitempty"`
	EntryPoint string     `json:",omitempty"`
	Objects    *orderedmap.Map[string, Object]
}

type SchemaKind string

type SchemaMeta struct {
	Kind       SchemaKind    `json:",omitempty"`
	Variant    SchemaVariant `json:",omitempty"`
	Identifier string        `json:",omitempty"`
}

type SchemaVariant string

type Schemas []*Schema

type StructField struct {
	Name        string
	Comments    []string `json:",omitempty"`
	Type        Type
	Required    bool
	PassesTrail []string `json:",omitempty"`
}

type StructFieldOption func(field *StructField)

type StructType struct {
	Fields []StructField
}

type Type struct {
	Kind     Kind
	Nullable bool
	Default  any `json:",omitempty"`

	Disjunction    *DisjunctionType    `json:",omitempty"`
	Array          *ArrayType          `json:",omitempty"`
	Enum           *EnumType           `json:",omitempty"`
	Map            *MapType            `json:",omitempty"`
	Struct         *StructType         `json:",omitempty"`
	Ref            *RefType            `json:",omitempty"`
	Scalar         *ScalarType         `json:",omitempty"`
	Intersection   *IntersectionType   `json:",omitempty"`
	ComposableSlot *ComposableSlotType `json:",omitempty" yaml:"composable_slot"`

	Hints       JenniesHints `json:",omitempty"`
	PassesTrail []string     `json:",omitempty"`
}

type TypeConstraint struct {
	Op   Op
	Args []any
}

type TypeOption func(def *Type)

type Types []Type