checkpoint

type BackupKeyType = string

type BackupValueType = RangeType

type CheckpointData struct {
	DureTime        time.Duration     `json:"dure-time"`
	RangeGroupMetas []*RangeGroupData `json:"range-group-metas"`
}

type CheckpointForeignKeyUpdateSQL struct {
	FKID       int64  `json:"fk-id"`
	SchemaName string `json:"schema-name"`
	TableName  string `json:"table-name"`
	FKName     string `json:"fk-name"`
	AddSQL     string `json:"add-sql"`
	AddArgs    []any  `json:"add-args"`

	OldForeignKeyFound bool `json:"-"`
	ForeignKeyUpdated  bool `json:"-"`
}

type CheckpointIngestIndexRepairSQL struct {
	IndexID    int64     `json:"index-id"`
	SchemaName ast.CIStr `json:"schema-name"`
	TableName  ast.CIStr `json:"table-name"`
	IndexName  string    `json:"index-name"`
	AddSQL     string    `json:"add-sql"`
	AddArgs    []any     `json:"add-args"`

	OldIndexIDFound bool `json:"-"`
	IndexRepaired   bool `json:"-"`
}

type CheckpointIngestIndexRepairSQLs struct {
	SQLs   []CheckpointIngestIndexRepairSQL
	FKSQLs []CheckpointForeignKeyUpdateSQL
}

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

type CheckpointLock struct {
	LockId   uint64 `json:"lock-id"`
	ExpireAt int64  `json:"expire-at"`
}

type CheckpointMessage[K KeyType, V ValueType] struct {
	// start-key of the origin range
	GroupKey K

	Group []V
}

type CheckpointMetadataForBackup struct {
	GCServiceId string `json:"gc-service-id"`
	ConfigHash  []byte `json:"config-hash"`
	BackupTS    uint64 `json:"backup-ts"`

	CheckpointChecksum    map[int64]*ChecksumItem `json:"-"`
	LoadCheckpointDataMap bool                    `json:"-"`
}

type CheckpointMetadataForLogRestore struct {
	UpstreamClusterID uint64 `json:"upstream-cluster-id"`
	RestoredTS        uint64 `json:"restored-ts"`
	StartTS           uint64 `json:"start-ts"`
	RewriteTS         uint64 `json:"rewrite-ts"`
	GcRatio           string `json:"gc-ratio"`
	// tiflash recorder items with snapshot restore records
	TiFlashItems map[int64]model.TiFlashReplicaInfo `json:"tiflash-recorder,omitempty"`
}

type CheckpointMetadataForSnapshotRestore struct {
	UpstreamClusterID uint64                `json:"upstream-cluster-id"`
	RestoredTS        uint64                `json:"restored-ts"`
	LogRestoredTS     uint64                `json:"log-restored-ts"`
	SchedulersConfig  *pdutil.ClusterConfig `json:"schedulers-config"`
	Hash              []byte                `json:"hash"`
	PreallocIDs       *PreallocIDs          `json:"prealloc-ids"`

	RestoreUUID uuid.UUID `json:"restore-uuid"`
}

type CheckpointProgress struct {
	Progress RestoreProgress `json:"progress"`
}

type CheckpointRunner[K KeyType, V ValueType] struct {
	// contains filtered or unexported fields
}

type ChecksumInfo struct {
	Content  []byte        `json:"content"`
	Checksum []byte        `json:"checksum"`
	DureTime time.Duration `json:"dure-time"`
}

type ChecksumItem struct {
	TableID    int64  `json:"table-id"`
	Crc64xor   uint64 `json:"crc64-xor"`
	TotalKvs   uint64 `json:"total-kvs"`
	TotalBytes uint64 `json:"total-bytes"`
}

type ChecksumItems struct {
	Items []*ChecksumItem `json:"checksum-items"`
}

type GlobalTimer interface {
	GetTS(context.Context) (int64, int64, error)
}

type KeyType interface {
	~BackupKeyType | ~RestoreKeyType
}

type LogMetaManager[K KeyType, SV, LV ValueType, M any] interface {
	MetaManager[K, SV, LV, M]

	LoadCheckpointProgress(context.Context) (*CheckpointProgress, error)
	SaveCheckpointProgress(context.Context, *CheckpointProgress) error
	ExistsCheckpointProgress(context.Context) (bool, error)

	LoadCheckpointIngestIndexRepairSQLs(context.Context) (*CheckpointIngestIndexRepairSQLs, error)
	SaveCheckpointIngestIndexRepairSQLs(context.Context, *CheckpointIngestIndexRepairSQLs) error
	ExistsCheckpointIngestIndexRepairSQLs(context.Context) (bool, error)

	TryGetStorage() storage.ExternalStorage
}

type LogMetaManagerT = LogMetaManager[
	LogRestoreKeyType, LogRestoreValueType, LogRestoreValueMarshaled, CheckpointMetadataForLogRestore,
]

type LogRestoreKeyType = string

type LogRestoreValueMarshaled struct {
	// group index in the metadata
	Goff int `json:"goff"`
	// downstream table id -> file indexes in the group
	Foffs map[int64][]int `json:"foffs"`
}

type LogRestoreValueType struct {
	// downstream table id
	TableID int64
	// group index in the metadata
	Goff int
	// file index in the group
	Foff int
}

type MetaManager[K KeyType, SV, LV ValueType, M any] interface {
	fmt.Stringer

	LoadCheckpointData(context.Context, func(K, LV) error) (time.Duration, error)
	LoadCheckpointChecksum(context.Context) (map[int64]*ChecksumItem, time.Duration, error)
	LoadCheckpointMetadata(context.Context) (*M, error)
	SaveCheckpointMetadata(context.Context, *M) error
	ExistsCheckpointMetadata(context.Context) (bool, error)
	RemoveCheckpointData(context.Context) error

	// start checkpoint runner
	StartCheckpointRunner(
		context.Context, tickDurationConfig, func(*RangeGroup[K, SV]) ([]byte, error),
	) (*CheckpointRunner[K, SV], error)

	// close session
	Close()
}

type PreallocIDs struct {
	Start          int64
	ReusableBorder int64
	End            int64
	Hash           [32]byte
}

type RangeGroup[K KeyType, V ValueType] struct {
	GroupKey K   `json:"group-key,omitempty"`
	Group    []V `json:"groups"`
}

type RangeGroupData struct {
	RangeGroupsEncriptedData []byte
	Checksum                 []byte
	CipherIv                 []byte

	Size int
}

type RangeType struct {
	*rtree.Range
}

type RestoreKeyType = int64

type RestoreProgress int

type RestoreValueType struct {
	// the file key of a range
	RangeKey string `json:"range-key,omitempty"`
	// the file name, used for compacted restore
	Name string `json:"name,omitempty"`
}

type SnapshotMetaManagerT = MetaManager[
	RestoreKeyType, RestoreValueType, RestoreValueType, CheckpointMetadataForSnapshotRestore,
]

type StorageMetaManager[K KeyType, SV, LV ValueType, M any] struct {
	// contains filtered or unexported fields
}

type TableMetaManager[K KeyType, SV, LV ValueType, M any] struct {
	// contains filtered or unexported fields
}

type TaskInfoForLogRestore struct {
	Metadata            *CheckpointMetadataForLogRestore
	HasSnapshotMetadata bool
	// the progress for this task
	Progress RestoreProgress
}

type TimeTicker interface {
	Ch() <-chan time.Time
	Stop()
}

type ValueType any