package main

import (
	"context"
	"fmt"
	"go-desk/internal/api"
	"go-desk/internal/database"
	"go-desk/internal/filesystem"
	"go-desk/internal/storage"
	"go-desk/internal/system"
	"os"
	"path/filepath"
	"strings"

	"github.com/wailsapp/wails/v2/pkg/runtime"
)

// App 应用结构体
type App struct {
	ctx           context.Context
	db            *database.DB
	connectionAPI *api.ConnectionAPI
	sqlAPI        *api.SqlAPI
	tabAPI        *api.TabAPI
	updateAPI     *api.UpdateAPI
}

// NewApp 创建新的应用实例
func NewApp() *App {
	return &App{}
}

// Startup 应用启动时调用
func (a *App) Startup(ctx context.Context) {
	a.ctx = ctx

	// 初始化 SQLite 本地存储（核心依赖，必须成功）
	// 如果失败，应用无法正常工作，应该 panic
	_, err := storage.Init()
	if err != nil {
		panic(fmt.Sprintf("SQLite 初始化失败，应用无法启动: %v", err))
	}

	// 初始化数据库连接（可选，用于测试功能）
	// 失败不影响核心功能，只记录日志
	appDB, err := database.Init()
	if err != nil {
		println("数据库连接失败（可选功能）:", err.Error())
	} else {
		a.db = appDB
	}

	// 初始化 API 层（依赖 storage）
	// 如果失败，应用无法正常工作，应该 panic
	if err := a.initAPIs(); err != nil {
		panic(fmt.Sprintf("API 初始化失败，应用无法启动: %v", err))
	}

	// 设置 updateAPI 的上下文
	if a.updateAPI != nil {
		a.updateAPI.SetContext(ctx)
	}
}

// QueryUsers 查询用户列表
func (a *App) QueryUsers(keyword string, status int, role int, organid int, page int, pageSize int, sortField string, sortOrder string) (map[string]interface{}, error) {
	return a.db.QueryUsers(keyword, status, role, organid, page, pageSize, sortField, sortOrder)
}

// Greet 测试方法
func (a *App) Greet(name string) string {
	return "Hello " + name + ", It's show time!"
}

// GetSystemInfo 获取系统信息
func (a *App) GetSystemInfo() (map[string]interface{}, error) {
	return system.GetSystemInfo()
}

// GetCPUInfo 获取 CPU 信息
func (a *App) GetCPUInfo() (map[string]interface{}, error) {
	return system.GetCPUInfo()
}

// GetMemoryInfo 获取内存信息
func (a *App) GetMemoryInfo() (map[string]interface{}, error) {
	return system.GetMemoryInfo()
}

// GetDiskInfo 获取磁盘信息
func (a *App) GetDiskInfo() ([]map[string]interface{}, error) {
	return system.GetDiskInfo()
}

// ReadFile 读取文件
func (a *App) ReadFile(path string) (string, error) {
	return filesystem.ReadFile(path)
}

// WriteFile 写入文件
func (a *App) WriteFile(path, content string) error {
	return filesystem.WriteFile(path, content)
}

// ListDir 列出目录
func (a *App) ListDir(path string) ([]map[string]interface{}, error) {
	return filesystem.ListDir(path)
}

// CreateDir 创建目录
func (a *App) CreateDir(path string) error {
	return filesystem.CreateDir(path)
}

// DeletePath 删除文件或目录
func (a *App) DeletePath(path string) error {
	return filesystem.DeletePath(path)
}

// GetFileInfo 获取文件信息
func (a *App) GetFileInfo(path string) (map[string]interface{}, error) {
	return filesystem.GetFileInfo(path)
}

// GetEnvVars 获取环境变量
func (a *App) GetEnvVars() (map[string]string, error) {
	envVars := make(map[string]string)
	for _, env := range os.Environ() {
		if key, value, found := strings.Cut(env, "="); found {
			envVars[key] = value
		}
	}
	return envVars, nil
}

// GetCommonPaths 获取常用系统路径
func (a *App) GetCommonPaths() (map[string]string, error) {
	homeDir, err := os.UserHomeDir()
	if err != nil {
		return nil, err
	}

	return map[string]string{
		"home":     homeDir,
		"desktop":  filepath.Join(homeDir, "Desktop"),
		"documents": filepath.Join(homeDir, "Documents"),
		"downloads": filepath.Join(homeDir, "Downloads"),
		"root_c":   "C:\\",
		"root_d":   "D:\\",
	}, nil
}

// ========== 数据库连接管理接口 ==========

// initAPIs 初始化所有API（在startup中调用）
func (a *App) initAPIs() error {
	var err error
	a.connectionAPI, err = api.NewConnectionAPI()
	if err != nil {
		return err
	}
	a.sqlAPI, err = api.NewSqlAPI()
	if err != nil {
		return err
	}
	a.tabAPI, err = api.NewTabAPI()
	if err != nil {
		return err
	}
	a.updateAPI, err = api.NewUpdateAPI("https://img.1216.top/go-desk/last-version.json")
	return err
}

// SaveDbConnection 保存数据库连接配置
func (a *App) SaveDbConnection(req api.SaveConnectionRequest) error {
	return a.connectionAPI.SaveDbConnection(req)
}

// ListDbConnections 获取连接列表
func (a *App) ListDbConnections() ([]map[string]interface{}, error) {
	return a.connectionAPI.ListDbConnections()
}

// DeleteDbConnection 删除连接配置
func (a *App) DeleteDbConnection(id uint) error {
	return a.connectionAPI.DeleteDbConnection(id)
}

// TestDbConnection 测试连接（通过已保存的连接ID）
func (a *App) TestDbConnection(id uint) error {
	return a.connectionAPI.TestDbConnection(id)
}

// TestDbConnectionWithParams 测试数据库连接（直接传入参数，不保存数据）
func (a *App) TestDbConnectionWithParams(req api.TestConnectionRequest) error {
	return a.connectionAPI.TestDbConnectionWithParams(req)
}

// ExecuteSQL 执行 SQL 语句
// 注意：SQL 语句应该已经包含分页信息（LIMIT 和 OFFSET），由客户端添加
func (a *App) ExecuteSQL(connectionId uint, sqlStr string, database string) (map[string]interface{}, error) {
	return a.sqlAPI.ExecuteSQL(connectionId, sqlStr, database)
}

// GetDatabases 获取数据库列表
func (a *App) GetDatabases(connectionId uint) ([]string, error) {
	return a.sqlAPI.GetDatabases(connectionId)
}

// GetTables 获取表列表
func (a *App) GetTables(connectionId uint, database string) ([]string, error) {
	return a.sqlAPI.GetTables(connectionId, database)
}

// GetTableStructure 获取表结构
func (a *App) GetTableStructure(connectionId uint, database, tableName string) (map[string]interface{}, error) {
	return a.sqlAPI.GetTableStructure(connectionId, database, tableName)
}

// GetIndexes 获取索引列表
func (a *App) GetIndexes(connectionId uint, database, tableName string) ([]map[string]interface{}, error) {
	return a.sqlAPI.GetIndexes(connectionId, database, tableName)
}

// PreviewTableStructure 预览表结构变更
func (a *App) PreviewTableStructure(connectionId uint, database, tableName string, structure map[string]interface{}) ([]string, error) {
	return a.sqlAPI.PreviewTableStructure(connectionId, database, tableName, structure)
}

// UpdateTableStructure 更新表结构
func (a *App) UpdateTableStructure(connectionId uint, database, tableName string, structure map[string]interface{}) ([]string, error) {
	return a.sqlAPI.UpdateTableStructure(connectionId, database, tableName, structure)
}

// SaveResult 手动保存执行结果
func (a *App) SaveResult(connectionId uint, database, sql string, resultType string, data interface{}, columns []string, rowsAffected int, executionTime int64) (map[string]interface{}, error) {
	return a.sqlAPI.SaveResult(connectionId, database, sql, resultType, data, columns, rowsAffected, executionTime)
}

// GetResultHistory 获取结果历史
func (a *App) GetResultHistory(connectionId *uint, keyword string, limit, offset int) (map[string]interface{}, error) {
	return a.sqlAPI.GetResultHistory(connectionId, keyword, limit, offset)
}

// GetResultHistoryByID 根据ID获取结果历史
func (a *App) GetResultHistoryByID(id uint) (map[string]interface{}, error) {
	return a.sqlAPI.GetResultHistoryByID(id)
}

// DeleteResultHistory 删除结果历史
func (a *App) DeleteResultHistory(id uint) error {
	return a.sqlAPI.DeleteResultHistory(id)
}

// Reload 重新加载窗口（用于菜单项）
func (a *App) Reload() {
	if a.ctx != nil {
		runtime.WindowReload(a.ctx)
	}
}

// ClearCache 清理本地缓存（用于菜单项）
func (a *App) ClearCache() {
	if a.ctx != nil {
		// 发送事件到前端，让前端清理 localStorage
		runtime.EventsEmit(a.ctx, "clear-cache")
	}
}

// ========== SQL 标签页管理接口 ==========

// SaveSqlTabs 保存 SQL 标签页列表
func (a *App) SaveSqlTabs(tabs []map[string]interface{}) error {
	return a.tabAPI.SaveSqlTabs(tabs)
}

// ListSqlTabs 获取 SQL 标签页列表
func (a *App) ListSqlTabs() ([]map[string]interface{}, error) {
	return a.tabAPI.ListSqlTabs()
}

// ========== 版本更新管理接口 ==========

// CheckUpdate 检查更新
func (a *App) CheckUpdate() (map[string]interface{}, error) {
	return a.updateAPI.CheckUpdate()
}

// GetCurrentVersion 获取当前版本号
func (a *App) GetCurrentVersion() (map[string]interface{}, error) {
	return a.updateAPI.GetCurrentVersion()
}

// GetUpdateConfig 获取更新配置
func (a *App) GetUpdateConfig() (map[string]interface{}, error) {
	return a.updateAPI.GetUpdateConfig()
}

// SetUpdateConfig 设置更新配置
func (a *App) SetUpdateConfig(autoCheckEnabled bool, checkIntervalMinutes int, checkURL string) (map[string]interface{}, error) {
	return a.updateAPI.SetUpdateConfig(autoCheckEnabled, checkIntervalMinutes, checkURL)
}

// DownloadUpdate 下载更新包
func (a *App) DownloadUpdate(downloadURL string) (map[string]interface{}, error) {
	return a.updateAPI.DownloadUpdate(downloadURL)
}

// InstallUpdate 安装更新包
func (a *App) InstallUpdate(installerPath string, autoRestart bool) (map[string]interface{}, error) {
	return a.updateAPI.InstallUpdate(installerPath, autoRestart)
}

// InstallUpdateWithHash 安装更新包（带哈希验证）
func (a *App) InstallUpdateWithHash(installerPath string, autoRestart bool, expectedHash string, hashType string) (map[string]interface{}, error) {
	return a.updateAPI.InstallUpdateWithHash(installerPath, autoRestart, expectedHash, hashType)
}

// VerifyUpdateFile 验证更新文件哈希值
func (a *App) VerifyUpdateFile(filePath string, expectedHash string, hashType string) (map[string]interface{}, error) {
	return a.updateAPI.VerifyUpdateFile(filePath, expectedHash, hashType)
}