datarepo

type AppTableSetter interface {
	// RegisterAppTables processes the schemata of the specified
	// app's tables, which this interface creates and/or manages.
	//  - Multiple calls to this func do not conflict, whether
	//    with tables previously specified or not before seen
	//  - If a table name is repeated but with a different schema,
	//    the result is undefined
	//  - If the tables already exist in the DB, it is not verified
	//    that their structure matches what this schema specifies
	//    (but this might be a future TODO)
	RegisterAppTables(string, []*DRM.TableDetails) error
	// EmptyAllTables deletes (app-level) data from the app's tables
	// but does not delete any tables (i.e. no DROP TABLE are done).
	EmptyAppTables() error
	// CreateTables creates the app's tables per already-supplied
	// schema(ta); if the tables exist, they are emptied of data.
	CreateAppTables() error
}

type Backupable interface {
	MoveToBackup() (string, error)
	CopyToBackup() (string, error)
	RestoreFromMostRecentBackup() (string, error)
}

type Caller[T DRM.RowModel] interface {
	BeginImmed() error
	DoSelectByIdGeneric(SimpleRepo, int, T) (bool, error)
	DoInsertGeneric(SimpleRepo, T) (int, error)
}

type DBEnginer interface {
	// EngineUnique works on/with a single DB record.
	EngineUnique(dbOp string, tableName string,
		anID int, RM DRM.RowModel) (int, error)
}

type DBManager interface {
	OpenAtPath(string) (SimpleRepo, error)
	NewAtPath(string) (SimpleRepo, error)
	OpenExistingAtPath(string) (SimpleRepo, error)
	// InitznPragmas is assumed to be multiline
	InitznPragmas() string
	// ReadonlyPragma is assumed to be a single pragma
	// that returns some sort of status message
	ReadonlyPragma() string
}

type Entity interface {
	// Handle (noun) is the handle to the DB.
	Handle() *sql.DB
	// Type has value [dsmnd.DB_SQLite] ("sqlite", equiv.to "sqlite3").
	Type() D.DB_type
	// Path is the file/URL (or dir/URL, if uses multiple files) to the DB.
	Path() string
	// IsURL is false for a local SQLite file.
	IsURL() bool
	// IsSingleFile is true for SQLite.
	IsSingleFile() bool
}

type FieldValuePair struct {
	Field string
	Value string
}

type GenericRepo[T any] interface {
	Create(T) T
	GetAll() []T
	GetByID(uint) (T, error)
	UpdateByID(uint, T) (T, error)
	DeleteByID(uint) (bool, error)
	GetSome(string) []T
}

type Init9nArgs struct {
	// D.DB_type is so far only D.DB_SQLite = "sqlite"
	D.DB_type
	// BaseFilename defaults to "m5.db"
	BaseFilename string
	Dir          string

	// DoImport requires DB access, so it is present
	// here, but it is not otherwise processed here.
	DoImport bool
	// DoZeroOut says initialize the DB with the
	// app's tables but with no data in them
	DoZeroOut bool
	// DoBackup says before DoingZeroOut on an
	// existing DB, first copy it to a backup
	// copy using a hard-coded naming scheme
	DoBackup bool
	// TableDetailz are app tables' details
	TableDetailz []*DRM.TableDetails
}

type QuerySpec struct {
	DBOp  string
	Table string
	Id1   int
	IdN   []int
	IsAnd bool // Irrelevant when only one condition
	// Conditions is AND-or-OR of (e.g.)
	// { FieldName, "<= Zork" } .
	// For SELECT, is a map[string]nils
	Conditions map[string]string
}

type SessionLifecycler interface {
	// Open is called on an existing repo file, and can be called
	// multiple times in a sessions, so it should not do pragma-style
	// initialization; however, options passed in the connection
	// string (such as SQLite's "...?foreign_keys=on") are kosher.
	Open() error
	SetLogWriter(io.Writer) io.Writer
	// DoPragmas is provided mainly for use in initialization,
	// but it is not included by default in any other functions
	// in this interface because of variations in usage of pragmas.
	// It is the therefore the sole responsibility of a caller to
	// determine which pragmas(s) to execute, and when.
	DoPragmas(string) (string, error)
	// IsOpen also pings the DB as a health check.
	IsOpen() bool
	// Verify runs app-level sanity & consistency checks (but things
	// like foreign key integtrity should be delegated to DB setup).
	Verify() error
	Flush() error
	// Close remembers the path (like [os.File] does).
	Close() error
	CloseLogWriter()
}

type SimpleRepo interface {
	// Entity is the Repo's basics: type, path, etc.
	Entity
	// Backupable is copy, move, restoreFrom
	Backupable
	// SessionLifecycler is open, close, etc.
	SessionLifecycler
	// StatementBuilder uses [TableDescriptor] and [QuerySpec]
	StatementBuilder

	// AppTableSetter is table mgmt for a specific Repo-using app.
	AppTableSetter
	// DBEnginer is basic DB ops.
	DBEnginer
	LogWriter() io.Writer
}

type StatementBuilder interface {
	// BuildQueryStmt(*DRU.QuerySpec) (string, error)
	NewCreateTableStmt(*DRM.TableDetails) (string, error)
}

type StatementBuilder_generics[T DRM.RowModel] interface {
	// BuildQueryStmt(*DRU.QuerySpec) (string, error)
	NewCreateTableStmt(T) (string, error)
	NewSelectByIdStmt(T, int) (string, error)
}