voidraft/internal/services/config_service.go

package services

import (
	"errors"
	"fmt"
	"os"
	"sync"
	"time"
	"voidraft/internal/models"

	jsonparser "github.com/knadh/koanf/parsers/json"
	"github.com/knadh/koanf/providers/file"
	"github.com/knadh/koanf/providers/structs"
	"github.com/knadh/koanf/v2"
	"github.com/wailsapp/wails/v3/pkg/services/log"
)

// ConfigService 应用配置服务
type ConfigService struct {
	koanf        *koanf.Koanf       // koanf 实例
	logger       *log.LoggerService // 日志服务
	pathManager  *PathManager       // 路径管理器
	mu           sync.RWMutex       // 读写锁
	fileProvider *file.File         // 文件提供器，用于监听

	// 配置通知服务
	notificationService *ConfigNotificationService
	// 配置迁移服务
	migrationService *ConfigMigrationService[*models.AppConfig]
}

// ConfigError 配置错误
type ConfigError struct {
	Operation string // 操作名称
	Err       error  // 原始错误
}

// Error 实现error接口
func (e *ConfigError) Error() string {
	return fmt.Sprintf("config error during %s: %v", e.Operation, e.Err)
}

// Unwrap 获取原始错误
func (e *ConfigError) Unwrap() error {
	return e.Err
}

// Is 实现错误匹配
func (e *ConfigError) Is(target error) bool {
	var configError *ConfigError
	ok := errors.As(target, &configError)
	return ok
}

// NewConfigService 创建新的配置服务实例
func NewConfigService(logger *log.LoggerService, pathManager *PathManager) *ConfigService {
	// 设置日志服务
	if logger == nil {
		logger = log.New()
	}

	// 设置路径管理器
	if pathManager == nil {
		pathManager = NewPathManager()
	}

	// 使用"."作为键路径分隔符
	k := koanf.New(".")

	notificationService := NewConfigNotificationService(k, logger)
	migrationService := NewAppConfigMigrationService(logger, pathManager)

	// 构造配置服务实例
	service := &ConfigService{
		koanf:               k,
		logger:              logger,
		pathManager:         pathManager,
		notificationService: notificationService,
		migrationService:    migrationService,
	}

	// 初始化配置
	if err := service.initConfig(); err != nil {
		panic(err)
	}

	// 启动配置文件监听
	service.startWatching()

	return service
}

// setDefaults 设置默认配置
func (cs *ConfigService) setDefaults() error {
	defaultConfig := models.NewDefaultAppConfig()

	if err := cs.koanf.Load(structs.Provider(defaultConfig, "json"), nil); err != nil {
		return &ConfigError{Operation: "load_defaults", Err: err}
	}

	return nil
}

// initConfig 初始化配置
func (cs *ConfigService) initConfig() error {
	cs.mu.Lock()
	defer cs.mu.Unlock()

	// 检查配置文件是否存在
	configPath := cs.pathManager.GetSettingsPath()
	if _, err := os.Stat(configPath); os.IsNotExist(err) {
		return cs.createDefaultConfig()
	}

	// 配置文件存在，先加载现有配置
	cs.fileProvider = file.Provider(configPath)
	if err := cs.koanf.Load(cs.fileProvider, jsonparser.Parser()); err != nil {
		return &ConfigError{Operation: "load_config_file", Err: err}
	}

	// 检查并执行配置迁移
	if cs.migrationService != nil {
		result, err := cs.migrationService.MigrateConfig(cs.koanf)
		if err != nil {
			return &ConfigError{Operation: "migrate_config", Err: err}
		}

		if result.Migrated && result.ConfigUpdated {
			// 迁移完成且配置已更新，重新创建文件提供器以监听新文件
			cs.fileProvider = file.Provider(configPath)
		}
	}

	return nil
}

// createDefaultConfig 创建默认配置文件
func (cs *ConfigService) createDefaultConfig() error {
	// 确保配置目录存在
	if err := cs.pathManager.EnsureConfigDir(); err != nil {
		return &ConfigError{Operation: "create_config_dir", Err: err}
	}

	if err := cs.setDefaults(); err != nil {
		return err
	}

	if err := cs.writeConfigToFile(); err != nil {
		return err
	}

	// 创建文件提供器
	cs.fileProvider = file.Provider(cs.pathManager.GetSettingsPath())

	if err := cs.koanf.Load(cs.fileProvider, jsonparser.Parser()); err != nil {
		return &ConfigError{Operation: "load_config_file", Err: err}
	}
	return nil
}

// startWatching 启动配置文件监听
func (cs *ConfigService) startWatching() {
	if cs.fileProvider == nil {
		return
	}
	err := cs.fileProvider.Watch(func(event interface{}, err error) {
		if err != nil {
			return
		}
		cs.koanf.Load(cs.fileProvider, jsonparser.Parser())

		// 使用配置通知服务检查所有已注册的配置变更
		if cs.notificationService != nil {
			cs.notificationService.CheckConfigChanges()
		}
	})

	if err != nil {
		cs.logger.Error("Failed to setup config file watcher", "error", err)
	}
}

// stopWatching 停止配置文件监听
func (cs *ConfigService) stopWatching() {
	if cs.fileProvider != nil {
		cs.fileProvider.Unwatch()
	}
}

// GetConfig 获取完整应用配置
func (cs *ConfigService) GetConfig() (*models.AppConfig, error) {
	cs.mu.RLock()
	defer cs.mu.RUnlock()

	var config models.AppConfig
	if err := cs.koanf.UnmarshalWithConf("", &config, koanf.UnmarshalConf{Tag: "json"}); err != nil {
		return nil, &ConfigError{Operation: "unmarshal_config", Err: err}
	}

	return &config, nil
}

// Set 设置配置项
func (cs *ConfigService) Set(key string, value interface{}) error {
	cs.mu.Lock()
	defer cs.mu.Unlock()

	// 设置值到koanf
	cs.koanf.Set(key, value)

	// 更新时间戳
	cs.koanf.Set("metadata.lastUpdated", time.Now().Format(time.RFC3339))

	// 将配置写回文件
	return cs.writeConfigToFile()
}

// Get 获取配置项
func (cs *ConfigService) Get(key string) interface{} {
	cs.mu.RLock()
	defer cs.mu.RUnlock()
	return cs.koanf.Get(key)
}

// ResetConfig 强制重置所有配置为默认值
func (cs *ConfigService) ResetConfig() error {
	cs.mu.Lock()
	defer cs.mu.Unlock()

	// 停止文件监听
	if cs.fileProvider != nil {
		cs.fileProvider.Unwatch()
		cs.fileProvider = nil
	}

	// 设置默认配置
	if err := cs.setDefaults(); err != nil {
		return &ConfigError{Operation: "reset_set_defaults", Err: err}
	}

	// 写入配置文件
	if err := cs.writeConfigToFile(); err != nil {
		return &ConfigError{Operation: "reset_write_config", Err: err}
	}

	// 重新创建koanf实例
	cs.koanf = koanf.New(".")

	// 重新加载默认配置到koanf
	if err := cs.setDefaults(); err != nil {
		return &ConfigError{Operation: "reset_reload_defaults", Err: err}
	}

	// 重新创建文件提供器
	cs.fileProvider = file.Provider(cs.pathManager.GetSettingsPath())

	// 重新加载配置文件
	if err := cs.koanf.Load(cs.fileProvider, jsonparser.Parser()); err != nil {
		return &ConfigError{Operation: "reset_reload_config", Err: err}
	}

	// 重新启动文件监听
	cs.startWatching()

	// 手动触发配置变更检查，确保通知系统能感知到变更
	if cs.notificationService != nil {
		cs.notificationService.CheckConfigChanges()
	}

	return nil
}

// writeConfigToFile 将配置写回JSON文件
func (cs *ConfigService) writeConfigToFile() error {
	configBytes, err := cs.koanf.Marshal(jsonparser.Parser())
	if err != nil {
		return &ConfigError{Operation: "marshal_config", Err: err}
	}

	if err := os.WriteFile(cs.pathManager.GetSettingsPath(), configBytes, 0644); err != nil {
		return &ConfigError{Operation: "write_config_file", Err: err}
	}

	return nil
}

// SetHotkeyChangeCallback 设置热键配置变更回调
func (cs *ConfigService) SetHotkeyChangeCallback(callback func(enable bool, hotkey *models.HotkeyCombo) error) error {
	cs.mu.Lock()
	defer cs.mu.Unlock()

	// 创建热键监听器并注册
	hotkeyListener := CreateHotkeyListener(callback)
	return cs.notificationService.RegisterListener(hotkeyListener)
}

// SetDataPathChangeCallback 设置数据路径配置变更回调
func (cs *ConfigService) SetDataPathChangeCallback(callback func(oldPath, newPath string) error) error {
	cs.mu.Lock()
	defer cs.mu.Unlock()

	// 创建数据路径监听器并注册
	dataPathListener := CreateDataPathListener(callback)
	return cs.notificationService.RegisterListener(dataPathListener)
}

// ServiceShutdown 关闭服务
func (cs *ConfigService) ServiceShutdown() error {
	cs.stopWatching()
	if cs.notificationService != nil {
		cs.notificationService.Cleanup()
	}
	return nil
}