db_view/service/internal/bootstrap/bootstrap.go

package bootstrap

import (
	"context"
	"fmt"
	"os"
	"os/signal"
	"syscall"

	"dbview/service/internal/common/logger"
	"dbview/service/internal/common/manager/connection"
	"dbview/service/internal/common/manager/storage"
	"dbview/service/internal/common/manager/task"
	"dbview/service/internal/common/mcp"
	"dbview/service/internal/config"

	"go.uber.org/zap"
)

// App 应用实例
type App struct {
	Config         *config.AppConfig
	Logger         logger.Logger
	AuditLogger    logger.AuditLogger
	StorageManager storage.StorageInterface // 使用 StorageInterface 接口
	TaskManager    *task.Manager
	ConnectionPool *connection.ConnectionPool
	MCP            *mcp.Component
	Context        context.Context
	Cancel         context.CancelFunc
}

// InitializeApp 初始化应用
func InitializeApp(configPath string) (*App, error) {
	ctx, cancel := context.WithCancel(context.Background())
	app := &App{
		Context: ctx,
		Cancel:  cancel,
	}

	// 1. 加载配置
	cfg, err := loadConfig(configPath)
	if err != nil {
		cancel()
		return nil, fmt.Errorf("加载配置文件失败，配置文件路径: %s，错误: %v", configPath, err)
	}
	app.Config = cfg

	// 2. 初始化日志系统
	appLogger, err := initializeLogger(cfg)
	if err != nil {
		cancel()
		return nil, fmt.Errorf("初始化日志系统失败，错误: %v", err)
	}
	app.Logger = appLogger

	// 3. 初始化审计系统
	auditLogger, err := initializeAuditLogger(cfg)
	if err != nil {
		app.Logger.Error("初始化审计系统失败", zap.Error(err))
		cancel()
		return nil, fmt.Errorf("初始化审计日志系统失败，错误: %v", err)
	}
	app.AuditLogger = auditLogger

	// 4. 初始化存储系统
	storageMgr, err := initializeStorage(cfg)
	if err != nil {
		app.Logger.Error("初始化存储系统失败", zap.Error(err))
		cancel()
		return nil, fmt.Errorf("初始化存储管理系统失败，存储类型: %s，错误: %v", cfg.Storage.Type, err)
	}
	app.StorageManager = storageMgr

	// 5. 注册数据库驱动
	// if err := registerDatabaseDrivers(); err != nil {
	// 	app.Logger.Error("注册数据库驱动失败", zap.Error(err))
	// 	cancel()
	// 	return nil, fmt.Errorf("注册数据库驱动失败，错误: %v", err)
	// }

	// 6. 初始化连接池
	connPool := initializeConnectionPool(ctx, appLogger)
	app.ConnectionPool = connPool

	// 7. 初始化任务管理器
	taskManager := initializeTaskManager(ctx)
	app.TaskManager = taskManager

	// 8. 初始化 MCP 组件（按配置开关）
	mcpComponent := initializeMCP(ctx, cfg, appLogger, storageMgr, connPool, taskManager)
	app.MCP = mcpComponent

	// 9. 记录启动信息
	app.Logger.Info("应用初始化完成",
		zap.String("config_path", configPath),
		zap.Bool("audit_enabled", cfg.Audit.Enabled),
		zap.String("storage_type", cfg.Storage.Type),
		zap.Bool("mcp_enabled", cfg.MCP.Enable),
	)

	return app, nil
}

// initializeLogger 初始化日志系统
func initializeLogger(cfg *config.AppConfig) (logger.Logger, error) {
	return logger.NewLogger(
		logger.WithLevel(cfg.Log.GetLogLevel()),
		logger.WithDevelopment(cfg.Log.Development),
		logger.WithEncoding(cfg.Log.Encoding),
		logger.WithOutputPaths(cfg.Log.OutputPaths...),
	)
}

// initializeAuditLogger 初始化审计日志系统
func initializeAuditLogger(cfg *config.AppConfig) (logger.AuditLogger, error) {
	return logger.NewAuditLogger(
		logger.WithEnabled(cfg.Audit.Enabled),
		logger.WithDatabasePath(cfg.Audit.DatabasePath),
		logger.WithRetention(cfg.Audit.RetentionDays),
		logger.WithBufferSize(cfg.Audit.BufferSize),
	)
}

// initializeStorage 初始化存储系统
func initializeStorage(cfg *config.AppConfig) (storage.StorageInterface, error) {
	// 检查数据库文件是否已存在
	var dbExists bool
	if cfg.Storage.Type == "db" {
		if _, err := os.Stat(cfg.Storage.DatabasePath); err == nil {
			dbExists = true
		}
	}

	var storageMgr storage.StorageInterface
	var err error

	switch cfg.Storage.Type {
	case "db":
		storageMgr, err = storage.NewDBStorage(cfg.Storage.DatabasePath)
		if err != nil {
			return nil, err
		}

		// 只有在数据库文件不存在时才调用CreateDefaultConfig
		if !dbExists {
			if err := storageMgr.CreateDefaultConfig(); err != nil {
				return nil, fmt.Errorf("创建默认配置失败: %v", err)
			}
		}

		return storageMgr, nil
	default:
		return nil, fmt.Errorf("不支持的存储类型: %s，可用类型:  db", cfg.Storage.Type)
	}
}

// initializeConnectionPool 初始化连接池
func initializeConnectionPool(ctx context.Context, log logger.Logger) *connection.ConnectionPool {
	pool := connection.NewConnectionPool(ctx)
	if log != nil {
		log.Info("数据库连接池初始化完成")
	}
	return pool
}

// initializeTaskManager 初始化任务管理器
func initializeTaskManager(ctx context.Context) *task.Manager {
	return task.NewManager(ctx, 5)
}

// loadConfig 加载配置文件，如果不存在则创建默认配置
func loadConfig(configPath string) (*config.AppConfig, error) {
	cfg, err := config.LoadConfig(configPath)
	if err != nil {
		return nil, err
	}

	// 设置默认值
	cfg.SetDefaults()
	return cfg, nil
}

// Shutdown 优雅关闭应用
func (app *App) Shutdown() error {
	app.Logger.Info("开始关闭应用")

	// 取消上下文
	app.Cancel()

	// 关闭连接池
	if app.ConnectionPool != nil {
		if err := app.ConnectionPool.CloseAllConnections(); err != nil {
			app.Logger.Warn("关闭连接池失败", zap.Error(err))
		}
	}

	// 关闭存储管理器
	if app.StorageManager != nil {
		if closer, ok := app.StorageManager.(interface{ Close() error }); ok {
			if err := closer.Close(); err != nil {
				app.Logger.Warn("关闭存储管理器失败", zap.Error(err))
			}
		}
	}

	// 关闭任务管理器
	if app.TaskManager != nil {
		app.TaskManager.Shutdown()
	}

	// 同步日志
	if app.Logger != nil {
		app.Logger.Sync()
	}

	if app.AuditLogger != nil {
		app.AuditLogger.Sync()
	}

	app.Logger.Info("应用已关闭")
	return nil
}

// Run 运行应用
func (app *App) Run() error {
	app.Logger.Info("应用开始运行")

	// 设置信号处理
	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)

	// 等待信号
	select {
	case sig := <-sigChan:
		app.Logger.Info("收到信号，开始关闭", zap.String("signal", sig.String()))
		return app.Shutdown()
	case <-app.Context.Done():
		app.Logger.Info("上下文取消，开始关闭")
		return app.Shutdown()
	}
}