storage

type BackendCapabilities struct {
	// Supports transactions (Begin/Commit/Rollback)
	SupportsTransactions bool

	// Supports batch operations
	SupportsBatch bool

	// Supports streaming results
	SupportsStreaming bool

	// Supports prepared statements / query caching
	SupportsPrepared bool

	// Supports schema generation
	SupportsSchemaGen bool

	// Supports seed data generation
	SupportsSeedGen bool

	// Requires external dependencies (e.g., proto files for gRPC)
	RequiresExternalDeps bool
	ExternalDepTypes     []string // e.g., ["proto"]
}

type BackendConfig struct {
	Type      BackendType
	OutputDir string
	Package   string

	// For gRPC backend
	ProtoFiles   []string
	ProtoPackage string

	// For SQL backends
	ConnectionString string

	// Generation options
	GenerateSchema bool
	GenerateSeed   bool
	GenerateMocks  bool
	GenerateTests  bool
}

type BackendGenerator interface {
	// Name returns the backend identifier.
	Name() BackendType

	// Generate produces repository implementation files.
	Generate(ctx context.Context, spec *GenerationSpec) error
}

type BackendType string

type BaseBackendGenerator struct {
	Config BackendConfig
}

type DMLTableStrategy struct{}

type DeleteInfo struct {
	Table TableRef

	// WHERE clause
	WhereFields []WhereField

	// FROM clause (for DELETE ... FROM with JOINs)
	FromTables []TableRef
	Joins      []JoinInfo

	// OUTPUT clause
	OutputColumns []string
}

type DeleteJoinStyle int

type DetectionError struct {
	Procedure string
	Line      int
	Message   string
	SQL       string
	Err       error
}

type DetectionResult struct {
	// Source info
	Procedures []ProcedureInfo

	// Extracted data
	Operations   []Operation
	Models       []Model
	Repositories []Repository

	// Issues encountered during detection
	Warnings []DetectionWarning
	Errors   []DetectionError
}

type DetectionWarning struct {
	Procedure string
	Line      int
	Message   string
	SQL       string // Relevant SQL snippet
}

type Detector interface {
	// DetectOperations scans a procedure and returns all data operations found.
	// The proc parameter should be *ast.CreateProcedure from tsqlparser.
	DetectOperations(proc interface{}) ([]Operation, error)

	// DetectModels infers models from detected operations.
	DetectModels(ops []Operation) ([]Model, error)

	// DetectRepositories generates repository specs from operations and models.
	DetectRepositories(ops []Operation, models []Model) ([]Repository, error)
}

type DetectorConfig struct {
	// Include operations that can't be fully parsed (as best-effort)
	IncludePartial bool

	// Track raw SQL for each operation (for debugging/reference)
	IncludeRawSQL bool

	// Infer optionality from SQL patterns (e.g., LEFT JOIN -> optional)
	InferOptionality bool
}

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

type ExecInfo struct {
	Procedure  string
	Schema     string
	Parameters []ExecParam
	ResultVar  string // Variable for EXEC @result = proc
}

type ExecParam struct {
	Name     string // Parameter name (if named)
	Position int    // Position (if positional)
	Variable string // Variable being passed
	Literal  string // Literal value
	IsOutput bool   // OUTPUT keyword
}

type Field struct {
	// SQL metadata
	Name    string // SQL column name (e.g., "currency_code")
	SQLType string // Original SQL type (e.g., "VARCHAR(50)")

	// Go mapping
	GoName string // Go field name in PascalCase (e.g., "CurrencyCode")
	GoType string // Go type (e.g., "string", "*string", "int32", "decimal.Decimal")

	// Optionality
	Optionality Optionality

	// Proto mapping (for gRPC backend)
	ProtoField  string // Proto field name (e.g., "currency_code")
	ProtoNumber int    // Proto field number

	// Context
	IsKey      bool   // Is this field part of a key/WHERE clause?
	IsAssigned bool   // Is this field being assigned to a variable?
	Variable   string // T-SQL variable being assigned (e.g., "@CurrencyCode")
}

type FieldMapping struct {
	ColumnName  string // SQL column name
	ColumnIndex int    // Position in result set
	ProtoField  string // Field name in response message
	ProtoType   string // Proto type
	GoType      string // Go type
}

type GenerationOutput struct {
	Files []OutputFile

	// For post-generation steps
	Commands []string // e.g., "go mod tidy", "go generate"
}

type GenerationSpec struct {
	// Source info
	SourceFiles []string // Original .sql files

	// Detected operations
	Operations []Operation

	// Generated models
	Models []Model

	// Generated repositories
	Repositories []Repository

	// Proto info (for gRPC backend)
	ProtoServices []ProtoServiceInfo

	// SQL to Proto mappings (for gRPC backend)
	ProtoMappings []SQLToProtoMapping

	// Configuration
	Config BackendConfig
}

type Generator interface {
	// GenerateInterfaces generates the repository interfaces (common for all backends).
	GenerateInterfaces(ctx context.Context, spec *GenerationSpec, w io.Writer) error

	// GenerateModels generates the model structs (common for all backends).
	GenerateModels(ctx context.Context, spec *GenerationSpec, w io.Writer) error

	// GenerateBackend generates backend-specific implementation.
	GenerateBackend(ctx context.Context, spec *GenerationSpec, backend BackendGenerator) error
}

type InsertInfo struct {
	Table   TableRef
	Columns []string

	// VALUES clause
	Values []InsertValue

	// SELECT clause (INSERT ... SELECT)
	SelectSource *SelectInfo

	// OUTPUT clause
	OutputColumns []string
	OutputInto    string // Variable or table
}

type InsertValue struct {
	Column    string
	Variable  string // T-SQL variable
	Literal   string // Literal value
	IsDefault bool   // DEFAULT keyword
}

type JoinInfo struct {
	Type       string // INNER, LEFT, RIGHT, FULL, CROSS
	Table      TableRef
	OnLeft     string // Left side of ON condition
	OnRight    string // Right side of ON condition
	IsOptional bool   // LEFT/RIGHT/FULL joins produce optional results
}

type MappingStats struct {
	TotalMethods     int
	MappedMethods    int
	UnmappedMethods  int
	HighConfidence   int // > 0.8
	MediumConfidence int // 0.5 - 0.8
	LowConfidence    int // < 0.5
	ByService        map[string]ServiceMappingStats
}

type MatchContext struct {
	ServiceName   string
	AllMessages   map[string]*ProtoMessageInfo
	AllProcedures []*Procedure
}

type MatchStrategy interface {
	Name() string
	Match(method *ProtoMethodInfo, proc *Procedure, context *MatchContext) *StrategyResult
}

type MethodMapping struct {
	ServiceName   string
	MethodName    string
	Procedure     *Procedure
	ParamMappings []ParamMapping
	ResultMapping *ResultMapping
	Confidence    float64 // 0.0 - 1.0 confidence score
	MatchReason   string  // Why this match was made
}

type MethodTemplate struct {
	// Method signature
	Name     string
	Receiver string
	Params   []ParamTemplate
	Returns  []string

	// Implementation details
	Operation Operation
	Pattern   SelectPattern

	// SQL backend
	SQL        string   // Generated SQL
	ScanFields []string // Fields to scan into

	// gRPC backend
	GRPCMethod      string // Proto method name
	RequestMapping  map[string]string
	ResponseMapping map[string]string
}

type Model struct {
	Name       string // Go struct name (e.g., "Currency")
	Table      string // Source table name
	Fields     []Field
	PrimaryKey []Field // Primary key fields
}

type MySQLDialect struct{}

type NamingConventionStrategy struct{}

type Operation struct {
	// Operation details
	Type  OperationType
	Table string // Primary table name
	Alias string // Table alias (if used)

	// Fields involved
	Fields    []Field // SELECT columns or INSERT/UPDATE fields
	KeyFields []Field // WHERE clause fields

	// For INSERT with OUTPUT or SELECT INTO
	OutputFields []Field

	// Source tracking
	Procedure string // Source stored procedure name
	Line      int    // Line number in source SQL
	RawSQL    string // Original SQL statement (for reference)

	// For EXEC operations
	CalledProcedure string  // Name of called procedure
	Parameters      []Field // Parameters passed to called procedure
}

type OperationType int

type Optionality int

type OracleDialect struct{}

type OutputFile struct {
	Path    string
	Content []byte
	Mode    int // File mode (e.g., 0644)
}

type ParamMapping struct {
	ProtoField string // Field name in request message
	ProtoType  string // Proto type
	ProcParam  string // Parameter name in procedure (without @)
	ProcType   string // SQL type
	GoType     string // Go type to use
	IsOptional bool   // Proto field is optional
	HasDefault bool   // Proc param has default
}

type ParamTemplate struct {
	Name string
	Type string
}

type ParameterSignatureStrategy struct{}

type PostgresDialect struct{}

type ProcParameter struct {
	Name         string // Without @ prefix
	SQLType      string // BIGINT, NVARCHAR(255), etc.
	GoType       string // Mapped Go type
	IsOutput     bool   // OUTPUT parameter
	HasDefault   bool   // Has default value
	DefaultValue string // Default value if any
	Position     int    // Parameter order (0-indexed)
}

type Procedure struct {
	Name       string
	Parameters []ProcParameter
	Operations []Operation // DML operations inside the procedure
	ResultSets []ResultSet // Expected result sets from SELECT statements
	RawSQL     string      // Original SQL for reference
}

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

type ProcedureInfo struct {
	Name       string
	Schema     string
	Parameters []ProcedureParam
	SourceFile string
	SourceLine int
}

type ProcedureParam struct {
	Name         string
	SQLType      string
	GoType       string
	IsOutput     bool
	HasDefault   bool
	DefaultValue string
}

type ProtoEnumInfo struct {
	Name    string
	Values  []ProtoEnumValue
	Comment string
}

type ProtoEnumValue struct {
	Name    string
	Number  int
	Comment string
}

type ProtoFieldInfo struct {
	Name      string // Field name in proto (e.g., "currency_code")
	Number    int    // Field number
	ProtoType string // Proto type (e.g., "string", "int32", "message")
	GoType    string // Generated Go type (e.g., "string", "*string", "int32", "*int32")

	// Optionality - critical for NULL handling
	IsOptional bool // Has 'optional' keyword in proto3
	IsRepeated bool // Is repeated field (generates slice)

	// For message types
	IsMessage   bool   // Is this field a message type?
	MessageType string // Full message type name (e.g., "originations.v1.dsl.Currency")

	// For map types
	IsMap      bool
	MapKeyType string
	MapValType string

	// For enums
	IsEnum   bool
	EnumType string

	// Metadata
	Comment string // Field comment from proto
}

type ProtoFile struct {
	Path      string // File path
	Package   string // Package declaration
	GoPackage string // go_package option

	Imports []string // Import statements

	Services []ProtoServiceInfo
	Messages []ProtoMessageInfo
	Enums    []ProtoEnumInfo
}

type ProtoMessageInfo struct {
	Name     string // Message name (e.g., "GetCurrencyByCodeRequest")
	FullName string // Full name with package (e.g., "originations.v1.dsl.GetCurrencyByCodeRequest")
	Package  string // Package name
	Fields   []ProtoFieldInfo
	Comment  string // Message comment

	// Nested types
	NestedMessages []ProtoMessageInfo
	NestedEnums    []ProtoEnumInfo
}

type ProtoMethodInfo struct {
	Name     string // Method name (e.g., "GetCurrencyByCode")
	FullName string // Full name with service (e.g., "CatalogService.GetCurrencyByCode")

	// Request/Response
	RequestType  string            // Request message type name
	ResponseType string            // Response message type name
	Request      *ProtoMessageInfo // Parsed request message
	Response     *ProtoMessageInfo // Parsed response message

	// Streaming
	ClientStreaming bool
	ServerStreaming bool

	// Metadata
	Comment string

	// Inferred operation type
	InferredOp OperationType // Inferred from method name (Get* -> SELECT, Create* -> INSERT, etc.)
}

type ProtoParseResult struct {
	Files []ProtoFile

	// Flattened indexes for quick lookup
	AllServices map[string]*ProtoServiceInfo // service name -> service
	AllMessages map[string]*ProtoMessageInfo // message name -> message
	AllMethods  map[string]*ProtoMethodInfo  // "Service.Method" -> method
}

type ProtoServiceInfo struct {
	Name     string // Service name (e.g., "CatalogService")
	FullName string // Full name with package
	Package  string // Package name
	Methods  []ProtoMethodInfo
	Comment  string
}

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

type Repository struct {
	Name    string // Interface name (e.g., "CurrencyRepository")
	Entity  string // Entity name (e.g., "Currency")
	Table   string // Source table
	Methods []RepositoryMethod
}

type RepositoryError struct {
	Op     string // Operation that failed
	Entity string // Entity type
	Key    string // Key value (if applicable)
	Err    error  // Underlying error
}

type RepositoryMethod struct {
	Name        string // Method name (e.g., "GetByCode")
	Operation   Operation
	InputFields []Field // Method parameters
	OutputType  string  // Return type (e.g., "*Currency", "[]Currency")
	ReturnsMany bool    // Returns slice vs single entity
}

type RepositoryTemplate struct {
	// Interface info
	InterfaceName string
	EntityName    string
	TableName     string

	// Methods to generate
	Methods []MethodTemplate

	// Backend specific
	Dialect SQLDialect

	// Proto info (for gRPC backend)
	GRPCClient  string // Client field name
	GRPCService string // Service name in proto
}

type ResultColumn struct {
	Name    string // Column name or alias
	SQLType string // If determinable
	GoType  string // Mapped Go type
	Source  string // Table.Column if identifiable
}

type ResultMapping struct {
	ResponseType    string // Proto response message name
	ResultSetIndex  int    // Which result set (0-indexed)
	NestedFieldName string // If response wraps a nested message, the field name (e.g., "customer")
	NestedTypeName  string // If response wraps a nested message, the type name (e.g., "Customer")
	IsRepeated      bool   // If true, response field is repeated (requires Query + loop, not QueryRow)
	FieldMappings   []FieldMapping
}

type ResultSet struct {
	Columns   []ResultColumn
	FromTable string // Primary table if identifiable
}

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

type SQLDialect interface {
	// Name returns the dialect name.
	Name() string

	// Placeholder returns the parameter placeholder for position n.
	// PostgreSQL: $1, $2, $3...
	// MySQL/SQLite: ?
	// Oracle: :1, :2, :3...
	// SQL Server: @p1, @p2, @p3...
	Placeholder(n int) string

	// QuoteIdentifier quotes an identifier (table/column name).
	// PostgreSQL: "name"
	// MySQL: `name`
	// SQL Server: [name]
	QuoteIdentifier(name string) string

	// TableAlias returns how to write a table alias.
	// PostgreSQL/MySQL/SQLite/SQL Server: "table AS alias" or "table alias"
	// Oracle: "table alias" (AS is forbidden!)
	TableAlias(table, alias string) string

	// SupportsTableAliasAS returns whether AS keyword is allowed for table aliases.
	// All except Oracle: true
	// Oracle: false
	SupportsTableAliasAS() bool

	// LastInsertIDMethod returns the method to get last insert ID.
	// PostgreSQL: RETURNING id
	// MySQL: LAST_INSERT_ID()
	// SQLite: last_insert_rowid()
	// SQL Server: SCOPE_IDENTITY() or OUTPUT clause
	// Oracle: RETURNING INTO
	LastInsertIDMethod() string

	// SupportsReturning returns whether INSERT ... RETURNING is supported.
	// PostgreSQL, SQLite 3.35+: true
	// MySQL, Oracle (without INTO): false
	// SQL Server: false (uses OUTPUT instead)
	SupportsReturning() bool

	// SupportsOutputClause returns whether OUTPUT clause is supported (SQL Server).
	SupportsOutputClause() bool

	// BooleanLiteral returns how to represent true/false.
	BooleanLiteral(b bool) string

	// LimitClause returns how to limit results.
	// PostgreSQL/MySQL/SQLite: LIMIT n
	// SQL Server: TOP n (in SELECT)
	// Oracle: FETCH FIRST n ROWS ONLY
	LimitClause(n int) string

	// LimitPosition returns where LIMIT goes.
	// Most: "end" (after WHERE/ORDER BY)
	// SQL Server: "select" (TOP after SELECT keyword)
	LimitPosition() string

	// OffsetFetchClause returns SQL standard OFFSET/FETCH syntax (if supported).
	// Returns empty string if not supported.
	OffsetFetchClause(offset, limit int) string

	// NullSafeEqual returns a null-safe equality operator or function.
	// PostgreSQL: IS NOT DISTINCT FROM
	// MySQL: <=>
	// SQLite: IS
	// Others: (a = b OR (a IS NULL AND b IS NULL))
	NullSafeEqual(left, right string) string

	// StringConcat returns how to concatenate strings.
	// PostgreSQL/SQLite/Oracle: ||
	// SQL Server: +
	// MySQL: CONCAT() function
	StringConcat(parts ...string) string

	// UpdateJoinSyntax returns how UPDATE with JOIN is written.
	// SQL Server: UPDATE t SET ... FROM t JOIN o ON ...
	// PostgreSQL: UPDATE t SET ... FROM o WHERE t.id = o.id
	// MySQL: UPDATE t JOIN o ON ... SET t.col = ...
	// SQLite/Oracle: subquery or not supported
	UpdateJoinSyntax() UpdateJoinStyle

	// DeleteJoinSyntax returns how DELETE with JOIN is written.
	// SQL Server: DELETE t FROM t JOIN o ON ...
	// PostgreSQL: DELETE FROM t USING o WHERE ...
	// MySQL: DELETE t FROM t JOIN o ON ...
	// SQLite/Oracle: subquery
	DeleteJoinSyntax() DeleteJoinStyle

	// UpsertSyntax returns how UPSERT/MERGE is written.
	UpsertSyntax() UpsertStyle

	// NeedsFromDual returns whether SELECT without FROM needs FROM DUAL.
	// Oracle: true
	// Others: false
	NeedsFromDual() bool

	// TypeMapping returns the native type for a Go type.
	TypeMapping(goType string) string

	// DriverName returns the database/sql driver name.
	DriverName() string

	// ConnectionStringFormat returns a sample connection string format.
	ConnectionStringFormat() string
}

type SQLServerDialect struct{}

type SQLToProtoMapping struct {
	// Source SQL
	Operation Operation

	// Target Proto
	Service     string // Service name
	Method      string // Method name
	ProtoMethod *ProtoMethodInfo

	// Field mappings: SQL column/variable -> Proto field
	RequestMapping  map[string]string // SQL field -> Request proto field
	ResponseMapping map[string]string // Response proto field -> SQL variable

	// Confidence score for automatic matching (0.0 - 1.0)
	Confidence float64

	// If confidence < 1.0, reasons for uncertainty
	MatchNotes []string
}

type SQLiteDialect struct{}

type SelectColumn struct {
	Name       string // Column name or alias
	SourceName string // Original column name (if aliased)
	Table      string // Source table (if known)
	Expression string // Full expression (for computed columns)
	IsComputed bool   // Is this a computed expression?
}

type SelectInfo struct {
	// Columns being selected
	Columns []SelectColumn

	// Tables involved
	Tables []TableRef

	// WHERE clause fields
	WhereFields []WhereField

	// Variables being assigned (SELECT @var = col)
	Assignments []VariableAssignment

	// Aggregates present
	HasAggregates bool

	// DISTINCT keyword
	IsDistinct bool

	// TOP clause
	TopCount int

	// JOINs
	Joins []JoinInfo
}

type SelectPattern int

type ServiceMappingStats struct {
	ServiceName   string
	TotalMethods  int
	MappedMethods int
	Mappings      []*MethodMapping
}

type StrategyResult struct {
	Matched    bool
	Score      float64 // 0.0 to 1.0
	Reason     string
	Confidence float64 // How confident the strategy is in its own result
}

type TableRef struct {
	Name   string
	Schema string
	Alias  string
}

type TemplateData struct {
	// Package info
	Package string
	Imports []string

	// Generation info
	GeneratedBy string
	SourceFiles []string

	// Content
	Models       []Model
	Repositories []Repository
	Operations   []Operation

	// Backend specific
	Backend BackendType
	Dialect SQLDialect

	// Proto info (for gRPC)
	ProtoPackage  string
	ProtoServices []ProtoServiceInfo
	ProtoMappings []SQLToProtoMapping
}

type UnitOfWorkSpec struct {
	Repositories    []Repository
	HasTransactions bool
}

type UpdateAssignment struct {
	Column     string
	Variable   string
	Literal    string
	Expression string // For computed updates
}

type UpdateInfo struct {
	Table TableRef

	// SET clause
	Assignments []UpdateAssignment

	// WHERE clause
	WhereFields []WhereField

	// FROM clause (for UPDATE ... FROM)
	FromTables []TableRef
	Joins      []JoinInfo

	// OUTPUT clause
	OutputColumns []string
}

type UpdateJoinStyle int

type UpsertStyle int

type VariableAssignment struct {
	Variable string // T-SQL variable (e.g., "@Name")
	Column   string // Column being assigned
	Table    string // Source table
}

type VerbEntityStrategy struct{}

type WhereField struct {
	Column      string
	Table       string // Table name or alias
	Operator    string // =, <>, <, >, LIKE, IN, IS NULL, etc.
	Variable    string // T-SQL variable (e.g., "@CustomerID")
	Literal     string // Literal value (if not variable)
	IsNullCheck bool   // IS NULL or IS NOT NULL
}