core

type ACLMetadataAdapter interface {
	// CheckPermission checks if a user has the required permission for a bucket
	// Returns true if the user's ACL permission covers the required action
	CheckPermission(c Ctx, bktID int64, uid int64, action int) (bool, error)
	// ListACLByUser lists all buckets accessible by a user
	ListACLByUser(c Ctx, uid int64) ([]*BucketACL, error)
	// PutACL adds or updates an ACL entry (bktID, uid pair) with permission
	// perm: permission flags (DR, DW, DD, MDR, MDW, MDD, or ALL)
	PutACL(c Ctx, bktID int64, uid int64, perm int) error
	// ListACL lists all ACL entries for a bucket
	ListACL(c Ctx, bktID int64) ([]*BucketACL, error)
	// DeleteACL deletes a specific ACL entry (bktID, uid pair)
	DeleteACL(c Ctx, bktID int64, uid int64) error
	// DeleteAllACL deletes all ACL entries for a bucket
	DeleteAllACL(c Ctx, bktID int64) error
}

type AccessCtrlMgr interface {
	SetAdapter(ma MetadataAdapter)

	CheckPermission(c Ctx, action int, bktID int64) error
	CheckRole(c Ctx, role uint32) error
	CheckOwn(c Ctx, bktID int64) error
}

type Admin interface {
	// 传入underlying，返回当前的，构成链式调用
	New(a Admin) Admin
	Close()

	PutBkt(c Ctx, o []*BucketInfo) error
	DeleteBkt(c Ctx, bktID int64) error
	// SetQuota Set bucket quota
	SetQuota(c Ctx, bktID int64, quota int64) error
	// 审计数据完整性：检查元数据和数据文件的一致性
	Scrub(c Ctx, bktID int64) (*ScrubResult, error)
	// 扫描脏数据：检查上传失败、机器断电导致的不完整数据
	ScanDirtyData(c Ctx, bktID int64) (*DirtyDataResult, error)
	// 合并秒传重复数据：查找并合并具有相同校验值但不同DataID的重复数据
	MergeDuplicateData(c Ctx, bktID int64) (*MergeDuplicateResult, error)
	// 碎片整理：小文件离线归并打包，打包中被删除的数据块前移
	Defragment(c Ctx, bktID int64) (*DefragmentResult, error)
	// 扫描孤立chunk：扫描文件系统中的chunk文件，检查元数据是否存在
	// delaySeconds: 延迟时间（秒），在删除前再次检查元数据
	ScanOrphanedChunks(c Ctx, bktID int64, delaySeconds int) (*ScanOrphanedChunksResult, error)

	// 用户管理
	CreateUser(c Ctx, username, password, name string, role uint32) (*UserInfo, error)
	UpdateUser(c Ctx, userID int64, username, password, name string, role *uint32) error
	DeleteUser(c Ctx, userID int64) error
	ListUsers(c Ctx) ([]*UserInfo, error)

	// PutACL adds or updates an ACL entry (bktID, uid pair) with permission
	// perm: permission flags (DR, DW, DD, MDR, MDW, MDD, or ALL)
	PutACL(c Ctx, bktID int64, uid int64, perm int) error
	// ListACL lists all ACL entries for a bucket
	ListACL(c Ctx, bktID int64) ([]*BucketACL, error)
	// DeleteACL deletes a specific ACL entry (bktID, uid pair)
	DeleteACL(c Ctx, bktID int64, uid int64) error
	// DeleteAllACL deletes all ACL entries for a bucket
	DeleteAllACL(c Ctx, bktID int64) error
	// ListACLByUser lists all buckets accessible by a user
	ListACLByUser(c Ctx, uid int64) ([]*BucketACL, error)
}

type BaseMetadataAdapter interface {
	Close()
	UserMetadataAdapter
	ACLMetadataAdapter

	SetBasePath(basePath string)
	SetBaseKey(key string)
}

type BucketACL struct {
	BktID int64 `borm:"bkt_id" json:"bkt_id,omitempty"` // Bucket ID
	UID   int64 `borm:"uid" json:"uid,omitempty"`       // User ID
	Perm  int   `borm:"perm" json:"perm,omitempty"`     // Permission flags (DR, DW, DD, MDR, MDW, MDD, or ALL)
}

type BucketInfo struct {
	ID           int64  `borm:"id" json:"i,omitempty"`  // Bucket ID
	Name         string `borm:"n" json:"n,omitempty"`   // Bucket name
	Type         int    `borm:"t" json:"t,omitempty"`   // Bucket type, 0: none, 1: normal ...
	Quota        int64  `borm:"q" json:"q,omitempty"`   // Quota, negative means unlimited
	Used         int64  `borm:"u" json:"s,omitempty"`   // Logical usage, counts original size of all versions
	RealUsed     int64  `borm:"ru" json:"ru,omitempty"` // Actual physical usage, counts actual stored data size
	LogicalUsed  int64  `borm:"lu" json:"lu,omitempty"` // Logical occupancy, counts logical size of all valid objects (not deleted, PID >= 0) considering deduplication but excluding deleted objects
	DedupSavings int64  `borm:"ds" json:"ds,omitempty"` // Instant upload space savings, counts deduplicated data savings (LogicalUsed - unique data block size)
	ChunkSize    int64  `borm:"cs" json:"cs,omitempty"` // Chunk size (bytes), must be >0 (defaults to system chunk size)

}

type BucketMetadataAdapter interface {
	PutBkt(c Ctx, o []*BucketInfo) error
	DeleteBkt(c Ctx, bktID int64) error
	GetBkt(c Ctx, ids []int64) ([]*BucketInfo, error)
	ListAllBuckets(c Ctx) ([]*BucketInfo, error) // Get all buckets (for scheduled tasks)
	// Update bucket quota and usage
	UpdateBktQuota(c Ctx, bktID int64, quota int64) error
	// Increase bucket's actual usage (when uploading data)
	IncBktRealUsed(c Ctx, bktID int64, size int64) error
	// Decrease bucket's actual usage (when deleting data)
	DecBktRealUsed(c Ctx, bktID int64, size int64) error
	// Increase bucket's logical usage (when creating objects, including instant upload)
	IncBktUsed(c Ctx, bktID int64, size int64) error
	// Decrease bucket's logical usage (when deleting objects)
	DecBktUsed(c Ctx, bktID int64, size int64) error
	// Increase bucket's logical occupancy (when creating objects, only count valid objects)
	IncBktLogicalUsed(c Ctx, bktID int64, size int64) error
	// Decrease bucket's logical occupancy (when deleting objects)
	DecBktLogicalUsed(c Ctx, bktID int64, size int64) error
	// Increase bucket's deduplication savings (saved data size from instant upload)
	IncBktDedupSavings(c Ctx, bktID int64, size int64) error
	// Decrease bucket's deduplication savings (when deleting objects)
	DecBktDedupSavings(c Ctx, bktID int64, size int64) error
}

type BucketSnapshot struct {
	ID              int64          `json:"id"`
	BucketID        int64          `json:"bucket_id"`
	Name            string         `json:"name"`
	Description     string         `json:"description,omitempty"`
	CreatedAt       int64          `json:"created_at"`
	MetadataVersion int64          `json:"metadata_version"` // Metadata version number
	SnapshotType    SnapshotType   `json:"snapshot_type"`
	Status          SnapshotStatus `json:"status"`
	FileCount       int64          `json:"file_count"`
	TotalSize       int64          `json:"total_size"`
	IsLazy          bool           `json:"is_lazy"` // Lazy copy mode
	ErrorMessage    string         `json:"error_message,omitempty"`
}

type BucketStatsDelta struct {

	// Bucket info cache (may be nil if not loaded yet)
	BucketInfo *BucketInfo `json:"-"` // Full bucket info, cached from database
	// Incremental changes (atomic)
	Used         int64  // Incremental change in Used (atomic)
	RealUsed     int64  // Incremental change in RealUsed (atomic)
	LogicalUsed  int64  // Incremental change in LogicalUsed (atomic)
	DedupSavings int64  // Incremental change in DedupSavings (instant upload space savings) (atomic)
	DataPath     string // Data path for this bucket
	// contains filtered or unexported fields
}

type Config struct {
	UserName string // Username
	Password string // Password
	NoAuth   bool   // If true, bypass authentication and permission checks (no user required)
	BasePath string // Base path for metadata (database storage location), if empty uses current directory "."
	DataPath string // Data path for file data storage location, if empty uses current directory "."
	RefLevel uint32 // Instant upload level setting: REF_LEVEL_OFF (default) / REF_LEVEL_FULL: Ref / REF_LEVEL_FAST: TryRef+Ref
	PkgThres uint32 // Package count limit, default 1000 if not set
	CmprWay  uint32 // Compression method (smart compression by default, decides whether to compress based on file type), see DATA_CMPR_MASK
	CmprQlty uint32 // Compression level, br:[0,11], gzip:[-3,9], zstd:[0,10]
	EndecWay uint32 // Encryption method, see DATA_ENDEC_MASK
	EndecKey string // Encryption KEY, SM4 requires exactly 16 characters, AES256 requires more than 16 characters
	DontSync string // Filename wildcards to exclude from sync (https://pkg.go.dev/path/filepath#Match), separated by semicolons
	Conflict uint32 // Conflict resolution for same name, CONFLICT_COVER: merge or overwrite / CONFLICT_RENAME: rename / CONFLICT_THROW: throw error / CONFLICT_SKIP: skip
	NameTmpl string // Rename suffix, "%s的副本", should contain "%s"
	WorkersN uint32 // Concurrent pool size, not less than 16

}

type CronJobConfig struct {
	// ScrubEnabled Whether to enable ScrubData scheduled task
	ScrubEnabled bool
	// ScrubSchedule Cron expression for ScrubData (format: minute hour day month weekday)
	ScrubSchedule string
	// ScrubFixOrphaned Whether to automatically fix orphaned data (files without metadata references)
	ScrubFixOrphaned bool
	// ScrubFixCorrupted Whether to automatically fix corrupted data (metadata without files)
	ScrubFixCorrupted bool
	// ScrubFixMismatchedChecksum Whether to automatically fix mismatched checksum data
	ScrubFixMismatchedChecksum bool

	// MergeEnabled Whether to enable MergeDuplicateData scheduled task
	MergeEnabled bool
	// MergeSchedule Cron expression for MergeDuplicateData
	MergeSchedule string

	// DeduplicationEnabled Whether to enable offline deduplication job
	DeduplicationEnabled bool
	// DeduplicationSchedule Cron expression for offline deduplication (default: "0 2 * * *")
	DeduplicationSchedule string

	// DefragmentEnabled Whether to enable Defragment scheduled task
	DefragmentEnabled bool
	// DefragmentSchedule Cron expression for Defragment
	DefragmentSchedule string
	// DefragmentMaxSize Maximum file size for Defragment (files smaller than this will be packed)
	DefragmentMaxSize int64
	// DefragmentAccessWindow Access window time for Defragment (seconds)
	DefragmentAccessWindow int64
	// DefragmentThreshold Space usage threshold for Defragment (percentage, 0-100)
	// Defragmentation will only be performed when fragmentation rate ((Used - RealUsed) / Used * 100) reaches this threshold
	DefragmentThreshold int64
}

type CronSchedule struct {
	Minute  []int // Minute (0-59)
	Hour    []int // Hour (0-23)
	Day     []int // Day (1-31)
	Month   []int // Month (1-12)
	Weekday []int // Weekday (0-6, 0=Sunday)
}

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

type Ctx context.Context

type DBConnectionType int

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

type DataAdapter interface {
	Close()

	SetDataPath(dataPath string)

	Write(c Ctx, bktID, dataID int64, sn int, buf []byte) error

	Read(c Ctx, bktID, dataID int64, sn int) ([]byte, error)
	ReadBytes(c Ctx, bktID, dataID int64, sn, offset, size int) ([]byte, error)
	// Delete deletes a specific data chunk (DataID + sn)
	// If the chunk doesn't exist, it returns nil (no error)
	Delete(c Ctx, bktID, dataID int64, sn int) error
}

type DataInfo struct {
	ID        int64  `borm:"id" json:"i,omitempty"`  // Data ID (randomly generated by idgen)
	Size      int64  `borm:"s" json:"s,omitempty"`   // Data size (compressed/encrypted)
	OrigSize  int64  `borm:"os" json:"r,omitempty"`  // Original data size (before compression/encryption)
	HdrXXH3   int64  `borm:"h" json:"h,omitempty"`   // XXHash3-64bit checksum of first 100KB
	XXH3      int64  `borm:"x" json:"x,omitempty"`   // XXHash3-64bit checksum of entire original data
	SHA256_0  int64  `borm:"s0" json:"s0,omitempty"` // SHA-256 hash of entire original data (bytes 0-7)
	SHA256_1  int64  `borm:"s1" json:"s1,omitempty"` // SHA-256 hash of entire original data (bytes 8-15)
	SHA256_2  int64  `borm:"s2" json:"s2,omitempty"` // SHA-256 hash of entire original data (bytes 16-23)
	SHA256_3  int64  `borm:"s3" json:"s3,omitempty"` // SHA-256 hash of entire original data (bytes 24-31)
	Kind      uint32 `borm:"k" json:"k,omitempty"`   // Data status: normal, corrupted, encrypted, compressed, type (for preview, etc.)
	PkgID     int64  `borm:"pi" json:"p,omitempty"`  // Package data ID (also generated by idgen)
	PkgOffset uint32 `borm:"po" json:"g,omitempty"`  // Offset position in package data

}

type DataInfoMetadataAdapter interface {
	RefData(c Ctx, bktID int64, d []*DataInfo) ([]int64, error)
	PutData(c Ctx, bktID int64, d []*DataInfo) error
	GetData(c Ctx, bktID, id int64) (*DataInfo, error)
	// PutDataAndObj writes both DataInfo and ObjectInfo in a single transaction
	// This optimization reduces database round trips
	PutDataAndObj(c Ctx, bktID int64, d []*DataInfo, o []*ObjectInfo) error
	ListAllData(c Ctx, bktID int64, offset, limit int) ([]*DataInfo, int64, error) // offset: offset, limit: page size, returns data and total count
	// Find duplicate data: returns DataID groups with same checksums (OrigSize, HdrXXH3, XXH3, SHA256 all same)
	FindDuplicateData(c Ctx, bktID int64, offset, limit int) ([]DuplicateGroup, int64, error) // Returns duplicate data groups and total count
	// Update object's DataID reference
	UpdateObjDataID(c Ctx, bktID int64, oldDataID, newDataID int64) error
	// Delete data metadata
	DeleteData(c Ctx, bktID int64, dataIDs []int64) error
	// Find small file data that can be packaged (for defragmentation)
	FindSmallPackageData(c Ctx, bktID int64, maxSize int64, offset, limit int) ([]*DataInfo, int64, error)
}

type DataMetadataAdapter interface {
	Close()
	BucketMetadataAdapter // Buckets are stored in bucket databases, not main database
	DataInfoMetadataAdapter
	ObjectMetadataAdapter

	SetDataPath(dataPath string)
	SetDataKey(key string)
}

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

type DeduplicationConfig struct {
	Enabled           bool          `json:"enabled"`              // Enable deduplication job
	Schedule          string        `json:"schedule"`             // Cron expression, default "0 2 * * *" (2:00 AM daily)
	PageSize          int           `json:"page_size"`            // Page size for processing, default 100
	BatchInterval     time.Duration `json:"batch_interval"`       // Interval between batches, default 100ms
	MaxDuration       time.Duration `json:"max_duration"`         // Maximum execution time, default 2 hours
	MaxItemsPerSecond int           `json:"max_items_per_second"` // Max items per second, default 100
	ConcurrentBuckets int           `json:"concurrent_buckets"`   // Number of buckets to process concurrently, default 1
}

type DeduplicationJobResult struct {
	StartTime       time.Time                       `json:"start_time"`        // Start time
	EndTime         time.Time                       `json:"end_time"`          // End time
	Duration        time.Duration                   `json:"duration"`          // Execution duration
	BucketsScanned  int                             `json:"buckets_scanned"`   // Number of buckets scanned
	BucketResults   map[int64]*MergeDuplicateResult `json:"bucket_results"`    // Results for each bucket
	TotalFreedSize  int64                           `json:"total_freed_size"`  // Total freed space (bytes)
	TotalMergedData int                             `json:"total_merged_data"` // Total merged data count
	Errors          []string                        `json:"errors"`            // Error list
}

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

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

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

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

type DefaultMetadataAdapter struct {
	*DefaultBaseMetadataAdapter
	*DefaultDataMetadataAdapter
}

type DefragmentResult struct {
	PackedGroups  int64 `json:"packed_groups"`  // 打包的组数
	PackedFiles   int64 `json:"packed_files"`   // 打包的文件数
	CompactedPkgs int64 `json:"compacted_pkgs"` // 整理的打包文件数
	FreedSize     int64 `json:"freed_size"`     // 释放的空间大小（字节）
	SkippedInUse  int64 `json:"skipped_in_use"` // 跳过正在使用的数据数
}

type DirtyDataResult struct {
	IncompleteChunks []int64 `json:"incomplete_chunks"` // 分片不完整的数据（上传过程中断电）
	UnreadableData   []int64 `json:"unreadable_data"`   // 无法读取的数据文件
}

type DuplicateGroup struct {
	OrigSize int64   // Original data size
	HdrXXH3  int64   // XXHash3-64bit checksum of first 100KB (as int64)
	XXH3     int64   // XXHash3-64bit checksum of entire original data (as int64)
	SHA256_0 int64   // SHA-256 hash bytes 0-7
	SHA256_1 int64   // SHA-256 hash bytes 8-15
	SHA256_2 int64   // SHA-256 hash bytes 16-23
	SHA256_3 int64   // SHA-256 hash bytes 24-31
	DataIDs  []int64 // List of DataIDs with same checksums
}

type Error string

type FixScrubIssuesResult struct {
	FixedCorrupted          int      `json:"fixed_corrupted"`           // 修复的损坏数据数
	FixedOrphaned           int      `json:"fixed_orphaned"`            // 修复的孤立数据数
	FixedMismatchedChecksum int      `json:"fixed_mismatched_checksum"` // 修复的校验和不匹配数据数
	FreedSize               int64    `json:"freed_size"`                // 释放的空间大小（字节）
	Errors                  []string `json:"errors"`                    // 修复过程中的错误信息
}

type Handler interface {
	// 传入underlying，返回当前的，构成链式调用
	New(h Handler) Handler
	Close()

	// 设置自定义的存储适配器
	SetAdapter(ma MetadataAdapter, da DataAdapter)
	SetAccessCtrlMgr(acm AccessCtrlMgr)

	MetadataAdapter() MetadataAdapter
	DataAdapter() DataAdapter
	AccessCtrlMgr() AccessCtrlMgr

	// 登录用户
	Login(c Ctx, usr, pwd string) (Ctx, *UserInfo, []*BucketInfo, error)

	// 只有文件长度、HdrXXH3是预Ref，如果成功返回新DataID，失败返回0
	// 有文件长度、XXH3、SHA-256，成功返回引用的DataID，失败返回0，客户端发现DataID有变化，说明不需要上传数据
	// 如果非预Ref DataID传0，说明跳过了预Ref
	Ref(c Ctx, bktID int64, d []*DataInfo) ([]int64, error)
	// PutData uploads data chunk, sn starts from 0, if dataID is 0 a new one will be created
	PutData(c Ctx, bktID, dataID int64, sn int, buf []byte) (int64, error)
	// GetData reads data: one param means sn, two params mean sn+offset, three params mean sn+offset+size
	GetData(c Ctx, bktID, id int64, sn int, offsetOrSize ...int) ([]byte, error)
	// 上传元数据
	PutDataInfo(c Ctx, bktID int64, d []*DataInfo) ([]int64, error)
	// PutDataInfoAndObj writes both DataInfo and ObjectInfo in a single transaction
	// This optimization reduces database round trips for better performance
	PutDataInfoAndObj(c Ctx, bktID int64, d []*DataInfo, o []*ObjectInfo) error
	// 获取数据信息
	GetDataInfo(c Ctx, bktID, id int64) (*DataInfo, error)

	// Name不传默认用ID字符串化后的值作为Name
	Put(c Ctx, bktID int64, o []*ObjectInfo) ([]int64, error)
	Get(c Ctx, bktID int64, ids []int64) ([]*ObjectInfo, error)
	List(c Ctx, bktID, pid int64, opt ListOptions) (o []*ObjectInfo, cnt int64, delim string, err error)

	Rename(c Ctx, bktID, id int64, name string) error
	MoveTo(c Ctx, bktID, id, pid int64) error

	// Recycle marks object as deleted to recycle bin
	// During garbage collection: data without metadata reference is dirty data (need window time)
	// Metadata without data is corrupted data
	Recycle(c Ctx, bktID, id int64) error
	// Delete permanently deletes object
	Delete(c Ctx, bktID, id int64) error
	// DeleteBatch permanently deletes multiple objects in batch for better performance
	// Returns a map of objID -> error for any failures (nil map means all succeeded)
	DeleteBatch(c Ctx, bktID int64, ids []int64) map[int64]error

	// CleanRecycleBin physically deletes objects marked as deleted in recycle bin
	CleanRecycleBin(c Ctx, bktID int64, targetID int64) error
	// ListRecycleBin lists objects in recycle bin
	ListRecycleBin(c Ctx, bktID int64, opt ListOptions) (o []*ObjectInfo, cnt int64, delim string, err error)

	// UpdateFileLatestVersion updates all files' latest version DataID, update time, size and directory size
	UpdateFileLatestVersion(c Ctx, bktID int64) error

	// GetBkt Get bucket information (for getting bucket configuration)
	GetBktInfo(c Ctx, bktID int64) (*BucketInfo, error)
	// ScanOrphanedChunks scans orphaned chunks (chunks without metadata)
	// delaySeconds: delay time in seconds before re-checking and deleting orphaned chunks
	// Returns result with orphaned chunks found and deleted
	ScanOrphanedChunks(c Ctx, bktID int64, delaySeconds int) (*ScanOrphanedChunksResult, error)
}

type InstantUploadConfig struct {
	RefLevel uint32 // Instant upload level: 0=OFF, 1=FULL, 2=FAST
}

type ListOptions struct {
	Word  string `json:"w,omitempty"` // 过滤词，支持通配符*和?
	Delim string `json:"d,omitempty"` // 分隔符，每次请求后返回，原样回传即可
	Type  int    `json:"t,omitempty"` // 对象类型，-1: malformed, 0: 不过滤(default), 1: dir, 2: file, 3: version, 4: preview(thumb/m3u8/pdf)
	Count int    `json:"c,omitempty"` // 查询个数
	Order string `json:"o,omitempty"` // 排序方式，id/mtime/name/size/type 前缀 +: 升序（默认） -: 降序
	Brief int    `json:"e,omitempty"` // 显示更少内容(只在网络传输层，节省流量时有效)，0: FULL(default), 1: without EXT, 2:only ID

}

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

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

type MergeDuplicateResult struct {
	MergedGroups int64             `json:"merged_groups"` // 合并的重复数据组数
	MergedData   []map[int64]int64 `json:"merged_data"`   // 合并的数据映射：重复DataID -> 主DataID
	FreedSize    int64             `json:"freed_size"`    // 释放的空间大小（字节）
}

type MetadataAdapter interface {
	Close()
	BaseMetadataAdapter
	DataMetadataAdapter
}

type NoAuthAccessCtrlMgr struct{}

type ObjectInfo struct {
	ID     int64  `borm:"id" json:"i,omitempty"`  // Object ID (randomly generated by idgen)
	PID    int64  `borm:"pid" json:"p,omitempty"` // Parent object ID
	MTime  int64  `borm:"m" json:"m,omitempty"`   // Update time, second-level timestamp
	DataID int64  `borm:"did" json:"d,omitempty"` // Data ID, if 0, no data (newly created file, DataID is object ID, serving as first version data)
	Type   int    `borm:"t" json:"t,omitempty"`   // Object type, -1: malformed, 0: none, 1: dir, 2: file, 3: version, 4: journal
	Name   string `borm:"n" json:"n,omitempty"`   // Object name (may be encrypted if MODE_NAME_ENCRYPTED flag is set)
	Size   int64  `borm:"s" json:"s,omitempty"`   // Object size, directory size is child object count, file size is latest version byte count
	Mode   uint32 `borm:"md" json:"md,omitempty"` // File mode (permissions and flags), 0 means use default. High bit (1<<31) indicates encrypted name
	Extra  string `borm:"e" json:"e,omitempty"`   // Object extended information
}

type ObjectMetadataAdapter interface {
	PutObj(c Ctx, bktID int64, o []*ObjectInfo) ([]int64, error)
	GetObj(c Ctx, bktID int64, ids []int64) ([]*ObjectInfo, error)
	SetObj(c Ctx, bktID int64, fields []string, o *ObjectInfo) error
	ListObj(c Ctx, bktID, pid int64, wd, delim, order string, count int) ([]*ObjectInfo, int64, string, error)
	CountDataRefs(c Ctx, bktID int64, dataIDs []int64) (map[int64]int64, error)               // Count DataID references
	DeleteObj(c Ctx, bktID int64, id int64) error                                             // Delete object (mark as deleted, flip PID to negative)
	ListDeletedObjs(c Ctx, bktID int64, beforeTime int64, limit int) ([]*ObjectInfo, error)   // List deleted objects (PID < 0)
	ListRecycleBin(c Ctx, bktID int64, opt ListOptions) ([]*ObjectInfo, int64, string, error) // List recycle bin (objects with PID < 0)
	// Query all objects of specified type (not deleted, pid >= 0)
	// offset: offset, limit: page size, returns data and total count
	ListObjsByType(c Ctx, bktID int64, objType int, offset, limit int) ([]*ObjectInfo, int64, error)
	// Query all child objects under specified directory (not deleted, pid >= 0)
	// offset: offset, limit: page size, returns data and total count
	ListChildren(c Ctx, bktID int64, pid int64, offset, limit int) ([]*ObjectInfo, int64, error)
	// Query all objects that reference the specified DataID
	GetObjByDataID(c Ctx, bktID int64, dataID int64) ([]*ObjectInfo, error)
	// Query all versions of a file (sorted by MTime descending, latest first)
	ListVersions(c Ctx, bktID int64, fileID int64) ([]*ObjectInfo, error)
	// Extended attributes (xattr) operations
	GetAttr(c Ctx, bktID int64, objID int64, key string) ([]byte, error)     // Get extended attribute value
	SetAttr(c Ctx, bktID int64, objID int64, key string, value []byte) error // Set extended attribute value
	RemoveAttr(c Ctx, bktID int64, objID int64, key string) error            // Remove extended attribute
	ListAttrs(c Ctx, bktID int64, objID int64) ([]string, error)             // List all extended attribute keys for an object
}

type ResourceControlConfig struct {
	// BatchInterval Batch interval time (milliseconds), delay between each batch processing
	// Configurable via environment variable ORCAS_BATCH_INTERVAL_MS, default 100ms
	BatchInterval time.Duration

	// MaxDuration Maximum running duration (seconds), stop processing after this time
	// Configurable via environment variable ORCAS_MAX_DURATION_SEC, default 0 means no limit
	MaxDuration time.Duration

	// MaxItemsPerSecond Maximum items processed per second, for rate limiting
	// Configurable via environment variable ORCAS_MAX_ITEMS_PER_SEC, default 0 means no limit
	MaxItemsPerSecond int

	// AdaptiveDelay Whether to enable adaptive delay, dynamically adjust delay based on processed data volume
	// Configurable via environment variable ORCAS_ADAPTIVE_DELAY (true/false), default true
	AdaptiveDelay bool

	// AdaptiveDelayFactor Adaptive delay factor, delay time = BatchInterval * (1 + processed items / factor)
	// Configurable via environment variable ORCAS_ADAPTIVE_DELAY_FACTOR, default 1000
	AdaptiveDelayFactor int64
}

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

type ScanOrphanedChunksResult struct {
	TotalScanned   int64    `json:"total_scanned"`   // 扫描的chunk总数
	OrphanedChunks []int64  `json:"orphaned_chunks"` // 孤立的chunk（dataID列表，去重）
	DeletedChunks  int      `json:"deleted_chunks"`  // 删除的chunk数量
	FreedSize      int64    `json:"freed_size"`      // 释放的空间大小（字节）
	DelayedChunks  int      `json:"delayed_chunks"`  // 延迟检查的chunk数量
	StillOrphaned  int      `json:"still_orphaned"`  // 延迟后仍然孤立的chunk数量
	Errors         []string `json:"errors"`          // 扫描过程中的错误信息
}

type ScrubResult struct {
	TotalData          int     `json:"total_data"`          // 总数据数
	CorruptedData      []int64 `json:"corrupted_data"`      // 损坏数据：有元数据但没有数据文件
	OrphanedData       []int64 `json:"orphaned_data"`       // 孤立数据：有数据文件但没有元数据引用
	MismatchedChecksum []int64 `json:"mismatched_checksum"` // 校验和不匹配的数据
}

type SnapshotConfig struct {
	Enabled          bool   // Enable snapshot feature
	AutoSnapshot     bool   // Auto snapshot
	SnapshotSchedule string // Cron expression
	MaxSnapshots     int    // Max snapshot count
	RetentionDays    int    // Retention days
	LazyMode         bool   // Lazy mode (O(1) creation)
	COWEnabled       bool   // Enable Copy-On-Write
}

type SnapshotDataAdapter interface {
	// COW 相关操作
	MarkDataAsShared(ctx Ctx, bktID, snapshotID int64) error
	MarkDataAsSharedTx(ctx Ctx, tx Transaction, bktID, snapshotID int64) error
	DecrementSnapshotDataRefs(ctx Ctx, snapshotID int64) error
	IncrementSnapshotDataRefs(ctx Ctx, snapshotID int64) error
	IncrementSnapshotDataRefsTx(ctx Ctx, tx Transaction, snapshotID int64) error
	CleanupUnreferencedData(ctx Ctx, bktID int64) error

	// COW 写入
	WriteWithCOW(ctx Ctx, bktID, objID int64, data []byte) (int64, error)
	CopyData(ctx Ctx, bktID, srcDataID, dstDataID int64) error
}

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

type SnapshotMetadataAdapter interface {
	// 事务
	BeginTransaction(ctx Ctx) (Transaction, error)

	// 快照基本操作
	InsertBucketSnapshot(ctx Ctx, snapshot *BucketSnapshot) (int64, error)
	UpdateSnapshotStatus(ctx Ctx, snapshotID int64, status SnapshotStatus) error
	UpdateSnapshotStats(ctx Ctx, snapshotID int64, fileCount, totalSize int64, status SnapshotStatus) error
	GetBucketSnapshot(ctx Ctx, snapshotID int64) (*BucketSnapshot, error)
	GetBucketSnapshotByName(ctx Ctx, bktID int64, name string) (*BucketSnapshot, error)
	ListBucketSnapshots(ctx Ctx, bktID int64, limit, offset int) ([]*BucketSnapshot, error)
	DeleteBucketSnapshot(ctx Ctx, snapshotID int64) error

	// 快照对象操作
	CopyObjectsToSnapshot(ctx Ctx, snapshotID, bktID int64) (fileCount, totalSize int64, err error)
	GetSnapshotObjects(ctx Ctx, snapshotID int64, prefix string, limit, offset int) ([]*SnapshotObject, error)
	GetObjectsByVersion(ctx Ctx, bktID, version int64, prefix string, limit, offset int) ([]*SnapshotObject, error)
	DeleteSnapshotObjects(ctx Ctx, snapshotID int64) error

	// 恢复操作
	MarkBucketObjectsAsDeleted(ctx Ctx, bktID int64) error
	RestoreObjectsFromSnapshot(ctx Ctx, snapshotID, targetBktID int64) error

	// 事务操作
	InsertBucketSnapshotTx(ctx Ctx, tx Transaction, snapshot *BucketSnapshot) (int64, error)
	CopyObjectsToSnapshotTx(ctx Ctx, tx Transaction, snapshotID, bktID int64) (fileCount, totalSize int64, err error)
	UpdateSnapshotStatsTx(ctx Ctx, tx Transaction, snapshotID int64, fileCount, totalSize int64, status SnapshotStatus) error
	MarkBucketObjectsAsDeletedTx(ctx Ctx, tx Transaction, bktID int64) error
	RestoreObjectsFromSnapshotTx(ctx Ctx, tx Transaction, snapshotID, targetBktID int64) error
}

type SnapshotObject struct {
	SnapshotID int64  `json:"snapshot_id"`
	ObjID      int64  `json:"obj_id"`
	Path       string `json:"path"`
	DataID     int64  `json:"data_id"`
	Size       int64  `json:"size"`
	MTime      int64  `json:"mtime"`
	Checksum   string `json:"checksum,omitempty"`
}

type SnapshotStatus int32

type SnapshotType int32

type Transaction interface {
	Commit() error
	Rollback() error
}

type UserInfo struct {
	ID     int64  `borm:"id" json:"i,omitempty"`     // User ID
	Usr    string `borm:"usr" json:"u,omitempty"`    // Username
	Pwd    string `borm:"pwd" json:"p,omitempty"`    // Password, encrypted using PBKDF2-HMAC-SHA256
	Role   uint32 `borm:"role" json:"r,omitempty"`   // User role: regular user / administrator
	Name   string `borm:"name" json:"n,omitempty"`   // Name
	Avatar string `borm:"avatar" json:"a,omitempty"` // Avatar
}

type UserMetadataAdapter interface {
	PutUsr(c Ctx, u *UserInfo) error
	GetUsr(c Ctx, ids []int64) ([]*UserInfo, error)
	GetUsr2(c Ctx, usr string) (*UserInfo, error)
	SetUsr(c Ctx, fields []string, u *UserInfo) error
	ListUsers(c Ctx) ([]*UserInfo, error)
	DeleteUser(c Ctx, userID int64) error
}

type WriteBufferConfig struct {
	// MaxBufferSize Maximum buffer size (bytes), exceeding this size will trigger immediate write
	// Configurable via environment variable ORCAS_MAX_WRITE_BUFFER_SIZE, default 8MB
	MaxBufferSize int64

	// MaxBufferWrites Maximum buffered write count, exceeding this count will trigger immediate write
	// Configurable via environment variable ORCAS_MAX_WRITE_BUFFER_COUNT, default 2048
	MaxBufferWrites int64

	// BufferWindow Buffer window time (seconds), multiple writes within the specified time will be merged
	// Configurable via environment variable ORCAS_WRITE_BUFFER_WINDOW_SEC, default 10 seconds
	BufferWindow time.Duration

	// BatchWriteEnabled Whether to enable batch write optimization
	// When disabled, files are written as individual objects directly
	// Configurable via environment variable ORCAS_BATCH_WRITE_ENABLED, default true
	BatchWriteEnabled bool

	// MaxBatchWriteFileSize Maximum file size for batch write optimization (bytes)
	// Files larger than this size will use direct write path
	// Based on performance tests: 1KB files benefit 155%, 1MB files degrade 9.6-65.5%
	// Optimal threshold: 64KB-128KB for best performance
	// Configurable via environment variable ORCAS_MAX_BATCH_WRITE_FILE_SIZE, default 64KB
	MaxBatchWriteFileSize int64
}