package config

import (
	"fmt"
	"os"
	"strconv"
	"strings"
	"time"
)

// Configuration 表示应用程序的完整配置
// 该结构体包含服务器、日志、安全和转换相关的所有配置项
type Configuration struct {
	// ServerConfig 服务器配置
	Server ServerConfig `yaml:"server" json:"server"`

	// LoggingConfig 日志配置
	Logging LoggingConfig `yaml:"logging" json:"logging"`

	// SecurityConfig 安全配置
	Security SecurityConfig `yaml:"security" json:"security"`

	// ConversionConfig 转换配置
	Conversion ConversionConfig `yaml:"conversion" json:"conversion"`
}

// ServerConfig 服务器相关配置
type ServerConfig struct {
	// Port 服务器监听端口，默认25500
	Port int `yaml:"port" json:"port" env:"SUBCONVERTER_PORT" mapstructure:"port"`

	// Host 服务器监听地址，默认"0.0.0.0"
	Host string `yaml:"host" json:"host" env:"SUBCONVERTER_HOST" mapstructure:"host"`

	// ReadTimeout 读取超时时间（秒），默认30
	ReadTimeout int `yaml:"read_timeout" json:"read_timeout" env:"SUBCONVERTER_READ_TIMEOUT" mapstructure:"read_timeout"`

	// WriteTimeout 写入超时时间（秒），默认30
	WriteTimeout int `yaml:"write_timeout" json:"write_timeout" env:"SUBCONVERTER_WRITE_TIMEOUT" mapstructure:"write_timeout"`

	// MaxRequestSize 最大请求大小（字节），默认10MB
	MaxRequestSize int64 `yaml:"max_request_size" json:"max_request_size" env:"SUBCONVERTER_MAX_REQUEST_SIZE" mapstructure:"max_request_size"`
}

// Clone 创建服务器配置的深拷贝
func (s *ServerConfig) Clone() ServerConfig {
	if s == nil {
		return ServerConfig{}
	}

	return ServerConfig{
		Port:           s.Port,
		Host:           s.Host,
		ReadTimeout:    s.ReadTimeout,
		WriteTimeout:   s.WriteTimeout,
		MaxRequestSize: s.MaxRequestSize,
	}
}

// LoggingConfig 日志相关配置
type LoggingConfig struct {
	// Level 日志级别，可选：debug, info, warn, error，默认info
	Level string `yaml:"level" json:"level" env:"SUBCONVERTER_LOG_LEVEL" mapstructure:"level"`

	// Format 日志格式，可选：json, text，默认json
	Format string `yaml:"format" json:"format" env:"SUBCONVERTER_LOG_FORMAT" mapstructure:"format"`

	// Output 日志输出，可选：stdout, stderr, file，默认stdout
	Output string `yaml:"output" json:"output" env:"SUBCONVERTER_LOG_OUTPUT" mapstructure:"output"`

	// File 如果Output为file，指定日志文件路径
	File string `yaml:"file" json:"file" env:"SUBCONVERTER_LOG_FILE" mapstructure:"file"`
}

// Clone 创建日志配置的深拷贝
func (l *LoggingConfig) Clone() LoggingConfig {
	if l == nil {
		return LoggingConfig{}
	}

	return LoggingConfig{
		Level:  l.Level,
		Format: l.Format,
		Output: l.Output,
		File:   l.File,
	}
}

// SecurityConfig 安全相关配置
type SecurityConfig struct {
	// AccessTokens 访问令牌列表，空列表表示无需认证
	AccessTokens []string `yaml:"access_tokens" json:"access_tokens" env:"SUBCONVERTER_ACCESS_TOKENS" mapstructure:"access_tokens"`

	// CorsOrigins CORS允许的源列表，支持通配符*
	CorsOrigins []string `yaml:"cors_origins" json:"cors_origins" env:"SUBCONVERTER_CORS_ORIGINS" mapstructure:"cors_origins"`

	// RateLimit 速率限制（每分钟请求数），0表示不限制
	RateLimit int `yaml:"rate_limit" json:"rate_limit" env:"SUBCONVERTER_RATE_LIMIT" mapstructure:"rate_limit"`

	// Timeout 请求超时时间（秒），默认60
	Timeout int `yaml:"timeout" json:"timeout" env:"SUBCONVERTER_TIMEOUT" mapstructure:"timeout"`
}

// Clone 创建安全配置的深拷贝
func (s *SecurityConfig) Clone() SecurityConfig {
	if s == nil {
		return SecurityConfig{}
	}

	// 深拷贝切片
	accessTokens := make([]string, len(s.AccessTokens))
	copy(accessTokens, s.AccessTokens)

	corsOrigins := make([]string, len(s.CorsOrigins))
	copy(corsOrigins, s.CorsOrigins)

	return SecurityConfig{
		AccessTokens: accessTokens,
		CorsOrigins:  corsOrigins,
		RateLimit:    s.RateLimit,
		Timeout:      s.Timeout,
	}
}

// ConversionConfig 转换相关配置
type ConversionConfig struct {
	// DefaultTarget 默认目标格式，默认clash
	DefaultTarget string `yaml:"default_target" json:"default_target" env:"SUBCONVERTER_DEFAULT_TARGET" mapstructure:"default_target"`

	// SupportedTargets 支持的目标格式列表
	SupportedTargets []string `yaml:"supported_targets" json:"supported_targets" mapstructure:"supported_targets"`

	// DefaultEmoji 默认是否启用emoji，默认false
	DefaultEmoji bool `yaml:"default_emoji" json:"default_emoji" env:"SUBCONVERTER_DEFAULT_EMOJI" mapstructure:"default_emoji"`

	// DefaultUDP 默认是否启用UDP，默认false
	DefaultUDP bool `yaml:"default_udp" json:"default_udp" env:"SUBCONVERTER_DEFAULT_UDP" mapstructure:"default_udp"`

	// MaxNodes 最大节点数量，默认0（无限制）
	MaxNodes int `yaml:"max_nodes" json:"max_nodes" env:"SUBCONVERTER_MAX_NODES" mapstructure:"max_nodes"`

	// CacheTimeout 缓存超时时间（分钟），默认60
	CacheTimeout int `yaml:"cache_timeout" json:"cache_timeout" env:"SUBCONVERTER_CACHE_TIMEOUT" mapstructure:"cache_timeout"`
}

// Clone 创建转换配置的深拷贝
func (c *ConversionConfig) Clone() ConversionConfig {
	if c == nil {
		return ConversionConfig{}
	}

	// 深拷贝切片
	supportedTargets := make([]string, len(c.SupportedTargets))
	copy(supportedTargets, c.SupportedTargets)

	return ConversionConfig{
		DefaultTarget:    c.DefaultTarget,
		SupportedTargets: supportedTargets,
		DefaultEmoji:     c.DefaultEmoji,
		DefaultUDP:       c.DefaultUDP,
		MaxNodes:         c.MaxNodes,
		CacheTimeout:     c.CacheTimeout,
	}
}

// NewConfiguration 创建新的默认配置
// 返回包含所有默认值的Configuration结构体
func NewConfiguration() *Configuration {
	return &Configuration{
		Server: ServerConfig{
			Port:           25500,
			Host:           "0.0.0.0",
			ReadTimeout:    30,
			WriteTimeout:   30,
			MaxRequestSize: 10 * 1024 * 1024, // 10MB
		},
		Logging: LoggingConfig{
			Level:  "info",
			Format: "json",
			Output: "stdout",
			File:   "",
		},
		Security: SecurityConfig{
			AccessTokens: []string{},
			CorsOrigins:  []string{"*"},
			RateLimit:    0,
			Timeout:      60,
		},
		Conversion: ConversionConfig{
			DefaultTarget:    "clash",
			SupportedTargets: []string{"clash", "clashr", "surge", "quanx", "loon", "surfboard", "v2ray"},
			DefaultEmoji:     false,
			DefaultUDP:       false,
			MaxNodes:         0,
			CacheTimeout:     60,
		},
	}
}

// Validate 验证配置的有效性
// 返回error如果配置无效，nil表示配置有效
func (c *Configuration) Validate() error {
	// 验证服务器配置
	if c.Server.Port < 1 || c.Server.Port > 65535 {
		return fmt.Errorf("server port must be between 1 and 65535, got: %d", c.Server.Port)
	}

	if c.Server.Host == "" {
		return fmt.Errorf("server host cannot be empty")
	}

	if c.Server.ReadTimeout < 1 {
		return fmt.Errorf("read timeout must be positive, got: %d", c.Server.ReadTimeout)
	}

	if c.Server.WriteTimeout < 1 {
		return fmt.Errorf("write timeout must be positive, got: %d", c.Server.WriteTimeout)
	}

	if c.Server.MaxRequestSize < 1 {
		return fmt.Errorf("max request size must be positive, got: %d", c.Server.MaxRequestSize)
	}

	// 验证日志配置
	validLogLevels := map[string]bool{
		"debug": true,
		"info":  true,
		"warn":  true,
		"error": true,
	}
	if !validLogLevels[c.Logging.Level] {
		return fmt.Errorf("log level must be one of: debug, info, warn, error, got: %s", c.Logging.Level)
	}

	validLogFormats := map[string]bool{
		"json": true,
		"text": true,
	}
	if !validLogFormats[c.Logging.Format] {
		return fmt.Errorf("log format must be one of: json, text, got: %s", c.Logging.Format)
	}

	validOutputs := map[string]bool{
		"stdout": true,
		"stderr": true,
		"file":   true,
	}
	if !validOutputs[c.Logging.Output] {
		return fmt.Errorf("log output must be one of: stdout, stderr, file, got: %s", c.Logging.Output)
	}

	if c.Logging.Output == "file" && c.Logging.File == "" {
		return fmt.Errorf("log file path must be specified when output is file")
	}

	// 验证安全配置
	if c.Security.Timeout < 1 {
		return fmt.Errorf("timeout must be positive, got: %d", c.Security.Timeout)
	}

	if c.Security.RateLimit < 0 {
		return fmt.Errorf("rate limit must be non-negative, got: %d", c.Security.RateLimit)
	}

	// 验证转换配置
	if !contains(c.Conversion.SupportedTargets, c.Conversion.DefaultTarget) {
		return fmt.Errorf("default target must be in supported targets, got: %s", c.Conversion.DefaultTarget)
	}

	if c.Conversion.MaxNodes < 0 {
		return fmt.Errorf("max nodes must be non-negative, got: %d", c.Conversion.MaxNodes)
	}

	if c.Conversion.CacheTimeout < 0 {
		return fmt.Errorf("cache timeout must be non-negative, got: %d", c.Conversion.CacheTimeout)
	}

	return nil
}

// Clone 创建配置的深拷贝
// 返回配置的独立副本
func (c *Configuration) Clone() *Configuration {
	if c == nil {
		return nil
	}

	clone := &Configuration{
		Server:     c.Server.Clone(),
		Logging:    c.Logging.Clone(),
		Security:   c.Security.Clone(),
		Conversion: c.Conversion.Clone(),
	}

	return clone
}

// LoadFromEnvironment 从环境变量加载配置
// 根据环境变量覆盖默认配置值
func (c *Configuration) LoadFromEnvironment() {
	// 服务器配置
	if port := os.Getenv("SUBCONVERTER_PORT"); port != "" {
		if p, err := strconv.Atoi(port); err == nil {
			c.Server.Port = p
		}
	}

	if host := os.Getenv("SUBCONVERTER_HOST"); host != "" {
		c.Server.Host = host
	}

	if readTimeout := os.Getenv("SUBCONVERTER_READ_TIMEOUT"); readTimeout != "" {
		if rt, err := strconv.Atoi(readTimeout); err == nil {
			c.Server.ReadTimeout = rt
		}
	}

	if writeTimeout := os.Getenv("SUBCONVERTER_WRITE_TIMEOUT"); writeTimeout != "" {
		if wt, err := strconv.Atoi(writeTimeout); err == nil {
			c.Server.WriteTimeout = wt
		}
	}

	// 日志配置
	if logLevel := os.Getenv("SUBCONVERTER_LOG_LEVEL"); logLevel != "" {
		c.Logging.Level = logLevel
	}

	if logFormat := os.Getenv("SUBCONVERTER_LOG_FORMAT"); logFormat != "" {
		c.Logging.Format = logFormat
	}

	if logOutput := os.Getenv("SUBCONVERTER_LOG_OUTPUT"); logOutput != "" {
		c.Logging.Output = logOutput
	}

	if logFile := os.Getenv("SUBCONVERTER_LOG_FILE"); logFile != "" {
		c.Logging.File = logFile
	}

	// 安全配置
	if accessTokens := os.Getenv("SUBCONVERTER_ACCESS_TOKENS"); accessTokens != "" {
		c.Security.AccessTokens = strings.Split(accessTokens, ",")
	}

	if corsOrigins := os.Getenv("SUBCONVERTER_CORS_ORIGINS"); corsOrigins != "" {
		c.Security.CorsOrigins = strings.Split(corsOrigins, ",")
	}

	if rateLimit := os.Getenv("SUBCONVERTER_RATE_LIMIT"); rateLimit != "" {
		if rl, err := strconv.Atoi(rateLimit); err == nil {
			c.Security.RateLimit = rl
		}
	}

	if timeout := os.Getenv("SUBCONVERTER_TIMEOUT"); timeout != "" {
		if t, err := strconv.Atoi(timeout); err == nil {
			c.Security.Timeout = t
		}
	}

	// 转换配置
	if defaultTarget := os.Getenv("SUBCONVERTER_DEFAULT_TARGET"); defaultTarget != "" {
		c.Conversion.DefaultTarget = defaultTarget
	}

	if defaultEmoji := os.Getenv("SUBCONVERTER_DEFAULT_EMOJI"); defaultEmoji != "" {
		if de, err := strconv.ParseBool(defaultEmoji); err == nil {
			c.Conversion.DefaultEmoji = de
		}
	}

	if defaultUDP := os.Getenv("SUBCONVERTER_DEFAULT_UDP"); defaultUDP != "" {
		if du, err := strconv.ParseBool(defaultUDP); err == nil {
			c.Conversion.DefaultUDP = du
		}
	}

	if maxNodes := os.Getenv("SUBCONVERTER_MAX_NODES"); maxNodes != "" {
		if mn, err := strconv.Atoi(maxNodes); err == nil {
			c.Conversion.MaxNodes = mn
		}
	}

	if cacheTimeout := os.Getenv("SUBCONVERTER_CACHE_TIMEOUT"); cacheTimeout != "" {
		if ct, err := strconv.Atoi(cacheTimeout); err == nil {
			c.Conversion.CacheTimeout = ct
		}
	}
}

// GetServerAddress 返回服务器地址字符串
// 格式为 "host:port"
func (c *Configuration) GetServerAddress() string {
	return fmt.Sprintf("%s:%d", c.Server.Host, c.Server.Port)
}

// GetReadTimeoutDuration 返回读取超时时间duration
func (c *Configuration) GetReadTimeoutDuration() time.Duration {
	return time.Duration(c.Server.ReadTimeout) * time.Second
}

// GetWriteTimeoutDuration 返回写入超时时间duration
func (c *Configuration) GetWriteTimeoutDuration() time.Duration {
	return time.Duration(c.Server.WriteTimeout) * time.Second
}

// GetTimeoutDuration 返回请求超时时间duration
func (c *Configuration) GetTimeoutDuration() time.Duration {
	return time.Duration(c.Security.Timeout) * time.Second
}

// GetCacheTimeoutDuration 返回缓存超时时间duration
func (c *Configuration) GetCacheTimeoutDuration() time.Duration {
	return time.Duration(c.Conversion.CacheTimeout) * time.Minute
}

// IsAccessTokenValid 检查访问令牌是否有效
func (c *Configuration) IsAccessTokenValid(token string) bool {
	if len(c.Security.AccessTokens) == 0 {
		return true // 空列表表示无需认证
	}
	return contains(c.Security.AccessTokens, token)
}

// IsCorsOriginAllowed 检查CORS源是否允许
func (c *Configuration) IsCorsOriginAllowed(origin string) bool {
	for _, allowed := range c.Security.CorsOrigins {
		if allowed == "*" || allowed == origin {
			return true
		}
	}
	return false
}

// IsTargetSupported 检查目标格式是否支持
func (c *Configuration) IsTargetSupported(target string) bool {
	return contains(c.Conversion.SupportedTargets, target)
}

// contains 检查字符串切片是否包含特定字符串
func contains(slice []string, item string) bool {
	for _, s := range slice {
		if s == item {
			return true
		}
	}
	return false
}