package main

import (
	"context"
	"errors"
	"net/http"
	"os/signal"
	"strings"
	"syscall"
	"time"

	"github.com/gin-gonic/gin"

	"github.com/hhs/camtalk/internal/api"
	"github.com/hhs/camtalk/internal/ai/llm"
	"github.com/hhs/camtalk/internal/ai/stt"
	"github.com/hhs/camtalk/internal/ai/tts"
	"github.com/hhs/camtalk/internal/config"
	"github.com/hhs/camtalk/internal/logger"
	"github.com/hhs/camtalk/internal/orchestrator"
	"github.com/hhs/camtalk/internal/session"
	"github.com/hhs/camtalk/internal/ws"
)

var startTime = time.Now()

func main() {
	// 加载配置
	cfg, err := config.Load()
	if err != nil {
		panic("failed to load config: " + err.Error())
	}

	// 初始化日志
	logger.Init(cfg.Log.Level, cfg.Log.Format)
	defer logger.Sync()

	logger.Log.Infow("config loaded",
		"env", cfg.App.Env,
		"addr", cfg.Server.Addr(),
	)

	// 初始化 Session Manager（MVP 默认内存实现）
	var sessionMgr session.Manager
	// TODO: 当 Redis 配置非空时切换为 RedisManager
	sessionMgr = session.NewMemoryManager(30*time.Minute, 20)
	defer sessionMgr.(*session.MemoryManager).Stop()

	// 初始化 AI 服务
	var sttService stt.Service
	switch strings.ToLower(cfg.AI.STT.Provider) {
	case "mimo", "xiaomi":
		sttService = stt.NewMiMoService(cfg.AI.STT.APIKey, cfg.AI.STT.Model, cfg.AI.STT.Endpoint, logger.Log)
	default:
		sttService = stt.NewDeepgramService(cfg.AI.STT.APIKey, cfg.AI.STT.Model, cfg.AI.STT.Endpoint, logger.Log)
	}
	llmService := llm.NewOpenAIService(cfg.AI.LLM.APIKey, cfg.AI.LLM.Model, cfg.AI.LLM.Endpoint, cfg.AI.LLM.Timeout, logger.Log)
	ttsService := tts.NewOpenAIService(cfg.AI.TTS.APIKey, cfg.AI.TTS.Model, cfg.AI.TTS.Voice, cfg.AI.TTS.Endpoint, cfg.AI.TTS.Speed, cfg.AI.TTS.Timeout, logger.Log)

	// 初始化 Orchestrator
	orch := orchestrator.New(sttService, llmService, ttsService, sessionMgr, cfg.AI.LLM.Model)

	// Gin 模式
	if cfg.App.Env == "prod" {
		gin.SetMode(gin.ReleaseMode)
	}

	r := gin.New()
	r.Use(gin.Recovery())

	// REST API
	apiGroup := r.Group("/api")
	{
		apiGroup.GET("/health", healthHandler(sessionMgr))
	}

	// Session REST 端点
	sessionHandler := api.NewSessionHandler(sessionMgr)
	sessionHandler.RegisterRoutes(apiGroup)

	// WebSocket
	r.GET("/ws", ws.ServeWS(sessionMgr, orch))

	// HTTP Server
	srv := &http.Server{
		Addr:         cfg.Server.Addr(),
		Handler:      r,
		ReadTimeout:  time.Duration(cfg.Server.ReadTimeout) * time.Second,
		WriteTimeout: time.Duration(cfg.Server.WriteTimeout) * time.Second,
	}

	// Graceful shutdown
	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
	defer stop()

	go func() {
		logger.Log.Infow("server starting", "addr", srv.Addr)
		if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
			logger.Log.Fatalw("listen failed", "error", err)
		}
	}()

	<-ctx.Done()
	logger.Log.Info("shutting down...")

	shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	if err := srv.Shutdown(shutdownCtx); err != nil {
		logger.Log.Errorw("shutdown error", "error", err)
	}
	logger.Log.Info("server stopped")
}

// healthHandler 健康检查。
func healthHandler(sessionMgr session.Manager) gin.HandlerFunc {
	return func(c *gin.Context) {
		c.JSON(200, gin.H{
			"status":          "ok",
			"version":         "0.1.0",
			"uptime_seconds":  int(time.Since(startTime).Seconds()),
			"active_sessions": sessionMgr.ActiveCount(),
		})
	}
}