const (
	LabelSystemRoot          = "root"
	LabelDockerImages        = "docker-images"
	LabelCrioImages          = "crio-images"
	LabelCrioContainers      = "crio-containers"
	DriverStatusPoolName     = "Pool Name"
	DriverStatusDataLoopFile = "Data loop file"
)

var (
	// ErrNoSuchDevice is the error indicating the requested device does not exist.
	ErrNoSuchDevice = errors.New("cadvisor: no such device")

	// ErrDeviceNotInPartitionsMap is the error resulting if a device could not be found in the partitions map.
	ErrDeviceNotInPartitionsMap = errors.New("could not find device in cached partitions map")
)

var ErrFallbackToVFS = errors.New("fallback to VFS")

type Context struct {
	// docker root directory.
	Docker DockerContext
	Crio   CrioContext
	Podman PodmanContext
}

type CrioContext struct {
	Root       string
	ImageStore string
	Driver     string
}

type DeviceInfo struct {
	Device string
	Major  uint
	Minor  uint
}

type DiskStats struct {
	MajorNum        uint64
	MinorNum        uint64
	ReadsCompleted  uint64
	ReadsMerged     uint64
	SectorsRead     uint64
	ReadTime        uint64
	WritesCompleted uint64
	WritesMerged    uint64
	SectorsWritten  uint64
	WriteTime       uint64
	IoInProgress    uint64
	IoTime          uint64
	WeightedIoTime  uint64
	Major           uint64
	Minor           uint64
}

type DockerContext struct {
	Root         string
	Driver       string
	DriverStatus map[string]string
}

type Fs struct {
	DeviceInfo
	Type       FsType
	Capacity   uint64
	Free       uint64
	Available  uint64
	Inodes     *uint64
	InodesFree *uint64
	DiskStats  DiskStats
}

type FsCachingPlugin interface {
	FsPlugin

	// CacheKey returns a cache key for the given partition.
	// Stats will be cached by this key and reused for partitions with the same key.
	// Return empty string to disable caching for a specific partition.
	CacheKey(partition PartitionInfo) string
}

type FsInfo interface {
	// Returns capacity and free space, in bytes, of all the ext2, ext3, ext4 filesystems on the host.
	GetGlobalFsInfo() ([]Fs, error)

	// Returns capacity and free space, in bytes, of the set of mounts passed.
	GetFsInfoForPath(mountSet map[string]struct{}) ([]Fs, error)

	// GetDirUsage returns a usage information for 'dir'.
	GetDirUsage(dir string) (UsageInfo, error)

	// GetDeviceInfoByFsUUID returns the information of the device with the
	// specified filesystem uuid. If no such device exists, this function will
	// return the ErrNoSuchDevice error.
	GetDeviceInfoByFsUUID(uuid string) (*DeviceInfo, error)

	// Returns the block device info of the filesystem on which 'dir' resides.
	GetDirFsDevice(dir string) (*DeviceInfo, error)

	// Returns the device name associated with a particular label.
	GetDeviceForLabel(label string) (string, error)

	// Returns all labels associated with a particular device name.
	GetLabelsForDevice(device string) ([]string, error)

	// Returns the mountpoint associated with a particular device.
	GetMountpointForDevice(device string) (string, error)
}

type FsPlugin interface {
	// Name returns the plugin identifier (e.g., "zfs", "devicemapper", "vfs").
	Name() string

	// CanHandle returns true if this plugin handles the given filesystem type.
	CanHandle(fsType string) bool

	// Priority returns the plugin priority (higher = checked first).
	// Allows specific plugins (zfs, btrfs) to override generic (vfs).
	Priority() int

	// GetStats returns filesystem statistics for a partition.
	GetStats(device string, partition PartitionInfo) (*FsStats, error)

	// ProcessMount optionally modifies mount info during processing.
	// Returns (shouldInclude bool, modifiedMount *mount.Info, error).
	ProcessMount(mnt *mount.Info) (bool, *mount.Info, error)
}

type FsStats struct {
	Capacity   uint64
	Free       uint64
	Available  uint64
	Inodes     *uint64
	InodesFree *uint64
	Type       FsType
}

type FsType string

const (
	ZFS          FsType = "zfs"
	DeviceMapper FsType = "devicemapper"
	VFS          FsType = "vfs"
	NFS          FsType = "nfs"
)

type FsWatcher interface {
	// GetUsage returns filesystem usage for a specific container/path.
	GetUsage(containerID string, deviceID string) (uint64, error)

	// Stop stops the background monitoring.
	Stop()
}

type FsWatcherPlugin interface {
	FsPlugin

	// StartWatcher starts background monitoring.
	// Returns a Watcher that can be used to get container-level usage.
	StartWatcher() (FsWatcher, error)
}

type PartitionInfo struct {
	Mountpoint string
	Major      uint
	Minor      uint
	FsType     string
	BlockSize  uint
}

type PodmanContext struct {
	Root         string
	Driver       string
	DriverStatus map[string]string
}

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

type UsageInfo struct {
	Bytes  uint64
	Inodes uint64
}