package config

import (
	"sync"

	"git.x2erp.com/qdy/go-base/config/subconfigs"
	"git.x2erp.com/qdy/go-base/logger"
)

// IConfig 主配置接口（更新支持多数据库）
type IConfig interface {
	// 多数据库支持
	GetDatabase() *subconfigs.DatabaseConfig                  // 获取默认数据库（向后兼容）
	GetDatabases() *subconfigs.DatabasesConfig                // 获取所有数据库配置
	GetDatabaseConfig(name string) *subconfigs.DatabaseConfig // 按名称获取数据库配置

	//多服务支持
	GetService() *subconfigs.ServiceConfig                  //获取默认微服务配置
	GetServices() *subconfigs.ServicesConfig                //获所有定义的微服务配置
	GetServiceConfig(name string) *subconfigs.ServiceConfig //获取微服务配置

	// 其他配置（保持不变）
	GetRedis() *subconfigs.RedisConfig
	GetDoris() *subconfigs.DorisConfig
	GetRabbitMQ() *subconfigs.RabbitMQConfig

	GetHTTP() *subconfigs.HTTPConfig
	GetMicro() *subconfigs.MicroConfig
	GetLog() *subconfigs.LogConfig
	GetInitError() error

	// 配置检查（更新）
	IsDatabaseConfigured() bool
	IsDatabaseConfiguredByName(name string) bool
	IsDorisConfigured() bool
	IsRedisConfigured() bool

	SetAppName(name string)
	SetAppVersion(version string)
	SetAppEnv(name string)

	GetAppName() string
	GetAppVersion() string
	GetAppEnv() string
	GetAppAuthToken() string
}

// Config 主配置结构体 - 访问门面
type Config struct {
	initError error // 初始化错误
}

// ========== 数据库相关方法（更新） ==========

// GetDatabases 获取所有数据库配置
func (c *Config) GetDatabases() *subconfigs.DatabasesConfig {
	if config := subconfigs.GetRegisteredConfig("databases"); config != nil {
		if dbs, ok := config.(*subconfigs.DatabasesConfig); ok {
			return dbs
		}
	}
	return nil
}

// GetDatabase 获取默认数据库配置（向后兼容）
func (c *Config) GetDatabase() *subconfigs.DatabaseConfig {
	dbs := c.GetDatabases()
	if dbs == nil {
		logger.Errorf("获取默认数据库连接配置发生错误：配置为空！")
		return nil
	}
	return dbs.GetDefaultDatabase()
}

// GetDatabaseConfig 按名称获取数据库配置
func (c *Config) GetDatabaseConfig(name string) *subconfigs.DatabaseConfig {
	dbs := c.GetDatabases()
	if dbs == nil {
		return nil
	}
	return dbs.GetDatabase(name)
}

// IsDatabaseConfigured 检查默认数据库是否配置
func (c *Config) IsDatabaseConfigured() bool {
	dbs := c.GetDatabases()
	if dbs == nil {
		return false
	}
	return dbs.IsConfigured()
}

// IsDatabaseConfiguredByName 检查指定名称的数据库是否配置
func (c *Config) IsDatabaseConfiguredByName(name string) bool {
	dbs := c.GetDatabases()
	if dbs == nil {
		return false
	}
	return dbs.IsConfigured()
}

// ========== 其他配置方法（保持不变） ==========

func (c *Config) GetRedis() *subconfigs.RedisConfig {
	if config := subconfigs.GetRegisteredConfig("redis"); config != nil {
		return config.(*subconfigs.RedisConfig)
	}
	return nil
}

func (c *Config) GetDoris() *subconfigs.DorisConfig {
	if config := subconfigs.GetRegisteredConfig("doris"); config != nil {
		return config.(*subconfigs.DorisConfig)
	}
	return nil
}

func (c *Config) GetRabbitMQ() *subconfigs.RabbitMQConfig {
	if config := subconfigs.GetRegisteredConfig("rabbitmq"); config != nil {
		return config.(*subconfigs.RabbitMQConfig)
	}
	return nil
}

// ========== 微服务相关方法（更新） ==========

// GetServices 获取所有微服务配置
func (c *Config) GetServices() *subconfigs.ServicesConfig {
	if config := subconfigs.GetRegisteredConfig("services"); config != nil {
		if dbs, ok := config.(*subconfigs.ServicesConfig); ok {
			return dbs
		}
	}
	return nil
}

// GetService 获取默认微服务配置（向后兼容）
func (c *Config) GetService() *subconfigs.ServiceConfig {
	dbs := c.GetServices()
	if dbs == nil {
		logger.Errorf("获取默认微服务配置发生错误：配置为空！")
		return nil
	}
	return dbs.GetDefaultService()
}

// GetServiceConfig 按名称获取微服务配置
func (c *Config) GetServiceConfig(name string) *subconfigs.ServiceConfig {
	dbs := c.GetServices()
	if dbs == nil {
		return nil
	}
	return dbs.GetService(name)
}

func (c *Config) GetHTTP() *subconfigs.HTTPConfig {
	if config := subconfigs.GetRegisteredConfig("http"); config != nil {
		return config.(*subconfigs.HTTPConfig)
	}
	return nil
}

func (c *Config) GetMicro() *subconfigs.MicroConfig {
	if config := subconfigs.GetRegisteredConfig("micro"); config != nil {
		return config.(*subconfigs.MicroConfig)
	}
	return nil
}

func (c *Config) GetLog() *subconfigs.LogConfig {
	if config := subconfigs.GetRegisteredConfig("log"); config != nil {
		return config.(*subconfigs.LogConfig)
	}
	return nil
}

func (c *Config) GetInitError() error {
	return c.initError
}

// 实现 IConfig 接口的其他方法
func (c *Config) IsDorisConfigured() bool {
	doris := c.GetDoris()
	return doris != nil && doris.IsConfigured()
}

func (c *Config) IsRedisConfigured() bool {
	redis := c.GetRedis()
	return redis != nil && redis.IsConfigured()
}

// 设置方法
func (c *Config) SetAppEnv(name string) {
	if c.GetAppEnv() == "" {
		c.GetServices().AppEnv = name
	}
}

func (c *Config) SetAppName(name string) {
	if c.GetAppName() == "" {
		c.GetServices().AppName = name
	}
}
func (c *Config) SetAppVersion(name string) {
	if c.GetAppVersion() == "" {
		c.GetServices().AppVersion = name
	}
}

// GetAppVersion 获取服务版本
func (c *Config) GetAppVersion() string {
	return c.GetServices().AppVersion
}

// GetAppEnv 获取环境
func (c *Config) GetAppEnv() string {
	return c.GetServices().AppEnv
}

// GetAppName 获取当前应用名称
func (c *Config) GetAppName() string {
	return c.GetServices().AppName
}

// GetAppAuthToken 得到当前配置文件里的token
func (c *Config) GetAppAuthToken() string {
	return c.GetServices().AppAuthToken
}

// ========== 包级便捷函数（更新） ==========

// GetDatabases 包级便捷函数 - 获取所有数据库配置
func GetDatabases() *subconfigs.DatabasesConfig {
	if cfgInstance == nil {
		return nil
	}
	return cfgInstance.GetDatabases()
}

// GetDatabase 包级便捷函数 - 获取默认数据库配置（向后兼容）
func GetDatabase() *subconfigs.DatabaseConfig {
	if cfgInstance == nil {
		return &subconfigs.DatabaseConfig{}
	}
	return cfgInstance.GetDatabase()
}

// GetDatabaseConfig 包级便捷函数 - 按名称获取数据库配置
func GetDatabaseConfig(name string) *subconfigs.DatabaseConfig {
	if cfgInstance == nil {
		return nil
	}
	return cfgInstance.GetDatabaseConfig(name)
}

// GetRedis 包级便捷函数 - 获取Redis配置
func GetRedis() *subconfigs.RedisConfig {
	if cfgInstance == nil {
		return &subconfigs.RedisConfig{}
	}
	return cfgInstance.GetRedis()
}

// GetHTTP 包级便捷函数 - 获取HTTP配置
func GetHTTP() *subconfigs.HTTPConfig {
	if cfgInstance == nil {
		return &subconfigs.HTTPConfig{}
	}
	return cfgInstance.GetHTTP()
}

// GetLog 包级便捷函数 - 获取日志配置
func GetLog() *subconfigs.LogConfig {
	if cfgInstance == nil {
		return &subconfigs.LogConfig{}
	}
	return cfgInstance.GetLog()
}

func GetMicro() *subconfigs.MicroConfig {
	if cfgInstance == nil {
		return &subconfigs.MicroConfig{}
	}
	return cfgInstance.GetMicro()
}

func GetService() *subconfigs.ServiceConfig {
	if cfgInstance == nil {
		return &subconfigs.ServiceConfig{}
	}
	return cfgInstance.GetService()
}

// GetServiceConfig 包级便捷函数 - 按名称获取数微服务配置
func GetServiceConfig(name string) *subconfigs.ServiceConfig {
	if cfgInstance == nil {
		return nil
	}
	return cfgInstance.GetServiceConfig(name)
}

// ========== 单例管理 ==========

var (
	cfgInstance *Config
	once        sync.Once
)

// GetConfig 获取主配置（单例模式）
func GetConfig() (IConfig, error) {
	once.Do(func() {
		cfgInstance = &Config{}
		cfgInstance.initError = LoadConfig() // 加载配置到注册表
	})
	return cfgInstance, cfgInstance.initError
}

// GetInitError 包级函数 - 兼容现有代码调用
func GetInitError() error {
	return cfgInstance.GetInitError()
}

// GetConfigWithError 新方法 - 同时获取配置和错误
func GetConfigWithError() (IConfig, error) {
	cfg, err := GetConfig()
	return cfg, err
}