export

type Dialect interface {
	SelectBatch(args *SelectBatch) (*Snippet, error)
	SelectRows(args *SelectRows) (*Snippet, error)
	InsertRows(args *InsertRows) (*Snippet, error)
	// contains filtered or unexported methods
}

type Exporter struct {
	Reader Reader
	Writer Writer
	// Mapper maps old ids to new ids.
	Mapper Mapper
	// RowTransformer may be provided as a hook to modify rows before they are inserted.
	RowTransformer RowTransformer
	Schema         *Schema
	Logger         *logiface.Logger[logiface.Event]
	// Offset provides an initial offset, to start querying from.
	Offset map[string]int64
	// Filters further restrict the target data set.
	Filters []*Snippet
	// BatchSize configures the max limit, and defaults to DefaultBatchSize if 0.
	BatchSize int
	// MaxSelectIn configures the maximum number of IDs to "SELECT ... WHERE <id> in (...<values>)".
	// If zero it defaults to the (resolved) batch size.
	MaxSelectIn int
	// MaxOffsetConditions configures the maximum number of offsets columns to support.
	// Default is unlimited.
	MaxOffsetConditions int
}

type InsertRows struct {
	Schema  *Schema
	Table   Table
	Columns []string
	Values  []any
}

type JoinRef struct {
	// Alias represents the joined table.
	Alias string

	// Column is the column name, in ONE OF Alias's table OR the parent Target's table, depending on Reverse.
	Column string

	// Reverse is set to true to indicate that Column belongs to the parent Target, rather than Alias.
	Reverse bool
}

type Mapper interface {
	Load(ctx context.Context, table Table, src int64) (dst int64, ok bool, err error)
	Store(ctx context.Context, table Table, src, dst int64) error
}

type Reader interface {
	Dialect
	// contains filtered or unexported methods
}

type ReaderImpl[C databaseReader[R], R Rows] struct {
	Dialect
	DB C
}

type Result interface {
	LastInsertId() (int64, error)
	RowsAffected() (int64, error)
}

type Row struct {
	Schema     *Schema
	Table      Table
	Columns    []string
	Values     []any
	PrimaryKey int64
}

type RowTransformer interface {
	TransformRow(ctx context.Context, row *Row) error
}

type Rows interface {
	Close() error
	Columns() ([]string, error)
	Err() error
	Next() bool
	Scan(dest ...any) error
}

type Schema struct {
	Template     *Template
	PrimaryKeys  map[Table]string
	ForeignKeys  map[Table]map[string]Table
	Dependencies map[Table][]Table
	// AliasOrder contains each key from Template.Targets, sorted by Target.Order + string sort.
	// Target.Order is in descending order (larger number first), and is higher priority than the string sort.
	// It is to be used control evaluation of the "offset" conditions in the SelectBatch WHERE clause, which, by
	// nature, must align with specific ORDER BY expressions.
	AliasOrder []string
}

type SelectBatch struct {
	Schema              *Schema
	Offset              map[string]int64
	Filters             []*Snippet
	Limit               uint64
	MaxOffsetConditions int
}

type SelectRows struct {
	Schema *Schema
	Table  Table
	IDs    []int64
}

type SimpleMapper map[Table]map[int64]int64

type Snippet struct {
	SQL  string
	Args []any
}

type Table struct {
	Schema string
	Name   string
}

type Target struct {
	// ForeignKey is optional, and models the join condition for this Target.
	ForeignKey *JoinRef
	Table      Table
	// PrimaryKey is the column of the table's primary key. It's after SELECT and (in some cases) ON.
	PrimaryKey string
	// Order is used to indicate the order of the predicates (expressions in WHERE and ORDER BY).
	// Larger numbers should appear first.
	Order int
}

type Template struct {
	// Targets are all joined tables with alias (can include the same table more than once).
	Targets map[string]*Target

	// Filters are SQL snippets to AND together in groups, to filter the batch data set.
	Filters []*Snippet
}

type UnimplementedDialect struct{}

type Writer interface {
	Dialect
	// contains filtered or unexported methods
}

type WriterImpl[C databaseWriter[R], R Result] struct {
	Dialect
	DB C
}