package fs

import (
	"context"
	"encoding/gob"
	"errors"
	"fmt"
	"io"
	"time"

	"github.com/cloudreve/Cloudreve/v4/ent"
	"github.com/cloudreve/Cloudreve/v4/inventory"
	"github.com/cloudreve/Cloudreve/v4/inventory/types"
	"github.com/cloudreve/Cloudreve/v4/pkg/boolset"
	"github.com/cloudreve/Cloudreve/v4/pkg/filemanager/lock"
	"github.com/cloudreve/Cloudreve/v4/pkg/hashid"
	"github.com/cloudreve/Cloudreve/v4/pkg/queue"
	"github.com/cloudreve/Cloudreve/v4/pkg/serializer"
	"github.com/gofrs/uuid"
)

type FsCapability int

const (
	FsCapabilityList = FsCapability(iota)
)

var (
	ErrDirectLinkInvalid    = serializer.NewError(serializer.CodeNotFound, "Direct link invalid", nil)
	ErrUnknownPolicyType    = serializer.NewError(serializer.CodeInternalSetting, "Unknown policy type", nil)
	ErrPathNotExist         = serializer.NewError(serializer.CodeParentNotExist, "Path not exist", nil)
	ErrFileDeleted          = serializer.NewError(serializer.CodeFileDeleted, "File deleted", nil)
	ErrEntityNotExist       = serializer.NewError(serializer.CodeEntityNotExist, "Entity not exist", nil)
	ErrFileExisted          = serializer.NewError(serializer.CodeObjectExist, "Object existed", nil)
	ErrNotSupportedAction   = serializer.NewError(serializer.CodeNoPermissionErr, "Not supported action", nil)
	ErrLockConflict         = serializer.NewError(serializer.CodeLockConflict, "Lock conflict", nil)
	ErrLockExpired          = serializer.NewError(serializer.CodeLockConflict, "Lock expired", nil)
	ErrModified             = serializer.NewError(serializer.CodeConflict, "Object conflict", nil)
	ErrIllegalObjectName    = serializer.NewError(serializer.CodeIllegalObjectName, "Invalid object name", nil)
	ErrFileSizeTooBig       = serializer.NewError(serializer.CodeFileTooLarge, "File is too large", nil)
	ErrInsufficientCapacity = serializer.NewError(serializer.CodeInsufficientCapacity, "Insufficient capacity", nil)
	ErrStaleVersion         = serializer.NewError(serializer.CodeStaleVersion, "File is updated during your edit", nil)
	ErrOwnerOnly            = serializer.NewError(serializer.CodeOwnerOnly, "Only owner or administrator can perform this action", nil)
	ErrArchiveSrcSizeTooBig = ErrFileSizeTooBig.WithError(fmt.Errorf("total size of to-be compressed file exceed group limit (%w)", queue.CriticalErr))
)

type (
	FileSystem interface {
		LockSystem
		UploadManager
		FileManager
		// Recycle recycles a DBFS and its generated resources.
		Recycle()
		// Capacity returns the storage capacity of the filesystem.
		Capacity(ctx context.Context, u *ent.User) (*Capacity, error)
		// CheckCapability checks if the filesystem supports given capability.
		CheckCapability(ctx context.Context, uri *URI, opts ...Option) error
		// StaleEntities returns all stale entities of given IDs. If no ID is given, all
		// potential stale entities will be returned.
		StaleEntities(ctx context.Context, entities ...int) ([]Entity, error)
		// AllFilesInTrashBin returns all files in trash bin, despite owner.
		AllFilesInTrashBin(ctx context.Context, opts ...Option) (*ListFileResult, error)
		// Walk walks through all files under given path with given depth limit.
		Walk(ctx context.Context, path *URI, depth int, walk WalkFunc, opts ...Option) error
		// SharedAddressTranslation translates a path that potentially contain shared symbolic to a real address.
		SharedAddressTranslation(ctx context.Context, path *URI, opts ...Option) (File, *URI, error)
		// ExecuteNavigatorHooks executes hooks of given type on a file for navigator based custom hooks.
		ExecuteNavigatorHooks(ctx context.Context, hookType HookType, file File) error
	}

	FileManager interface {
		// Get returns a file by its path.
		Get(ctx context.Context, path *URI, opts ...Option) (File, error)
		// Create creates a file.
		Create(ctx context.Context, path *URI, fileType types.FileType, opts ...Option) (File, error)
		// List lists files under give path.
		List(ctx context.Context, path *URI, opts ...Option) (File, *ListFileResult, error)
		// Rename renames a file.
		Rename(ctx context.Context, path *URI, newName string) (File, error)
		// Move moves files to dst.
		MoveOrCopy(ctx context.Context, path []*URI, dst *URI, isCopy bool) error
		// Delete performs hard-delete for given paths, return newly generated stale entities in this delete operation.
		Delete(ctx context.Context, path []*URI, opts ...Option) ([]Entity, error)
		// GetEntitiesFromFileID returns all entities of a given file.
		GetEntity(ctx context.Context, entityID int) (Entity, error)
		// UpsertMetadata update or insert metadata of a file.
		PatchMetadata(ctx context.Context, path []*URI, metas ...MetadataPatch) error
		// SoftDelete moves given files to trash bin.
		SoftDelete(ctx context.Context, path ...*URI) error
		// Restore restores given files from trash bin to its original location.
		Restore(ctx context.Context, path ...*URI) error
		// VersionControl performs version control on given file.
		//  - `delete` is false: set version as current version;
		//  - `delete` is true: delete version.
		VersionControl(ctx context.Context, path *URI, versionId int, delete bool) error
		// GetFileFromDirectLink gets a file from a direct link.
		GetFileFromDirectLink(ctx context.Context, dl *ent.DirectLink) (File, error)
		// TraverseFile traverses a file to its root file, return the file with linked root.
		TraverseFile(ctx context.Context, fileID int) (File, error)
		// PatchProps patches the props of a file.
		PatchProps(ctx context.Context, uri *URI, props *types.FileProps, delete bool) error
	}

	UploadManager interface {
		// PrepareUpload prepares an upload session. It performs validation on upload request and returns a placeholder
		// file if needed.
		PrepareUpload(ctx context.Context, req *UploadRequest, opts ...Option) (*UploadSession, error)
		// CompleteUpload completes an upload session.
		CompleteUpload(ctx context.Context, session *UploadSession) (File, error)
		// CancelUploadSession cancels an upload session. Delete the placeholder file if no other entity is created.
		CancelUploadSession(ctx context.Context, path *URI, sessionID string, session *UploadSession) ([]Entity, error)
		// PreValidateUpload pre-validates an upload request.
		PreValidateUpload(ctx context.Context, dst *URI, files ...PreValidateFile) error
	}

	LockSystem interface {
		// ConfirmLock confirms if a lock token is valid on given URI.
		ConfirmLock(ctx context.Context, ancestor File, uri *URI, token ...string) (func(), LockSession, error)
		// Lock locks a file. If zeroDepth is true, only the file itself will be locked. Ancestor is closest ancestor
		// of the file that will be locked, if the given uri is an existing file, ancestor will be itself.
		// `token` is optional and can be used if the requester need to explicitly specify a token.
		Lock(ctx context.Context, d time.Duration, requester *ent.User, zeroDepth bool, application lock.Application,
			uri *URI, token string) (LockSession, error)
		// Unlock unlocks files by given tokens.
		Unlock(ctx context.Context, tokens ...string) error
		// Refresh refreshes a lock.
		Refresh(ctx context.Context, d time.Duration, token string) (lock.LockDetails, error)
	}

	StatelessUploadManager interface {
		// PrepareUpload prepares the upload on the node.
		PrepareUpload(ctx context.Context, args *StatelessPrepareUploadService) (*StatelessPrepareUploadResponse, error)
		// CompleteUpload completes the upload on the node.
		CompleteUpload(ctx context.Context, args *StatelessCompleteUploadService) error
		// OnUploadFailed handles the failed upload on the node.
		OnUploadFailed(ctx context.Context, args *StatelessOnUploadFailedService) error
		// CreateFile creates a file on the node.
		CreateFile(ctx context.Context, args *StatelessCreateFileService) error
	}

	WalkFunc func(file File, level int) error

	File interface {
		IsNil() bool
		ID() int
		Name() string
		DisplayName() string
		Ext() string
		Type() types.FileType
		Size() int64
		UpdatedAt() time.Time
		CreatedAt() time.Time
		Metadata() map[string]string
		// Uri returns the URI of the file.
		Uri(isRoot bool) *URI
		Owner() *ent.User
		OwnerID() int
		// RootUri return the URI of the user root file under owner's view.
		RootUri() *URI
		Entities() []Entity
		PrimaryEntity() Entity
		PrimaryEntityID() int
		Shared() bool
		IsSymbolic() bool
		PolicyID() (id int)
		ExtendedInfo() *FileExtendedInfo
		FolderSummary() *FolderSummary
		Capabilities() *boolset.BooleanSet
		IsRootFolder() bool
		View() *types.ExplorerView
	}

	Entities []Entity
	Entity   interface {
		ID() int
		Type() types.EntityType
		Size() int64
		UpdatedAt() time.Time
		CreatedAt() time.Time
		Source() string
		ReferenceCount() int
		PolicyID() int
		UploadSessionID() *uuid.UUID
		CreatedBy() *ent.User
		Model() *ent.Entity
	}

	FileExtendedInfo struct {
		StoragePolicy         *ent.StoragePolicy
		StorageUsed           int64
		Shares                []*ent.Share
		EntityStoragePolicies map[int]*ent.StoragePolicy
		View                  *types.ExplorerView
		DirectLinks           []*ent.DirectLink
	}

	FolderSummary struct {
		Size         int64     `json:"size"`
		Files        int       `json:"files"`
		Folders      int       `json:"folders"`
		Completed    bool      `json:"completed"` // whether the size calculation is completed
		CalculatedAt time.Time `json:"calculated_at"`
	}

	MetadataPatch struct {
		Key     string `json:"key" binding:"required"`
		Value   string `json:"value"`
		Private bool   `json:"private" binding:"ne=true"`
		Remove  bool   `json:"remove"`
	}

	// ListFileResult result of listing files.
	ListFileResult struct {
		Files                 []File
		Parent                File
		Pagination            *inventory.PaginationResults
		Props                 *NavigatorProps
		ContextHint           *uuid.UUID
		RecursionLimitReached bool
		MixedType             bool
		SingleFileView        bool
		StoragePolicy         *ent.StoragePolicy
		View                  *types.ExplorerView
	}

	// NavigatorProps is the properties of current filesystem.
	NavigatorProps struct {
		// Supported capabilities of the navigator.
		Capability *boolset.BooleanSet `json:"capability"`
		// MaxPageSize is the maximum page size of the navigator.
		MaxPageSize int `json:"max_page_size"`
		// OrderByOptions is the supported order by options of the navigator.
		OrderByOptions []string `json:"order_by_options"`
		// OrderDirectionOptions is the supported order direction options of the navigator.
		OrderDirectionOptions []string `json:"order_direction_options"`
	}

	// UploadCredential for uploading files in client side.
	UploadCredential struct {
		SessionID      string   `json:"session_id"`
		ChunkSize      int64    `json:"chunk_size"` // 分块大小，0 为部分快
		Expires        int64    `json:"expires"`    // 上传凭证过期时间， Unix 时间戳
		UploadURLs     []string `json:"upload_urls,omitempty"`
		Credential     string   `json:"credential,omitempty"`
		UploadID       string   `json:"uploadID,omitempty"`
		Callback       string   `json:"callback,omitempty"` // 回调地址
		Uri            string   `json:"uri,omitempty"`      // 存储路径
		AccessKey      string   `json:"ak,omitempty"`
		KeyTime        string   `json:"keyTime,omitempty"` // COS用有效期
		CompleteURL    string   `json:"completeURL,omitempty"`
		StoragePolicy  *ent.StoragePolicy
		CallbackSecret string `json:"callback_secret,omitempty"`
		MimeType       string `json:"mime_type,omitempty"`     // Expected mimetype
		UploadPolicy   string `json:"upload_policy,omitempty"` // Upyun upload policy
	}

	// UploadSession stores the information of an upload session, used in server side.
	UploadSession struct {
		UID            int // 发起者
		Policy         *ent.StoragePolicy
		FileID         int    // ID of the placeholder file
		EntityID       int    // ID of the new entity
		Callback       string // 回调 URL 地址
		CallbackSecret string // Callback secret
		UploadID       string // Multi-part upload ID
		UploadURL      string
		Credential     string
		ChunkSize      int64
		SentinelTaskID int
		NewFileCreated bool // If new file is created for this session
		Importing      bool // If the upload is importing from another file

		LockToken string // Token of the locked placeholder file
		Props     *UploadProps
	}

	// UploadProps properties of an upload session/request.
	UploadProps struct {
		Uri                    *URI
		Size                   int64
		UploadSessionID        string
		PreferredStoragePolicy int
		SavePath               string
		LastModified           *time.Time
		MimeType               string
		Metadata               map[string]string
		PreviousVersion        string
		// EntityType is the type of the entity to be created. If not set, a new file will be created
		// with a default version entity. This will be set in update request for existing files.
		EntityType *types.EntityType
		ExpireAt   time.Time
	}

	// FsOption options for underlying file system.
	FsOption struct {
		Page               int // Page number when listing files.
		PageSize           int // Size of pages when listing files.
		OrderBy            string
		OrderDirection     string
		UploadRequest      *UploadRequest
		UnlinkOnly         bool
		UploadSession      *UploadSession
		DownloadSpeed      int64
		IsDownload         bool
		Expire             *time.Time
		Entity             Entity
		IsThumb            bool
		EntityType         *types.EntityType
		EntityTypeNil      bool
		SkipSoftDelete     bool
		SysSkipSoftDelete  bool
		Metadata           map[string]string
		ArchiveCompression bool
		ProgressFunc
		MaxArchiveSize  int64
		DryRun          CreateArchiveDryRunFunc
		Policy          *ent.StoragePolicy
		Node            StatelessUploadManager
		StatelessUserID int
		NoCache         bool
	}

	// Option 发送请求的额外设置
	Option interface {
		Apply(any)
	}

	OptionFunc func(*FsOption)

	// Ctx keys used to detect user canceled operation.
	UserCancelCtx struct{}
	GinCtx        struct{}

	// Capacity describes the capacity of a filesystem.
	Capacity struct {
		Total int64 `json:"total"`
		Used  int64 `json:"used"`
	}

	FileCapacity int

	LockSession interface {
		LastToken() string
	}

	HookType int

	CreateArchiveDryRunFunc func(name string, e Entity)

	StatelessPrepareUploadService struct {
		UploadRequest *UploadRequest `json:"upload_request" binding:"required"`
		UserID        int            `json:"user_id"`
	}
	StatelessCompleteUploadService struct {
		UploadSession *UploadSession `json:"upload_session" binding:"required"`
		UserID        int            `json:"user_id"`
	}
	StatelessOnUploadFailedService struct {
		UploadSession *UploadSession `json:"upload_session" binding:"required"`
		UserID        int            `json:"user_id"`
	}
	StatelessCreateFileService struct {
		Path   string         `json:"path" binding:"required"`
		Type   types.FileType `json:"type" binding:"required"`
		UserID int            `json:"user_id"`
	}
	StatelessPrepareUploadResponse struct {
		Session *UploadSession
		Req     *UploadRequest
	}

	PrepareRelocateRes struct {
		Entities  map[int]*RelocateEntity `json:"entities,omitempty"`
		LockToken string                  `json:"lock_token,omitempty"`
		Policy    *ent.StoragePolicy      `json:"policy,omitempty"`
	}

	RelocateEntity struct {
		SrcEntity                *ent.Entity `json:"src_entity"`
		FileUri                  *URI        `json:"file_uri,omitempty"`
		NewSavePath              string      `json:"new_save_path"`
		ParentFiles              []int       `json:"parent_files"`
		PrimaryEntityParentFiles []int       `json:"primary_entity_parent_files"`
	}

	PreValidateFile struct {
		Name     string
		Size     int64
		OmitName bool // if true, file name will not be validated
	}

	PhysicalObject struct {
		Name         string    `json:"name"`
		Source       string    `json:"source"`
		RelativePath string    `json:"relative_path"`
		Size         int64     `json:"size"`
		IsDir        bool      `json:"is_dir"`
		LastModify   time.Time `json:"last_modify"`
	}
)

const (
	FileCapacityPreview FileCapacity = iota
	FileCapacityEnter
	FileCapacityDownload
	FileCapacityRename
	FileCapacityCopy
	FileCapacityMove
)

const (
	HookTypeBeforeDownload = HookType(iota)
)

func (p *UploadProps) Copy() *UploadProps {
	newProps := *p
	return &newProps
}

func (f OptionFunc) Apply(o any) {
	f(o.(*FsOption))
}

// ==================== FS Options ====================

// WithUploadSession sets upload session for manager.
func WithUploadSession(s *UploadSession) Option {
	return OptionFunc(func(o *FsOption) {
		o.UploadSession = s
	})
}

// WithPageSize limit items in a page for listing files.
func WithPageSize(s int) Option {
	return OptionFunc(func(o *FsOption) {
		o.PageSize = s
	})
}

// WithPage set page number for listing files.
func WithPage(p int) Option {
	return OptionFunc(func(o *FsOption) {
		o.Page = p
	})
}

// WithOrderBy set order by for listing files.
func WithOrderBy(p string) Option {
	return OptionFunc(func(o *FsOption) {
		o.OrderBy = p
	})
}

// WithOrderDirection set order direction for listing files.
func WithOrderDirection(p string) Option {
	return OptionFunc(func(o *FsOption) {
		o.OrderDirection = p
	})
}

// WithUploadRequest set upload request for uploading files.
func WithUploadRequest(p *UploadRequest) Option {
	return OptionFunc(func(o *FsOption) {
		o.UploadRequest = p
	})
}

// WithProgressFunc set progress function for manager.
func WithProgressFunc(p ProgressFunc) Option {
	return OptionFunc(func(o *FsOption) {
		o.ProgressFunc = p
	})
}

// WithUnlinkOnly set unlink only for unlinking files.
func WithUnlinkOnly(p bool) Option {
	return OptionFunc(func(o *FsOption) {
		o.UnlinkOnly = p
	})
}

// WithDownloadSpeed sets download speed limit for manager.
func WithDownloadSpeed(speed int64) Option {
	return OptionFunc(func(o *FsOption) {
		o.DownloadSpeed = speed
	})
}

func WithIsDownload(b bool) Option {
	return OptionFunc(func(o *FsOption) {
		o.IsDownload = b
	})
}

// WithSysSkipSoftDelete sets whether to skip soft delete without checking
// file ownership.
func WithSysSkipSoftDelete(b bool) Option {
	return OptionFunc(func(o *FsOption) {
		o.SysSkipSoftDelete = b
	})
}

// WithNoCache sets whether to disable cache for entity's URL.
func WithNoCache(b bool) Option {
	return OptionFunc(func(o *FsOption) {
		o.NoCache = b
	})
}

// WithUrlExpire sets expire time for entity's URL.
func WithUrlExpire(t *time.Time) Option {
	return OptionFunc(func(o *FsOption) {
		o.Expire = t
	})
}

// WithEntity sets entity for manager.
func WithEntity(e Entity) Option {
	return OptionFunc(func(o *FsOption) {
		o.Entity = e
	})
}

// WithPolicy sets storage policy overwrite for manager.
func WithPolicy(p *ent.StoragePolicy) Option {
	return OptionFunc(func(o *FsOption) {
		o.Policy = p
	})
}

// WithUseThumb sets whether entity's URL is used for thumbnail.
func WithUseThumb(b bool) Option {
	return OptionFunc(func(o *FsOption) {
		o.IsThumb = b
	})
}

// WithEntityType sets entity type for manager.
func WithEntityType(t types.EntityType) Option {
	return OptionFunc(func(o *FsOption) {
		o.EntityType = &t
	})
}

// WithNoEntityType sets entity type to nil for manager.
func WithNoEntityType() Option {
	return OptionFunc(func(o *FsOption) {
		o.EntityTypeNil = true
	})
}

// WithSkipSoftDelete sets whether to skip soft delete.
func WithSkipSoftDelete(b bool) Option {
	return OptionFunc(func(o *FsOption) {
		o.SkipSoftDelete = b
	})
}

// WithMetadata sets metadata for file creation.
func WithMetadata(m map[string]string) Option {
	return OptionFunc(func(o *FsOption) {
		o.Metadata = m
	})
}

// WithArchiveCompression sets whether to compress files in archive.
func WithArchiveCompression(b bool) Option {
	return OptionFunc(func(o *FsOption) {
		o.ArchiveCompression = b
	})
}

// WithMaxArchiveSize sets maximum size of to be archived file or to-be decompressed
// size, 0 for unlimited.
func WithMaxArchiveSize(s int64) Option {
	return OptionFunc(func(o *FsOption) {
		o.MaxArchiveSize = s
	})
}

// WithDryRun sets whether to perform dry run.
func WithDryRun(b CreateArchiveDryRunFunc) Option {
	return OptionFunc(func(o *FsOption) {
		o.DryRun = b
	})
}

// WithNode sets node for stateless upload manager.
func WithNode(n StatelessUploadManager) Option {
	return OptionFunc(func(o *FsOption) {
		o.Node = n
	})
}

// WithStatelessUserID sets stateless user ID for manager.
func WithStatelessUserID(id int) Option {
	return OptionFunc(func(o *FsOption) {
		o.StatelessUserID = id
	})
}

type WriteMode int

const (
	ModeNone      WriteMode = 0x00000
	ModeOverwrite WriteMode = 0x00001
	// Deprecated
	ModeNop WriteMode = 0x00004
)

type (
	ProgressFunc  func(current, diff int64, total int64)
	UploadRequest struct {
		Props *UploadProps

		Mode         WriteMode
		File         io.ReadCloser `json:"-"`
		Seeker       io.Seeker     `json:"-"`
		Offset       int64
		ProgressFunc `json:"-"`

		ImportFrom *PhysicalObject `json:"-"`
		read       int64
	}
)

func (file *UploadRequest) Read(p []byte) (n int, err error) {
	if file.File != nil {
		n, err = file.File.Read(p)
		file.read += int64(n)
		if file.ProgressFunc != nil {
			file.ProgressFunc(file.read, int64(n), file.Props.Size)
		}

		return
	}

	return 0, io.EOF
}

func (file *UploadRequest) Close() error {
	if file.File != nil {
		return file.File.Close()
	}

	return nil
}

func (file *UploadRequest) Seek(offset int64, whence int) (int64, error) {
	if file.Seekable() {
		previous := file.read
		o, err := file.Seeker.Seek(offset, whence)
		file.read = o
		if file.ProgressFunc != nil {
			file.ProgressFunc(o, file.read-previous, file.Props.Size)
		}
		return o, err
	}

	return 0, errors.New("no seeker")
}

func (file *UploadRequest) Seekable() bool {
	return file.Seeker != nil
}

func init() {
	gob.Register(UploadSession{})
	gob.Register(FolderSummary{})
}

type ApplicationType string

const (
	ApplicationCreate         ApplicationType = "create"
	ApplicationRename         ApplicationType = "rename"
	ApplicationSetPermission  ApplicationType = "setPermission"
	ApplicationMoveCopy       ApplicationType = "moveCopy"
	ApplicationUpload         ApplicationType = "upload"
	ApplicationUpdateMetadata ApplicationType = "updateMetadata"
	ApplicationDelete         ApplicationType = "delete"
	ApplicationSoftDelete     ApplicationType = "softDelete"
	ApplicationDAV            ApplicationType = "dav"
	ApplicationVersionControl ApplicationType = "versionControl"
	ApplicationViewer         ApplicationType = "viewer"
	ApplicationMount          ApplicationType = "mount"
	ApplicationRelocate       ApplicationType = "relocate"
)

func LockApp(a ApplicationType) lock.Application {
	return lock.Application{Type: string(a)}
}

type LockSessionCtxKey struct{}

// LockSessionToContext stores lock session to context.
func LockSessionToContext(ctx context.Context, session LockSession) context.Context {
	return context.WithValue(ctx, LockSessionCtxKey{}, session)
}

func FindDesiredEntity(file File, version string, hasher hashid.Encoder, entityType *types.EntityType) (bool, Entity) {
	if version == "" {
		return true, file.PrimaryEntity()
	}

	requestedVersion, err := hasher.Decode(version, hashid.EntityID)
	if err != nil {
		return false, nil
	}

	hasVersions := false
	for _, entity := range file.Entities() {
		if entity.Type() == types.EntityTypeVersion {
			hasVersions = true
		}

		if entity.ID() == requestedVersion && (entityType == nil || *entityType == entity.Type()) {
			return true, entity
		}
	}

	// Happy path for: File has no versions, requested version is empty entity
	if !hasVersions && requestedVersion == 0 {
		return true, file.PrimaryEntity()
	}

	return false, nil
}

type DbEntity struct {
	model *ent.Entity
}

func NewEntity(model *ent.Entity) Entity {
	return &DbEntity{model: model}
}

func (e *DbEntity) ID() int {
	return e.model.ID
}

func (e *DbEntity) Type() types.EntityType {
	return types.EntityType(e.model.Type)
}

func (e *DbEntity) Size() int64 {
	return e.model.Size
}

func (e *DbEntity) UpdatedAt() time.Time {
	return e.model.UpdatedAt
}

func (e *DbEntity) CreatedAt() time.Time {
	return e.model.CreatedAt
}

func (e *DbEntity) CreatedBy() *ent.User {
	return e.model.Edges.User
}

func (e *DbEntity) Source() string {
	return e.model.Source
}

func (e *DbEntity) ReferenceCount() int {
	return e.model.ReferenceCount
}

func (e *DbEntity) PolicyID() int {
	return e.model.StoragePolicyEntities
}

func (e *DbEntity) UploadSessionID() *uuid.UUID {
	return e.model.UploadSessionID
}

func (e *DbEntity) Model() *ent.Entity {
	return e.model
}

func NewEmptyEntity(u *ent.User) Entity {
	return &DbEntity{
		model: &ent.Entity{
			UpdatedAt:      time.Now(),
			ReferenceCount: 1,
			CreatedAt:      time.Now(),
			Edges: ent.EntityEdges{
				User: u,
			},
		},
	}
}