model

type ApiResponse[T any] struct {
	Success bool   `json:"success"`
	Data    T      `json:"data"`
	Message string `json:"message,omitempty"`
	Error   string `json:"error,omitempty"`
}

type CreateMigrationReq struct {
	Name        string                               `json:"name"        validate:"required"`
	Description string                               `json:"description"`
	Plan        targetmodel.TargetDataMigrationModel `json:"plan"        validate:"required"`

	// DBMSOnFailure decides what happens to a DBMS target when one of its
	// database items fails. It is named for the DBMS domain because only that
	// domain has an undo step: a filesystem or object storage transfer leaves
	// whatever it had already written, with or without this field.
	//
	// "cleanup" (the default) undoes the failed item. "keep" leaves it in place
	// for inspection — useful when the failure is in the data rather than in the
	// connection, since cleanup destroys the evidence.
	//
	// Cancellation is not a failure and always cleans up, whatever this says.
	DBMSOnFailure string `json:"dbmsOnFailure,omitempty" validate:"omitempty,oneof=cleanup keep"`

	// StagingDir is the local directory, on the cm-centipede host, that
	// transfers stage data under when they cannot go straight from source to
	// destination: a filesystem or object storage relay, a cross-storage
	// transfer, a DBMS dump. Must be an absolute path; it is created if missing.
	// Empty uses centipede.migration.stagingDir from the configuration, and when
	// that is empty too, $TMPDIR/datamig-staging or /tmp/datamig-staging.
	StagingDir string `json:"stagingDir,omitempty" example:"/data/centipede-staging"`

	// Concurrency is how many transfers each item runs at once: rsync processes
	// for a filesystem, objects and the parts of one object for object storage,
	// restore connections for a database. 1 to 32; empty or 0 uses
	// centipede.migration.concurrency from the configuration, and when that is
	// unset too, 4. Each item runs at most what its environment allows and logs
	// what it ran at; a MySQL or PostgreSQL restore over an SSH tunnel runs one
	// stream whatever this says.
	Concurrency int `json:"concurrency,omitempty" example:"8"`
}

type ListResponse[T any] struct {
	Total    int64 `json:"total"`
	Page     int   `json:"page"`
	PageSize int   `json:"pageSize"`
	Items    []T   `json:"items"`
}

type Migration struct {
	ID          string                               `gorm:"primaryKey"                                         json:"id"`
	Name        string                               `gorm:"index:,column:name,unique;type:text collate nocase" json:"name"        validate:"required"`
	Description string                               `gorm:"column:description"                                 json:"description"`
	Plan        targetmodel.TargetDataMigrationModel `gorm:"column:plan;serializer:json"                        json:"plan"        validate:"required"`

	// DBMSOnFailure is carried on the record rather than only on the request
	// because execution is asynchronous and a retry re-reads the row: the policy
	// has to outlive the call that set it. Empty means DBMSOnFailureCleanup.
	DBMSOnFailure string `gorm:"column:dbms_on_failure" json:"dbmsOnFailure,omitempty"`

	// StagingDir is the staging root the request named, kept as given for the
	// same reason as DBMSOnFailure. Empty means the server's configured default,
	// resolved when the migration runs.
	StagingDir string `gorm:"column:staging_dir" json:"stagingDir,omitempty"`

	// Concurrency is the concurrency the request named, kept as given for the
	// same reason as DBMSOnFailure. Zero means the server's configured default,
	// resolved when the migration runs. What each item actually ran at is on its
	// log row (MigrationLog.AppliedConcurrency).
	Concurrency int `gorm:"column:concurrency" json:"concurrency,omitempty"`

	Status        string `gorm:"column:status"         json:"status"`
	StatusMessage string `gorm:"column:status_message" json:"statusMessage,omitempty"`

	TotalItems       int64 `gorm:"column:total_items"       json:"totalItems"`
	ProcessedItems   int64 `gorm:"column:processed_items"   json:"processedItems"`
	FailedItems      int64 `gorm:"column:failed_items"      json:"failedItems"`
	TransferredBytes int64 `gorm:"column:transferred_bytes" json:"transferredBytes"`

	// CurrentObject is the file, object or table being moved right now — one level
	// below ItemPath, which names the folder, bucket or database. Empty when
	// nothing is in flight.
	CurrentObject string `gorm:"column:current_object" json:"currentObject,omitempty"`

	// CurrentStep is the step of the item's transfer that CurrentObject and the
	// in-flight part of TransferredBytes belong to, and CurrentSteps how many it
	// has: a relay's 1/2 stages through local storage, its 2/2 sends to the
	// destination, and each counts its bytes from zero. Zero when nothing is in
	// flight or the transfer has no steps to report (DBMS).
	CurrentStep  int `gorm:"column:current_step"  json:"currentStep,omitempty"`
	CurrentSteps int `gorm:"column:current_steps" json:"currentSteps,omitempty"`

	// CurrentStepName names CurrentStep when the transfer has a word for it: a
	// database's "dumping" and "restoring". Empty for a file transfer.
	CurrentStepName string `gorm:"column:current_step_name" json:"currentStepName,omitempty"`
	// CurrentStepDetail is what CurrentStep is doing beyond its name, where
	// the transfer says: a restore's "indexes deferred: 2 tables" while it
	// writes rows with those tables' indexes held back, then "rebuilding
	// indexes". Empty otherwise.
	CurrentStepDetail string `gorm:"column:current_step_detail" json:"currentStepDetail,omitempty"`
	// CurrentUnits counts the tables (or collections) of the item in flight
	// that its current step has finished, out of CurrentUnitsTotal;
	// CurrentRows the rows it has written; CurrentBytesTotal what the in-flight
	// part of TransferredBytes is counting towards — the dump a restore reads.
	// Databases only, and zero wherever the step cannot tell: a restore through
	// a CLI over SSH counts bytes alone.
	CurrentUnits      int   `gorm:"column:current_units"       json:"currentUnits,omitempty"`
	CurrentUnitsTotal int   `gorm:"column:current_units_total" json:"currentUnitsTotal,omitempty"`
	CurrentRows       int64 `gorm:"column:current_rows"        json:"currentRows,omitempty"`
	CurrentBytesTotal int64 `gorm:"column:current_bytes_total" json:"currentBytesTotal,omitempty"`

	ValidationStatus  string                 `gorm:"column:validation_status"              json:"validationStatus,omitempty"`
	ValidationMessage string                 `gorm:"column:validation_message"             json:"validationMessage,omitempty"`
	ValidationDetails []ValidationDetailItem `gorm:"column:validation_details;serializer:json" json:"validationDetails,omitempty"`
	// ValidationMode is how filesystem items were compared — "quick" (size and
	// modification time) or "checksum" (size and SHA256). Object storage,
	// databases and cross-storage items are compared one way whatever it says.
	ValidationMode string `gorm:"column:validation_mode" json:"validationMode,omitempty"`
	// ValidationStartedAt is when the latest validation started, so a running
	// one can show how long it has been going.
	ValidationStartedAt *time.Time `gorm:"column:validation_started_at" json:"validationStartedAt,omitempty"`

	StartedAt   *time.Time `gorm:"column:started_at"         json:"startedAt,omitempty"`
	CompletedAt *time.Time `gorm:"column:completed_at"       json:"completedAt,omitempty"`
	// CreatedAt is indexed because it is both the list ordering key and the only
	// column the date filters compare against: without the index every list call
	// is a full scan plus a sort.
	CreatedAt time.Time `gorm:"column:created_at;index" json:"createdAt"`
	UpdatedAt time.Time `gorm:"column:updated_at"       json:"updatedAt"`
}

type MigrationListFilter struct {
	// Status filters on the status column. Empty means no filter; an unknown
	// value is not rejected and simply matches nothing.
	Status string

	// DateFrom is the inclusive lower bound on created_at. Empty means none.
	DateFrom string

	// DateToExcl is the *exclusive* upper bound on created_at: the requested
	// dateTo plus one day, since dateTo includes its own day. Empty means none.
	DateToExcl string

	// DateParamGiven records that the request carried at least one of dateFrom,
	// dateTo or lastDays — lastDays=0 included, which asks for no window at
	// all. ApplyDefaultWindow leaves such a filter untouched.
	DateParamGiven bool
}

type MigrationLog struct {
	ID          uint   `gorm:"primaryKey;autoIncrement"  json:"id"`
	MigrationID string `gorm:"column:migration_id;index" json:"migrationId"`

	// PlanEntryID names the plan entry this item came from
	// (targetmodel.Migration*Model.PlanEntryID). ItemPath alone does not identify
	// it: two entries of one plan legitimately carry the same path — one source
	// fanned out to two destinations, or two sources that scanned the same
	// directory — and their log lines were indistinguishable.
	//
	// It is the only thing about the entry kept here. Which host the item was
	// read from, where it was written and under what rules are all in the plan,
	// which GET /centipede/migration/{id} returns beside these logs; copying any
	// of it into every row would not save the reader that lookup.
	//
	// Not indexed: nothing queries by it. One migration's logs are read whole, by
	// the list endpoint and by the retry that groups them in memory, so an index
	// here would only be paid for on every insert.
	//
	// Empty on rows written before this field existed.
	PlanEntryID string `gorm:"column:plan_entry_id"      json:"planEntryId,omitempty"`

	// ItemPath: absolute file path (SSH) | object key (ObjectStorage) | table/collection name (DBMS)
	ItemPath   string `gorm:"column:item_path"          json:"itemPath"`
	Status     string `gorm:"column:status"             json:"status"`
	ErrorMsg   string `gorm:"column:error_msg"          json:"errorMsg,omitempty"`
	SizeBytes  int64  `gorm:"column:size_bytes"         json:"sizeBytes,omitempty"`
	DurationMs int64  `gorm:"column:duration_ms"        json:"durationMs"`

	// FailedObjectKind and FailedObjectName name the object data-mig was
	// working on when the item failed — a table, view, routine, file or object —
	// so the failure can be located without reading ErrorMsg. FailedObjectName
	// carries the enclosing database, schema or bucket when data-mig knew it
	// ("centipede_test.v_customer_stats").
	//
	// Both stay empty when the failure was not tied to a single object: a
	// connection refused, a dump command that failed as a whole.
	FailedObjectKind string `gorm:"column:failed_object_kind" json:"failedObjectKind,omitempty"`
	FailedObjectName string `gorm:"column:failed_object_name" json:"failedObjectName,omitempty"`

	// TargetCreated records that this item's target database did not exist before
	// the migration and does because of it, which is what decides whether a failure
	// dropped the database or emptied it. DBMS items only.
	//
	// It is not a record of who ran a DDL statement. On MongoDB nobody does: a
	// database begins to exist when the restore writes its first collection, and
	// the flag is true there all the same, because dropping is still what undoing
	// the item means.
	TargetCreated bool `gorm:"column:target_created" json:"targetCreated,omitempty"`

	// RollbackStatus reports the cleanup that followed a failure. What it refers
	// to depends on TargetCreated: emptying a database that already existed
	// (false), or dropping one centipede created (true).
	RollbackStatus   string `gorm:"column:rollback_status"    json:"rollbackStatus,omitempty"`
	RollbackErrorMsg string `gorm:"column:rollback_error_msg" json:"rollbackErrorMsg,omitempty"`

	// AppliedConcurrency is how many transfers this item ran at once, as
	// data-mig settled on them, and ConcurrencyNote why that is not what the
	// migration asked for, when it is not: "capped from 16: ssh MaxSessions", or
	// a restore through a CLI over SSH, which runs one stream. Zero when the
	// item did not report it — rows written before this field existed among them.
	AppliedConcurrency int    `gorm:"column:applied_concurrency" json:"appliedConcurrency,omitempty"`
	ConcurrencyNote    string `gorm:"column:concurrency_note"    json:"concurrencyNote,omitempty"`

	CreatedAt time.Time `gorm:"column:created_at" json:"createdAt"`
}

type MigrationSummary struct {
	ID          string      `json:"id"`
	Name        string      `json:"name"`
	Description string      `json:"description"`
	PlanSummary PlanSummary `json:"planSummary"`

	DBMSOnFailure string `json:"dbmsOnFailure,omitempty"`
	StagingDir    string `json:"stagingDir,omitempty"`
	Concurrency   int    `json:"concurrency,omitempty"`

	Status        string `json:"status"`
	StatusMessage string `json:"statusMessage,omitempty"`

	TotalItems       int64  `json:"totalItems"`
	ProcessedItems   int64  `json:"processedItems"`
	FailedItems      int64  `json:"failedItems"`
	TransferredBytes int64  `json:"transferredBytes"`
	CurrentObject    string `json:"currentObject,omitempty"`
	CurrentStep      int    `json:"currentStep,omitempty"`
	CurrentSteps     int    `json:"currentSteps,omitempty"`

	CurrentStepName   string `json:"currentStepName,omitempty"`
	CurrentStepDetail string `json:"currentStepDetail,omitempty"`
	CurrentUnits      int    `json:"currentUnits,omitempty"`
	CurrentUnitsTotal int    `json:"currentUnitsTotal,omitempty"`
	CurrentRows       int64  `json:"currentRows,omitempty"`
	CurrentBytesTotal int64  `json:"currentBytesTotal,omitempty"`

	ValidationStatus  string                 `json:"validationStatus,omitempty"`
	ValidationMessage string                 `json:"validationMessage,omitempty"`
	ValidationDetails []ValidationDetailItem `json:"validationDetails,omitempty"`
	ValidationMode    string                 `json:"validationMode,omitempty"`

	ValidationStartedAt *time.Time `json:"validationStartedAt,omitempty"`

	StartedAt   *time.Time `json:"startedAt,omitempty"`
	CompletedAt *time.Time `json:"completedAt,omitempty"`
	CreatedAt   time.Time  `json:"createdAt"`
	UpdatedAt   time.Time  `json:"updatedAt"`
}

type PlanEntry struct {
	SrcConnection commonmodel.ConnectionRef `json:"srcConnection" validate:"required"`
	DstConnection commonmodel.ConnectionRef `json:"dstConnection" validate:"required"`

	// FileSystemStrategy is the transfer strategy applied to filesystem (SSH→SSH)
	// tasks. Empty is normalised to "direct" (agent-forward: the source host
	// sends straight to the destination, with nothing staged here). Object
	// storage tasks take ObjectStorageStrategy instead; DBMS tasks have none.
	FileSystemStrategy  string                           `json:"fileSystemStrategy,omitempty" validate:"omitempty,oneof=auto direct relay"`
	FileSystemFilter    *commonmodel.FileSystemFilter    `json:"fileSystemFilter,omitempty"`
	ObjectStorageFilter *commonmodel.ObjectStorageFilter `json:"objectStorageFilter,omitempty"`
	DBMSFilter          *commonmodel.DBMSFilter          `json:"dbmsFilter,omitempty"`

	// ObjectStorageStrategy is the transfer strategy applied to object storage
	// (S3→S3) tasks. Empty is normalised to "direct": each object streams from
	// source to destination, with nothing staged here. "relay" downloads to
	// local staging first, then uploads. It has no effect on objectstorage→
	// filesystem cross-storage, which always relays.
	ObjectStorageStrategy string `json:"objectStorageStrategy,omitempty" validate:"omitempty,oneof=auto direct relay"`
}

type PlanSummary struct {
	FileSystems    int `json:"fileSystems"`
	ObjectStorages int `json:"objectStorages"`
	Databases      int `json:"databases"`
	// CrossStorage counts the entries above that land on the other storage
	// type: a file system into object storage, or object storage onto a file
	// system. Validation compares those by path and size only, so a screen
	// offering a validation mode needs to know without reading the plan.
	CrossStorage int `json:"crossStorage"`
}

type RetryReq struct {
	RetryMode string `json:"retryMode,omitempty"`
}

type RetryResponse struct {
	OriginalMigrationID string    `json:"originalMigrationId"`
	NewMigration        Migration `json:"newMigration"`
}

type SimpleMessageResponse struct {
	Message string `json:"message"`
}

type StartValidationRequest struct {
	// Mode is how filesystem items are compared: "quick" (size and
	// modification time, seconds; the default) or "checksum" (size and SHA256
	// of every migrated file). Object storage, databases and cross-storage
	// items (compared by path and size) are compared one way whatever it says.
	Mode string `json:"mode,omitempty" enums:"quick,checksum" example:"quick"`
}

type TargetPlanReq struct {
	Source sourcemodel.SourceDataMigrationModel `json:"source" validate:"required"`
	Plans  []PlanEntry                          `json:"plans"  validate:"required,min=1"`
}

type ValidationDetailItem struct {
	// PlanEntryID names the plan entry this detail is about, the same id
	// MigrationLog carries. Without it a plan of several entries reports every
	// one of them under the same ItemPath — "filesystem" for a whole entry that
	// could not be resolved — and nothing says which.
	PlanEntryID string `json:"planEntryId,omitempty"`
	// ItemPath: file path | object key | DBMS target
	// ("{database}/{table}", "{database}/{table}.{column}", "{database}/{kind}:{name}").
	ItemPath string `json:"itemPath"`
	// Status: "passed" | "failed" | "warning". A warning is reported but does not
	// fail the validation — a character-set difference can be a managed service
	// imposing its own default.
	Status  string `json:"status"`
	Message string `json:"message,omitempty"`
}

type ValidationResultResponse struct {
	ValidationStatus string `json:"validationStatus"` // "passed" | "failed" | "not_run" | "running"
	// ValidationMessage is the result's summary once the validation has
	// finished, and while it runs, where it has got to — refreshed every few
	// seconds.
	ValidationMessage string                 `json:"validationMessage,omitempty"`
	Details           []ValidationDetailItem `json:"details,omitempty"` // list of failed items
	Mode              string                 `json:"mode,omitempty"`    // "quick" | "checksum": how filesystem items were compared
	StartedAt         *time.Time             `json:"startedAt,omitempty"`
}