package config

import "math/rand"

type ConfigInterface interface {
	GetVersion() string
	GetToken() string
	GetNumOfWorkers() int
	GetRefreshEverySeconds() int
	EnableRepair() bool
	GetHost() string
	GetPort() string
	GetDirectories() []string
	MeetsConditions(directory, torrentName string, torrentIDs, fileNames []string) bool
	GetOnLibraryUpdate() string
	GetNetworkBufferSize() int
	GetMountPoint() string
	EnableRetainFolderNameExtension() bool
	EnableRetainRDTorrentName() bool
	GetRandomPreferredHost() string
	ShouldServeFromRclone() bool
	ShouldForceIPv6() bool
	GetRateLimitSleepSeconds() int
	GetRealDebridTimeout() int
	GetRetriesUntilFailed() int
	EnableDownloadCache() bool
}

type ZurgConfig struct {
	Version                   string   `yaml:"zurg"`
	Token                     string   `yaml:"token"`
	Host                      string   `yaml:"host"`
	Port                      string   `yaml:"port"`
	NumOfWorkers              int      `yaml:"concurrent_workers"`
	RateLimitSleepSeconds     int      `yaml:"rate_limit_sleep_secs"`
	RefreshEverySeconds       int      `yaml:"check_for_changes_every_secs"`
	CanRepair                 bool     `yaml:"enable_repair"`
	OnLibraryUpdate           string   `yaml:"on_library_update"`
	NetworkBufferSize         int      `yaml:"network_buffer_size"`
	MountPoint                string   `yaml:"mount_point"`
	RetainFolderNameExtension bool     `yaml:"retain_folder_name_extension"`
	RetainRDTorrentName       bool     `yaml:"retain_rd_torrent_name"`
	PreferredHosts            []string `yaml:"preferred_hosts"`
	ServeFromRclone           bool     `yaml:"serve_from_rclone"`
	ForceIPv6                 bool     `yaml:"force_ipv6"`
	RealDebridTimeout         int      `yaml:"realdebrid_timeout_secs"`
	RetriesUntilFailed        int      `yaml:"retries_until_failed"`
	UseDownloadCache          bool     `yaml:"use_download_cache"`
}

func (z *ZurgConfig) GetToken() string {
	return z.Token
}

func (z *ZurgConfig) GetHost() string {
	if z.Host == "" {
		return "[::]"
	}
	return z.Host
}

func (z *ZurgConfig) GetPort() string {
	if z.Port == "" {
		return "9999"
	}
	return z.Port
}

func (z *ZurgConfig) GetNumOfWorkers() int {
	if z.NumOfWorkers == 0 {
		return 50
	}
	return z.NumOfWorkers
}

func (z *ZurgConfig) GetRefreshEverySeconds() int {
	if z.RefreshEverySeconds == 0 {
		return 60
	}
	return z.RefreshEverySeconds
}

func (z *ZurgConfig) EnableRepair() bool {
	return z.CanRepair
}

func (z *ZurgConfig) GetOnLibraryUpdate() string {
	return z.OnLibraryUpdate
}

func (z *ZurgConfig) GetNetworkBufferSize() int {
	if z.NetworkBufferSize == 0 {
		return 64 * 1024 // 64kb
	}
	return z.NetworkBufferSize
}

func (z *ZurgConfig) GetMountPoint() string {
	if z.MountPoint == "" {
		return "/app/mnt"
	}
	return z.MountPoint
}

func (z *ZurgConfig) EnableRetainFolderNameExtension() bool {
	return z.RetainFolderNameExtension
}

func (z *ZurgConfig) EnableRetainRDTorrentName() bool {
	return z.RetainRDTorrentName
}

func (z *ZurgConfig) GetRandomPreferredHost() string {
	if len(z.PreferredHosts) == 0 {
		return ""
	}
	randomIndex := rand.Intn(len(z.PreferredHosts))
	return z.PreferredHosts[randomIndex]
}

func (z *ZurgConfig) ShouldServeFromRclone() bool {
	return z.ServeFromRclone
}

func (z *ZurgConfig) ShouldForceIPv6() bool {
	return z.ForceIPv6
}

func (z *ZurgConfig) GetRateLimitSleepSeconds() int {
	if z.RateLimitSleepSeconds == 0 {
		return 4
	}
	return z.RateLimitSleepSeconds
}

func (z *ZurgConfig) GetRealDebridTimeout() int {
	if z.RealDebridTimeout == 0 {
		return 60
	}
	return z.RealDebridTimeout
}

func (z *ZurgConfig) GetRetriesUntilFailed() int {
	if z.RetriesUntilFailed == 0 {
		return 5
	}
	return z.RetriesUntilFailed
}

func (z *ZurgConfig) EnableDownloadCache() bool {
	return z.UseDownloadCache
}