languages

type ArgumentMapping struct {
	Direct             *DirectArgMapping
	Runtime            *RuntimeArgMapping
	Builder            *BuilderArgMapping
	BuilderDisjunction []BuilderChoiceMapping
	Array              *ArrayArgMapping
	Map                *MapArgMapping
	Disjunction        *DisjunctionArgMapping

	// TODO: used? necessary?
	Guards []MappingGuard
}

type ArrayArgMapping struct {
	For       ast.Path
	ForType   ast.Type
	ForArg    *ArgumentMapping
	ValueAs   ast.Path
	ValueType ast.Type
}

type BuilderArgMapping struct {
	ValuePath   ast.Path
	ValueType   ast.Type
	BuilderPkg  string
	BuilderName string
}

type BuilderChoiceMapping struct {
	Guards  []MappingGuard
	Builder BuilderArgMapping
}

type Config struct {
	// Debug turns on or off the debugging mode.
	Debug bool

	// Types indicates whether types should be generated or not.
	Types bool

	// Builders indicates whether builders should be generated or not.
	Builders bool

	// Converters indicates whether converters should be generated or not.
	Converters bool

	// APIReference indicates whether an API reference should be generated or not.
	APIReference bool
}

type Context struct {
	Schemas         ast.Schemas
	Builders        ast.Builders
	ConverterConfig ConverterConfig
}

type ConversionMapping struct {
	// for i, panel := range input.Panels { WithPanel(panel) }
	RepeatFor   ast.Path // `input.Panels`
	RepeatAs    string   // `panel`
	RepeatIndex string   // `i`

	Options []OptionMapping
}

type Converter struct {
	Package string

	BuilderName string
	Input       ConverterInput

	// FIXME: assuming we only have direct mappings here is... *optimistic*.
	ConstructorArgs []DirectArgMapping

	Mappings []ConversionMapping
}

type ConverterConfig struct {
	RuntimeConfig []RuntimeConfig
}

type ConverterGenerator struct {
	// contains filtered or unexported fields
}

type ConverterInput struct {
	ArgName string
	TypeRef ast.RefType
}

type DirectArgMapping struct {
	ValuePath ast.Path // direct mapping between a JSON value and an argument
	ValueType ast.Type
}

type DisjunctionArgMapping struct {
	Branches []DisjunctionBranchArgMapping
}

type DisjunctionBranchArgMapping struct {
	Type ast.Type
	Of   *DirectArgMapping
	Arg  *ArgumentMapping
}

type Language interface {
	Name() string
	Jennies(config Config) *codejen.JennyList[Context]
	CompilerPasses() compiler.Passes
}

type Languages map[string]Language

type MapArgMapping struct {
	For       ast.Path
	ForType   ast.Type
	ForArg    *ArgumentMapping
	ValueAs   ast.Path
	IndexType ast.Type
	ValueType ast.Type
}

type MappingGuard struct {
	Path  ast.Path
	Op    ast.Op
	Value any
}

type NullableConfig struct {
	Kinds              []ast.Kind
	ProtectArrayAppend bool
	AnyIsNullable      bool
}

type NullableKindsProvider interface {
	NullableKinds() NullableConfig
}

type OptionMapping struct {
	Option ast.Option // option in the builder

	Guards []MappingGuard
	Args   []ArgumentMapping
}

type RuntimeArgMapping struct {
	FuncName string
	Args     []*DirectArgMapping
}

type RuntimeConfig struct {
	Package            string
	Name               string
	NameFunc           string `yaml:"name_func"`
	DiscriminatorField string `yaml:"discriminator_field"`
}