fscan/Common/i18n/manager.go

package i18n

import (
	"fmt"
	"sync"
)

/*
manager.go - 国际化管理器

提供统一的国际化文本管理，支持多语言动态切换，
包含完整的消息库和高效的文本查询机制。
*/

// =============================================================================
// 常量定义
// =============================================================================

// 支持的语言常量
const (
	LangZH = "zh" // 中文
	LangEN = "en" // 英文
)

// 默认配置
const (
	DefaultLanguage = LangZH // 默认语言
	FallbackLanguage = LangEN // 回退语言
)

// =============================================================================
// 国际化管理器
// =============================================================================

// Manager 国际化管理器
type Manager struct {
	mu               sync.RWMutex
	currentLanguage  string
	fallbackLanguage string
	messages         map[string]map[string]string
	enabled          bool
}

// 全局管理器实例
var globalManager = NewManager()

// NewManager 创建新的国际化管理器
func NewManager() *Manager {
	return &Manager{
		currentLanguage:  DefaultLanguage,
		fallbackLanguage: FallbackLanguage,
		messages:         make(map[string]map[string]string),
		enabled:          true,
	}
}

// =============================================================================
// 基础管理方法
// =============================================================================

// SetLanguage 设置当前语言
func (m *Manager) SetLanguage(lang string) {
	m.mu.Lock()
	defer m.mu.Unlock()
	m.currentLanguage = lang
}

// GetLanguage 获取当前语言
func (m *Manager) GetLanguage() string {
	m.mu.RLock()
	defer m.mu.RUnlock()
	return m.currentLanguage
}

// SetFallbackLanguage 设置回退语言
func (m *Manager) SetFallbackLanguage(lang string) {
	m.mu.Lock()
	defer m.mu.Unlock()
	m.fallbackLanguage = lang
}

// Enable 启用国际化
func (m *Manager) Enable() {
	m.mu.Lock()
	defer m.mu.Unlock()
	m.enabled = true
}

// Disable 禁用国际化
func (m *Manager) Disable() {
	m.mu.Lock()
	defer m.mu.Unlock()
	m.enabled = false
}

// IsEnabled 检查是否启用国际化
func (m *Manager) IsEnabled() bool {
	m.mu.RLock()
	defer m.mu.RUnlock()
	return m.enabled
}

// =============================================================================
// 消息管理方法
// =============================================================================

// AddMessage 添加单个消息
func (m *Manager) AddMessage(key string, translations map[string]string) {
	m.mu.Lock()
	defer m.mu.Unlock()
	m.messages[key] = translations
}

// AddMessages 批量添加消息
func (m *Manager) AddMessages(messages map[string]map[string]string) {
	m.mu.Lock()
	defer m.mu.Unlock()
	for key, translations := range messages {
		m.messages[key] = translations
	}
}

// GetMessage 获取指定键和语言的消息
func (m *Manager) GetMessage(key, lang string) (string, bool) {
	m.mu.RLock()
	defer m.mu.RUnlock()
	
	if translations, exists := m.messages[key]; exists {
		if message, exists := translations[lang]; exists {
			return message, true
		}
	}
	return "", false
}

// HasMessage 检查是否存在指定键的消息
func (m *Manager) HasMessage(key string) bool {
	m.mu.RLock()
	defer m.mu.RUnlock()
	_, exists := m.messages[key]
	return exists
}

// GetAllMessages 获取所有消息
func (m *Manager) GetAllMessages() map[string]map[string]string {
	m.mu.RLock()
	defer m.mu.RUnlock()
	
	// 创建深拷贝
	result := make(map[string]map[string]string)
	for key, translations := range m.messages {
		result[key] = make(map[string]string)
		for lang, message := range translations {
			result[key][lang] = message
		}
	}
	return result
}

// GetMessageCount 获取消息总数
func (m *Manager) GetMessageCount() int {
	m.mu.RLock()
	defer m.mu.RUnlock()
	return len(m.messages)
}

// GetSupportedLanguages 获取支持的语言列表
func (m *Manager) GetSupportedLanguages() []string {
	m.mu.RLock()
	defer m.mu.RUnlock()
	
	languageSet := make(map[string]bool)
	for _, translations := range m.messages {
		for lang := range translations {
			languageSet[lang] = true
		}
	}
	
	languages := make([]string, 0, len(languageSet))
	for lang := range languageSet {
		languages = append(languages, lang)
	}
	return languages
}

// =============================================================================
// 文本获取方法
// =============================================================================

// GetText 获取国际化文本（支持格式化）
func (m *Manager) GetText(key string, args ...interface{}) string {
	if !m.IsEnabled() {
		// 如果禁用国际化，返回原始键名
		if len(args) > 0 {
			return fmt.Sprintf(key, args...)
		}
		return key
	}

	m.mu.RLock()
	currentLang := m.currentLanguage
	fallbackLang := m.fallbackLanguage
	m.mu.RUnlock()

	// 尝试获取当前语言的消息
	if message, exists := m.GetMessage(key, currentLang); exists {
		if len(args) > 0 {
			return fmt.Sprintf(message, args...)
		}
		return message
	}

	// 回退到回退语言
	if currentLang != fallbackLang {
		if message, exists := m.GetMessage(key, fallbackLang); exists {
			if len(args) > 0 {
				return fmt.Sprintf(message, args...)
			}
			return message
		}
	}

	// 如果都没找到，返回键名作为兜底
	if len(args) > 0 {
		return fmt.Sprintf(key, args...)
	}
	return key
}

// GetTextWithLanguage 获取指定语言的文本
func (m *Manager) GetTextWithLanguage(key, lang string, args ...interface{}) string {
	if !m.IsEnabled() {
		if len(args) > 0 {
			return fmt.Sprintf(key, args...)
		}
		return key
	}

	if message, exists := m.GetMessage(key, lang); exists {
		if len(args) > 0 {
			return fmt.Sprintf(message, args...)
		}
		return message
	}

	// 如果指定语言没找到，使用回退语言
	m.mu.RLock()
	fallbackLang := m.fallbackLanguage
	m.mu.RUnlock()

	if lang != fallbackLang {
		if message, exists := m.GetMessage(key, fallbackLang); exists {
			if len(args) > 0 {
				return fmt.Sprintf(message, args...)
			}
			return message
		}
	}

	// 兜底返回键名
	if len(args) > 0 {
		return fmt.Sprintf(key, args...)
	}
	return key
}

// =============================================================================
// 全局访问函数
// =============================================================================

// GetGlobalManager 获取全局国际化管理器
func GetGlobalManager() *Manager {
	return globalManager
}

// SetLanguage 设置全局语言
func SetLanguage(lang string) {
	globalManager.SetLanguage(lang)
}

// GetLanguage 获取全局当前语言
func GetLanguage() string {
	return globalManager.GetLanguage()
}

// AddMessage 添加消息到全局管理器
func AddMessage(key string, translations map[string]string) {
	globalManager.AddMessage(key, translations)
}

// AddMessages 批量添加消息到全局管理器
func AddMessages(messages map[string]map[string]string) {
	globalManager.AddMessages(messages)
}

// GetText 从全局管理器获取国际化文本
func GetText(key string, args ...interface{}) string {
	return globalManager.GetText(key, args...)
}

// GetTextWithLanguage 从全局管理器获取指定语言文本
func GetTextWithLanguage(key, lang string, args ...interface{}) string {
	return globalManager.GetTextWithLanguage(key, lang, args...)
}

// Enable 启用全局国际化
func Enable() {
	globalManager.Enable()
}

// Disable 禁用全局国际化
func Disable() {
	globalManager.Disable()
}

// IsEnabled 检查全局国际化是否启用
func IsEnabled() bool {
	return globalManager.IsEnabled()
}

// HasMessage 检查全局管理器是否存在指定消息
func HasMessage(key string) bool {
	return globalManager.HasMessage(key)
}

// GetMessageCount 获取全局消息总数
func GetMessageCount() int {
	return globalManager.GetMessageCount()
}

// GetSupportedLanguages 获取全局支持的语言列表
func GetSupportedLanguages() []string {
	return globalManager.GetSupportedLanguages()
}

// =============================================================================
// 初始化函数
// =============================================================================

// init 初始化全局国际化管理器
func init() {
	// 设置默认配置
	globalManager.SetLanguage(DefaultLanguage)
	globalManager.SetFallbackLanguage(FallbackLanguage)
	globalManager.Enable()
}