package storage

import (
	"fmt"
	"log"
	"seeyon-filesystem/config"
	"seeyon-filesystem/model"
)

var engines = make(map[string]Engine)
var policyEngines = make(map[uint64]Engine)

func Register(policyType string, engine Engine) {
	engines[policyType] = engine
}

func GetEngine(policy *model.StoragePolicy) (Engine, error) {
	if engine, ok := policyEngines[policy.ID]; ok {
		return engine, nil
	}
	engine, ok := engines[policy.Type]
	if !ok {
		return nil, fmt.Errorf("不支持的存储类型: %s", policy.Type)
	}
	if policy.Type == "local" && policy.Config.BasePath != "" {
		cfg := config.AppConfig.Storage
		engine = NewLocalEngineWithCDN(policy.Config.BasePath, cfg.CDNHost, cfg.CDNPathPrefix)
	}
	policyEngines[policy.ID] = engine
	return engine, nil
}

func GetEngineByPolicyID(policyID uint64) (Engine, error) {
	if engine, ok := policyEngines[policyID]; ok {
		return engine, nil
	}
	var policy model.StoragePolicy
	if err := config.DB.First(&policy, policyID).Error; err != nil {
		return nil, fmt.Errorf("存储策略不存在: %d", policyID)
	}
	return GetEngine(&policy)
}

func GetDefaultEngine() Engine {
	if engine, ok := engines["local"]; ok {
		return engine
	}
	return nil
}

// InitEngines 初始化所有存储引擎
func InitEngines(localBasePath string) {
	cfg := config.AppConfig.Storage

	// 注册默认本地存储引擎(带CDN配置)
	localEngine := NewLocalEngineWithCDN(localBasePath, cfg.CDNHost, cfg.CDNPathPrefix)
	Register("local", localEngine)

	if cfg.CDNHost != "" {
		log.Printf("CDN已启用: %s%s", cfg.CDNHost, cfg.CDNPathPrefix)
	}

	// 从数据库加载存储策略
	var policies []model.StoragePolicy
	if err := config.DB.Find(&policies).Error; err != nil {
		log.Printf("加载存储策略失败: %v", err)
		return
	}

	for _, policy := range policies {
		switch policy.Type {
		case "local":
			basePath := localBasePath
			if policy.Config.BasePath != "" {
				basePath = policy.Config.BasePath
			}
			policyEngines[policy.ID] = NewLocalEngineWithCDN(basePath, cfg.CDNHost, cfg.CDNPathPrefix)
			log.Printf("初始化本地存储: %s -> %s (CDN: %s)", policy.Name, basePath, cfg.CDNHost+cfg.CDNPathPrefix)

		case "minio":
			engine, err := NewMinIOEngine(
				policy.Config.Endpoint,
				policy.Config.AccessKey,
				policy.Config.SecretKey,
				policy.Config.Bucket,
				policy.Config.UseSSL,
			)
			if err != nil {
				log.Printf("初始化MinIO失败 [%s]: %v", policy.Name, err)
				continue
			}
			policyEngines[policy.ID] = engine
			log.Printf("初始化MinIO: %s -> %s/%s", policy.Name, policy.Config.Endpoint, policy.Config.Bucket)

		case "s3", "oss":
			log.Printf("S3/OSS暂未实现: %s", policy.Name)
		}
	}

	log.Printf("存储引擎初始化完成, 已加载 %d 个策略", len(policyEngines))
}

func GetMinIOEngine(policyID uint64) (*MinIOEngine, error) {
	engine, err := GetEngineByPolicyID(policyID)
	if err != nil {
		return nil, err
	}
	if minioEngine, ok := engine.(*MinIOEngine); ok {
		return minioEngine, nil
	}
	return nil, fmt.Errorf("策略 %d 不是MinIO类型", policyID)
}