package config

import (
	"fmt"
	"net"
	"os"
	"path/filepath"
	"runtime"
	"strconv"
	"strings"
	"time"

	"cloudnest/internal/pkg/logger"
	"github.com/spf13/viper"
)

// Config holds all application configuration.
// Config 包含所有应用程序配置。
//
// Configuration loading order (later overrides earlier):
// 1. config.yaml (default values)
// 2. config.{env}.yaml (environment-specific values)
// 3. Environment variables (highest priority, auto-mapped)
//
// 配置加载顺序（后面的覆盖前面的）：
// 1. config.yaml（默认值）
// 2. config.{env}.yaml（环境特定值）
// 3. 环境变量（最高优先级，自动映射）
type Config struct {
	App      AppConfig      `mapstructure:"app"`
	Server   ServerConfig   `mapstructure:"server"`
	Database DatabaseConfig `mapstructure:"database"`
	Cache    CacheConfig    `mapstructure:"cache"`
	Storage  StorageConfig  `mapstructure:"storage"`
	JWT      JWTConfig      `mapstructure:"jwt"`
	Email    EmailConfig    `mapstructure:"email"`
}

// AppConfig holds application-level configuration.
// AppConfig 包含应用程序级别的配置。
type AppConfig struct {
	Name           string `mapstructure:"name"`
	Version        string `mapstructure:"version"`
	Env            string `mapstructure:"env"`
	LogLevel       string `mapstructure:"log_level"`
	FileServiceURL string `mapstructure:"file_service_url"`
}

// ServerConfig holds HTTP server configuration.
// ServerConfig 包含 HTTP 服务器配置。
type ServerConfig struct {
	Host                       string `mapstructure:"host"`
	Port                       int    `mapstructure:"port"`
	GracefulShutdownTimeout    int    `mapstructure:"graceful_shutdown_timeout"`
}

// DatabaseConfig holds database connection configuration.
// DatabaseConfig 包含数据库连接配置。
type DatabaseConfig struct {
	Driver          string `mapstructure:"driver"`
	Host            string `mapstructure:"host"`
	Port            int    `mapstructure:"port"`
	User            string `mapstructure:"user"`
	Password        string `mapstructure:"password"`
	DBName          string `mapstructure:"dbname"`
	Charset         string `mapstructure:"charset"`
	ParseTime       bool   `mapstructure:"parse_time"`
	Loc             string `mapstructure:"loc"`
	MaxIdleConns    int    `mapstructure:"max_idle_conns"`
	MaxOpenConns    int    `mapstructure:"max_open_conns"`
	ConnMaxLifetime int    `mapstructure:"conn_max_lifetime"`
}

// CacheConfig holds Redis cache configuration.
// CacheConfig 包含 Redis 缓存配置。
type CacheConfig struct {
	Driver       string `mapstructure:"driver"`
	Host         string `mapstructure:"host"`
	Port         int    `mapstructure:"port"`
	Password     string `mapstructure:"password"`
	DB           int    `mapstructure:"db"`
	PoolSize     int    `mapstructure:"pool_size"`
	MinIdleConns int    `mapstructure:"min_idle_conns"`
}

// StorageConfig holds MinIO object storage configuration.
// StorageConfig 包含 MinIO 对象存储配置。
type StorageConfig struct {
	Driver           string `mapstructure:"driver"`
	Endpoint         string `mapstructure:"endpoint"`
	AccessKeyID      string `mapstructure:"access_key_id"`
	SecretAccessKey  string `mapstructure:"secret_access_key"`
	BucketName       string `mapstructure:"bucket_name"`
	UseSSL           bool   `mapstructure:"use_ssl"`
	PresignDuration  int    `mapstructure:"presign_duration"`
	MaxFileSize      int    `mapstructure:"max_file_size"`
	RecycleBinExpireDays int `mapstructure:"recycle_bin_expire_days"`
}

// JWTConfig holds JWT authentication configuration.
// JWTConfig 包含 JWT 认证配置。
type JWTConfig struct {
	Secret    string `mapstructure:"secret"`
	ExpiresIn int    `mapstructure:"expires_in"`
	Issuer    string `mapstructure:"issuer"`
}

// EmailConfig holds SMTP email configuration.
// EmailConfig 包含 SMTP 邮件配置。
type EmailConfig struct {
	SMTPHost     string `mapstructure:"smtp_host"`
	SMTPPort     int    `mapstructure:"smtp_port"`
	SMTPUsername string `mapstructure:"smtp_username"`
	SMTPPassword string `mapstructure:"smtp_password"`
	FromName     string `mapstructure:"from_name"`
}

// DSN builds MySQL DSN string from config fields.
// DSN 从配置字段构建 MySQL DSN 字符串。
//
// Returns:
//   - string: The formatted DSN string.
//
// 返回值:
//   - string: 格式化后的 DSN 字符串。
func (c *DatabaseConfig) DSN() string {
	return fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=%s&parseTime=%t&loc=%s",
		c.User,
		c.Password,
		c.Host,
		c.Port,
		c.DBName,
		c.Charset,
		c.ParseTime,
		c.Loc,
	)
}

// Addr builds Redis connection address.
// Addr 构建 Redis 连接地址。
//
// Returns:
//   - string: The formatted "host:port" address.
//
// 返回值:
//   - string: 格式化的 "host:port" 地址。
func (c *CacheConfig) Addr() string {
	return fmt.Sprintf("%s:%d", c.Host, c.Port)
}

// PresignDuration builds time.Duration from hours config.
// PresignDuration 从小时配置构建 time.Duration。
//
// Returns:
//   - time.Duration: The presign duration.
//
// 返回值:
//   - time.Duration: 预签名有效期。
func (c *StorageConfig) PresignDurationTime() time.Duration {
	return time.Duration(c.PresignDuration) * time.Hour
}

// ExpiresIn builds time.Duration from hours config.
// ExpiresIn 从小时配置构建 time.Duration。
//
// Returns:
//   - time.Duration: The JWT expiration duration.
//
// 返回值:
//   - time.Duration: JWT 过期时间。
func (c *JWTConfig) ExpiresInDuration() time.Duration {
	return time.Duration(c.ExpiresIn) * time.Hour
}

// getEnv returns the current environment name from CLOUDNEST_ENV or defaults to "dev".
// getEnv 从 CLOUDNEST_ENV 获取当前环境名称，默认为 "dev"。
func getEnv() string {
	env := strings.ToLower(os.Getenv("CLOUDNEST_ENV"))
	if env == "" {
		env = "dev"
	}
	return env
}

// getConfigDir returns the absolute path to the configs directory.
// getConfigDir 返回 configs 目录的绝对路径。
//
// Note:
//   - Tries to find configs/ relative to the executable or current working directory.
//   - Falls back to current working directory if not found.
//
// 注意:
//   - 尝试从可执行文件或当前工作目录相对位置找到 configs/。
//   - 如果找不到则回退到当前工作目录。
func getConfigDir() string {
	// Try to get the directory of the current file
	// 尝试获取当前文件的目录
	_, filename, _, ok := runtime.Caller(0)
	if ok {
		dir := filepath.Join(filepath.Dir(filename), "..", "..", "configs")
		if _, err := os.Stat(dir); err == nil {
			return dir
		}
	}

	// Try executable directory / 尝试可执行文件目录
	ex, err := os.Executable()
	if err == nil {
		dir := filepath.Join(filepath.Dir(ex), "configs")
		if _, err := os.Stat(dir); err == nil {
			return dir
		}
	}

	// Try current working directory / 尝试当前工作目录
	cwd, err := os.Getwd()
	if err == nil {
		dir := filepath.Join(cwd, "configs")
		if _, err := os.Stat(dir); err == nil {
			return dir
		}
	}

	return "configs"
}

// Load reads and parses configuration from YAML files and environment variables.
// Load 从 YAML 文件和环境变量中读取并解析配置。
//
// Loading order (later overrides earlier):
// 1. configs/config.yaml (base defaults)
// 2. configs/config.{env}.yaml (env-specific overrides)
// 3. Environment variables (highest priority)
//
// Environment selection via CLOUDNEST_ENV:
//   - "dev"     -> configs/config.dev.yaml
//   - "test"    -> configs/config.test.yaml
//   - "prod"    -> configs/config.prod.yaml
//   - default   -> configs/config.dev.yaml
//
// Environment variables are automatically mapped with the following prefixes:
//   - APP_      -> app
//   - SERVER_   -> server
//   - DB_       -> database
//   - REDIS_    -> cache
//   - MINIO_    -> storage
//   - JWT_      -> jwt
//   - EMAIL_    -> email
//
// Returns:
//   - *Config: A pointer to the parsed configuration struct.
//
// 配置加载顺序（后面的覆盖前面的）：
// 1. configs/config.yaml（基础默认值）
// 2. configs/config.{env}.yaml（环境特定覆盖）
// 3. 环境变量（最高优先级）
//
// 通过 CLOUDNEST_ENV 选择环境：
//   - "dev"     -> configs/config.dev.yaml
//   - "test"    -> configs/config.test.yaml
//   - "prod"    -> configs/config.prod.yaml
//   - 默认       -> configs/config.dev.yaml
//
// 环境变量自动映射的前缀：
//   - APP_      -> app
//   - SERVER_   -> server
//   - DB_       -> database
//   - REDIS_    -> cache
//   - MINIO_    -> storage
//   - JWT_      -> jwt
//   - EMAIL_    -> email
//
// 返回值:
//   - *Config: 解析后的配置结构体指针。
func Load() *Config {
	env := getEnv()
	configDir := getConfigDir()

	v := viper.New()
	v.SetConfigType("yaml")

	// 1. Load base config / 加载基础配置
	baseConfig := filepath.Join(configDir, "config.yaml")
	v.SetConfigFile(baseConfig)
	if err := v.ReadInConfig(); err != nil {
		logger.Warn("failed to read base config, using defaults", "error", err, "path", baseConfig)
	} else {
		logger.Info("base config loaded", "path", baseConfig)
	}

	// 2. Load environment-specific config / 加载环境特定配置
	envConfig := filepath.Join(configDir, fmt.Sprintf("config.%s.yaml", env))
	if _, err := os.Stat(envConfig); err == nil {
		envViper := viper.New()
		envViper.SetConfigFile(envConfig)
		if err := envViper.ReadInConfig(); err == nil {
			// Merge environment config into base config
			// 将环境配置合并到基础配置中
			for _, key := range envViper.AllKeys() {
				v.Set(key, envViper.Get(key))
			}
			logger.Info("env config loaded", "env", env, "path", envConfig)
		} else {
			logger.Warn("failed to read env config", "env", env, "error", err)
		}
	} else {
		logger.Info("env config not found, using base config", "env", env, "path", envConfig)
	}

	// 3. Enable environment variable overrides / 启用环境变量覆盖
	v.AutomaticEnv()
	v.SetEnvPrefix("")
	v.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))

	// Map environment variables to nested config keys
	// 将环境变量映射到嵌套配置键
	envMappings := map[string]string{
		"APP_NAME":             "app.name",
		"APP_VERSION":          "app.version",
		"APP_ENV":              "app.env",
		"APP_LOG_LEVEL":        "app.log_level",
		"APP_FILE_SERVICE_URL": "app.file_service_url",

		"SERVER_HOST":                        "server.host",
		"SERVER_PORT":                        "server.port",
		"SERVER_GRACEFUL_SHUTDOWN_TIMEOUT":   "server.graceful_shutdown_timeout",

		"DB_DRIVER":             "database.driver",
		"DB_HOST":               "database.host",
		"DB_PORT":               "database.port",
		"DB_USER":               "database.user",
		"DB_PASSWORD":           "database.password",
		"DB_NAME":               "database.dbname",
		"DB_CHARSET":            "database.charset",
		"DB_PARSE_TIME":         "database.parse_time",
		"DB_LOC":                "database.loc",
		"DB_MAX_IDLE_CONNS":     "database.max_idle_conns",
		"DB_MAX_OPEN_CONNS":     "database.max_open_conns",
		"DB_CONN_MAX_LIFETIME":  "database.conn_max_lifetime",

		"REDIS_HOST":          "cache.host",
		"REDIS_PORT":          "cache.port",
		"REDIS_PASSWORD":      "cache.password",
		"REDIS_DB":            "cache.db",
		"REDIS_POOL_SIZE":     "cache.pool_size",
		"REDIS_MIN_IDLE_CONNS": "cache.min_idle_conns",

		"MINIO_ENDPOINT":         "storage.endpoint",
		"MINIO_ACCESS_KEY":       "storage.access_key_id",
		"MINIO_SECRET_KEY":       "storage.secret_access_key",
		"MINIO_BUCKET":           "storage.bucket_name",
		"MINIO_USE_SSL":          "storage.use_ssl",
		"MINIO_PRESIGN_DURATION": "storage.presign_duration",
		"MINIO_MAX_FILE_SIZE":    "storage.max_file_size",
		"MINIO_RECYCLE_BIN_EXPIRE_DAYS": "storage.recycle_bin_expire_days",

		"JWT_SECRET":     "jwt.secret",
		"JWT_EXPIRES_IN": "jwt.expires_in",
		"JWT_ISSUER":     "jwt.issuer",

		"EMAIL_SMTP_HOST":     "email.smtp_host",
		"EMAIL_SMTP_PORT":     "email.smtp_port",
		"EMAIL_SMTP_USERNAME": "email.smtp_username",
		"EMAIL_SMTP_PASSWORD": "email.smtp_password",
		"EMAIL_FROM_NAME":     "email.from_name",
	}

	for envKey, configKey := range envMappings {
		if val := os.Getenv(envKey); val != "" {
			// Try to parse as int/bool first, fallback to string
			// 先尝试解析为 int/bool，否则回退为 string
			if intVal, err := strconv.Atoi(val); err == nil {
				v.Set(configKey, intVal)
			} else if boolVal, err := strconv.ParseBool(val); err == nil {
				v.Set(configKey, boolVal)
			} else {
				v.Set(configKey, val)
			}
		}
	}

	// 4. Unmarshal into struct / 反序列化到结构体
	var cfg Config
	if err := v.Unmarshal(&cfg); err != nil {
		logger.Fatal("failed to unmarshal config", "error", err)
	}

	logger.Info("config loaded",
		"app", fmt.Sprintf("%s:%s", cfg.App.Name, cfg.App.Version),
		"env", cfg.App.Env,
		"config_dir", configDir,
	)

	return &cfg
}

// IsDev returns true if running in development environment.
// IsDev 如果运行在开发环境则返回 true。
func (c *Config) IsDev() bool {
	return strings.ToLower(c.App.Env) == "development" || strings.ToLower(c.App.Env) == "dev"
}

// IsProd returns true if running in production environment.
// IsProd 如果运行在生产环境则返回 true。
func (c *Config) IsProd() bool {
	return strings.ToLower(c.App.Env) == "production" || strings.ToLower(c.App.Env) == "prod"
}

// IsTest returns true if running in test environment.
// IsTest 如果运行在测试环境则返回 true。
func (c *Config) IsTest() bool {
	return strings.ToLower(c.App.Env) == "test"
}

// FindAvailablePort checks if the configured port is available, returns next available if occupied.
// FindAvailablePort 检查配置的端口是否可用，如果被占用则返回下一个可用端口。
//
// Parameters:
//   - preferredPort: The preferred port to use.
//   - maxAttempts: Maximum number of ports to try.
//
// Returns:
//   - int: An available port number.
//   - error: An error if no port is available after max attempts.
//
// Note:
//   - Only searches in development mode. In production, it returns the configured port directly.
//   - Search range: preferredPort to preferredPort + maxAttempts - 1.
//
// 参数:
//   - preferredPort: 首选端口。
//   - maxAttempts: 最大尝试次数。
//
// 返回值:
//   - int: 可用端口号。
//   - error: 如果超过最大尝试次数仍未找到可用端口则返回错误。
//
// 注意:
//   - 仅在开发模式下搜索。生产模式下直接返回配置端口。
//   - 搜索范围: preferredPort 到 preferredPort + maxAttempts - 1。
func FindAvailablePort(preferredPort int, maxAttempts int) (int, error) {
	for i := 0; i < maxAttempts; i++ {
		port := preferredPort + i
		addr := fmt.Sprintf(":%d", port)
		listener, err := net.Listen("tcp", addr)
		if err != nil {
			logger.Warn("port occupied, trying next", "port", port, "error", err)
			continue
		}
		listener.Close()
		return port, nil
	}
	return 0, fmt.Errorf("no available port found in range %d-%d", preferredPort, preferredPort+maxAttempts-1)
}