model

type AliasLookup interface {
	LookupAlias(uniqueKey string) (string, bool)
}

type AliasManager interface {
	AliasLookup
	PopulateAliases()
	GetAllAliases() map[string]string
	GetAliasedTypes() map[string]*TypeInfo
	GetAlias(info *TypeInfo) (string, bool)
	IsUserDefined(uniqueKey string) bool
	GetSourcePath() string
	GetTargetPath() string
}

type AliasRenderInfo struct {
	AliasName        string
	OriginalTypeName string
}

type AnalysisResult struct {
	TypeInfos         map[string]*TypeInfo
	ExistingFunctions map[string]bool
	ExistingAliases   map[string]string
	ExecutionPlan     *ExecutionPlan
}

type CodeEmitter interface {
	EmitHeader(buf *bytes.Buffer) error
	EmitStubHeader(buf *bytes.Buffer) error
	EmitImports(buf *bytes.Buffer, imports map[string]string) error
	EmitAliases(buf *bytes.Buffer, aliases []*AliasRenderInfo) error
	EmitConversions(buf *bytes.Buffer, funcs []string) error
	EmitHelpers(buf *bytes.Buffer, helpers []Helper) error
}

type ConversionEngine interface {
	GenerateConversionFunction(source, target *TypeInfo, rule *config.ConversionRule) (*GeneratedCode, []*ConversionTask, error)
	GenerateSliceConversion(source, target *TypeInfo) (*GeneratedCode, []*ConversionTask, error)
	GetStubsToGenerate() map[string]*ConversionTask
}

type ConversionTask struct {
	Source *TypeInfo
	Target *TypeInfo
	Rule   *config.ConversionRule
}

type ExecutionPlan struct {
	FinalConfig *config.Config
	ActiveRules []*config.ConversionRule
}

type FieldInfo struct {
	Name       string
	Type       *TypeInfo
	Tag        string
	IsEmbedded bool
}

type GeneratedCode struct {
	FunctionBody    string
	RequiredHelpers []Helper
}

type GenerationResponse struct {
	GeneratedCode    []byte
	CustomStubs      []byte
	RequiredPackages []string
}

type Helper struct {
	Name         string
	SourceType   string
	TargetType   string
	Body         string
	Dependencies []string
}

type ImportManager interface {
	Add(pkgPath string) string
	AddAs(pkgPath, alias string) string
	GetAlias(pkgPath string) (string, bool)
	GetAllImports() map[string]string
	PackageName(pkg *types.Package) string
}

type MethodInfo struct {
	Name      string
	Signature *SignatureInfo
}

type NameGenerator interface {
	ConversionFunctionName(source, target *TypeInfo) string
	FieldConversionFunctionName(sourceParent, targetParent *TypeInfo, sourceField, targetField *FieldInfo) string
}

type Planner interface {
	Plan(initialConfig *config.Config, typeInfos map[string]*TypeInfo) *ExecutionPlan
}

type SignatureInfo struct {
	Params     []*TypeInfo
	Results    []*TypeInfo
	IsVariadic bool
}

type TypeAnalyzer interface {
	Analyze(sourceDir string) (*AnalysisResult, error)
}

type TypeConverter interface {
	GetConcreteType(info *TypeInfo) *TypeInfo
	GetEffectiveType(info *TypeInfo) *TypeInfo
	GetElementType(info *TypeInfo) *TypeInfo
	GetSliceElementType(info *TypeInfo) *TypeInfo
	GetKeyType(info *TypeInfo) *TypeInfo
	IsUltimatelyPrimitive(info *TypeInfo) bool
	IsPurelyPrimitiveOrCompositeOfPrimitives(info *TypeInfo) bool
}

type TypeFormatter interface {
	Format(info *TypeInfo) string
	FormatWithoutAlias(info *TypeInfo) string
}

type TypeInfo struct {
	Name       string
	ImportPath string
	Kind       TypeKind
	ArrayLen   int
	Underlying *TypeInfo
	KeyType    *TypeInfo
	IsAlias    bool
	Fields     []*FieldInfo
	Methods    []*MethodInfo
	Original   types.Object
}

type TypeKind int