package handler

import (
	"log"
	"net/http"
	"time"

	"github.com/gin-gonic/gin"

	"github.com/yourname/cyrene-ai/gateway/internal/middleware"
	"github.com/yourname/cyrene-ai/gateway/internal/store"
	"github.com/yourname/cyrene-ai/gateway/internal/ws"
)

// SessionHandler 会话管理处理器
type SessionHandler struct {
	store *store.SessionStore // PostgreSQL 持久化存储
	hub   *ws.Hub
	useDB bool // 数据库是否可用
}

// NewSessionHandler 创建会话处理器
func NewSessionHandler(hub *ws.Hub, s *store.SessionStore) *SessionHandler {
	return &SessionHandler{
		store: s,
		hub:   hub,
		useDB: s != nil && s.IsAvailable(),
	}
}

// ========== POST /api/v1/sessions — 创建会话 ==========

type createSessionRequest struct {
	UserID    string `json:"user_id"`
	SessionID string `json:"session_id"`
	Title     string `json:"title"`
	IsMain    bool   `json:"is_main"`
}

// Create 创建新会话
func (h *SessionHandler) Create(c *gin.Context) {
	userID := middleware.GetUserID(c)

	var req createSessionRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		// 允许空 body
	}
	if req.UserID != "" {
		userID = req.UserID
	}
	if req.Title == "" {
		req.Title = "新的对话"
	}
	if req.SessionID == "" {
		req.SessionID = "session_" + randomID(12)
	}

	if h.useDB {
		if err := h.store.CreateSession(userID, req.SessionID, req.Title, req.IsMain); err != nil {
			log.Printf("[SessionHandler] 创建会话失败: %v", err)
			c.JSON(http.StatusInternalServerError, gin.H{"error": "创建会话失败", "errorType": "db_error"})
			return
		}
	}

	c.JSON(http.StatusCreated, gin.H{
		"id":         req.SessionID,
		"user_id":    userID,
		"title":      req.Title,
		"is_main":    req.IsMain,
		"created_at": time.Now().UnixMilli(),
		"updated_at": time.Now().UnixMilli(),
	})
}

// ========== GET /api/v1/sessions?user_id=xxx — 获取用户会话列表 ==========

// List 获取会话列表 (按 updated_at DESC 排序)
func (h *SessionHandler) List(c *gin.Context) {
	userID := c.Query("user_id")
	if userID == "" {
		userID = middleware.GetUserID(c)
	}

	if h.useDB {
		sessions, err := h.store.GetUserSessions(userID)
		if err != nil {
			log.Printf("[SessionHandler] 查询会话列表失败: %v", err)
			c.JSON(http.StatusInternalServerError, gin.H{"error": "查询会话失败", "errorType": "db_error"})
			return
		}
		// 转换为列表格式
		result := make([]gin.H, 0, len(sessions))
		for _, s := range sessions {
			result = append(result, gin.H{
				"id":         s.ID,
				"user_id":    s.UserID,
				"title":      s.Title,
				"is_main":    s.IsMain,
				"created_at": s.CreatedAt.UnixMilli(),
				"updated_at": s.UpdatedAt.UnixMilli(),
			})
		}
		c.JSON(http.StatusOK, gin.H{"sessions": result})
		return
	}

	// 降级：返回空列表
	c.JSON(http.StatusOK, gin.H{"sessions": []gin.H{}})
}

// ========== GET /api/v1/sessions/:id — 获取单个会话 ==========

// Get 获取单个会话信息
func (h *SessionHandler) Get(c *gin.Context) {
	sessionID := c.Param("id")

	if h.useDB {
		session, err := h.store.GetSession(sessionID)
		if err != nil {
			log.Printf("[SessionHandler] 查询会话失败: %v", err)
			c.JSON(http.StatusInternalServerError, gin.H{"error": "查询会话失败", "errorType": "db_error"})
			return
		}
		if session == nil {
			c.JSON(http.StatusNotFound, gin.H{
				"error":     "会话不存在",
				"errorType": "session_not_found",
				"hint":      "该会话可能已被删除或尚未创建",
			})
			return
		}
		c.JSON(http.StatusOK, gin.H{
			"id":         session.ID,
			"user_id":    session.UserID,
			"title":      session.Title,
			"is_main":    session.IsMain,
			"created_at": session.CreatedAt.UnixMilli(),
			"updated_at": session.UpdatedAt.UnixMilli(),
		})
		return
	}

	c.JSON(http.StatusNotFound, gin.H{
		"error":     "会话存储不可用",
		"errorType": "store_unavailable",
		"hint":      "数据库连接未建立，Gateway 运行在仅内存模式",
	})
}

// ========== DELETE /api/v1/sessions/:id — 删除会话 ==========

// Delete 删除会话 (不删除记忆)
func (h *SessionHandler) Delete(c *gin.Context) {
	sessionID := c.Param("id")

	if h.useDB {
		if err := h.store.DeleteSession(sessionID); err != nil {
			log.Printf("[SessionHandler] 删除会话失败: %v", err)
			c.JSON(http.StatusInternalServerError, gin.H{"error": "删除会话失败", "errorType": "db_error"})
			return
		}
	}

	// 同时清理 Hub 中的缓存
	h.hub.DeleteConversation("", sessionID)

	c.JSON(http.StatusOK, gin.H{"status": "deleted"})
}

// ========== DELETE /api/v1/sessions?user_id=xxx — 删除用户所有会话 ==========

// DeleteAll 删除用户所有会话 (不删除记忆)
func (h *SessionHandler) DeleteAll(c *gin.Context) {
	userID := c.Query("user_id")
	if userID == "" {
		userID = middleware.GetUserID(c)
	}

	if h.useDB {
		if err := h.store.DeleteAllUserSessions(userID); err != nil {
			log.Printf("[SessionHandler] 删除用户所有会话失败: %v", err)
			c.JSON(http.StatusInternalServerError, gin.H{"error": "删除会话失败", "errorType": "db_error"})
			return
		}
	}

	c.JSON(http.StatusOK, gin.H{"status": "deleted"})
}

// ========== GET /api/v1/sessions/:id/messages?limit=50 — 获取会话消息 ==========

// GetMessages 获取会话的完整消息列表
func (h *SessionHandler) GetMessages(c *gin.Context) {
	sessionID := c.Param("id")
	limit := 50
	if l := c.Query("limit"); l != "" {
		parsed := 0
		for _, ch := range l {
			if ch < '0' || ch > '9' {
				break
			}
			parsed = parsed*10 + int(ch-'0')
		}
		if parsed > 0 {
			limit = parsed
		}
	}

	if h.useDB {
		messages, err := h.store.GetMessages(sessionID, limit)
		if err != nil {
			log.Printf("[SessionHandler] 查询消息失败: %v", err)
			c.JSON(http.StatusInternalServerError, gin.H{"error": "查询消息失败", "errorType": "db_error"})
			return
		}
		// 转换为统一格式
		result := make([]gin.H, 0, len(messages))
		for _, m := range messages {
			result = append(result, gin.H{
				"id":         m.ID,
				"session_id": m.SessionID,
				"role":       m.Role,
				"content":    m.Content,
				"created_at": m.CreatedAt.UnixMilli(),
			})
		}
		c.JSON(http.StatusOK, gin.H{"messages": result})
		return
	}

	// 降级：从 Hub 内存缓存读取
	messages := h.hub.GetConversation("", sessionID)
	if messages == nil {
		messages = []ws.Message{}
	}
	c.JSON(http.StatusOK, gin.H{"messages": messages})
}

// ========== DELETE /api/v1/sessions/:id/messages — 清空会话消息 ==========

// ClearMessages 清空会话所有消息但不删除会话本身
func (h *SessionHandler) ClearMessages(c *gin.Context) {
	sessionID := c.Param("id")

	if h.useDB {
		if err := h.store.ClearSessionMessages(sessionID); err != nil {
			log.Printf("[SessionHandler] 清空消息失败: %v", err)
			c.JSON(http.StatusInternalServerError, gin.H{"error": "清空消息失败", "errorType": "db_error"})
			return
		}
	}

	// 同时清理 Hub 内存缓存
	h.hub.DeleteConversation("", sessionID)

	c.JSON(http.StatusOK, gin.H{"status": "cleared"})
}

// ========== Admin 端点 ==========

// ListActiveSessions 获取当前所有活跃 WebSocket 会话列表 (管理员)
func (h *SessionHandler) ListActiveSessions(c *gin.Context) {
	sessions := h.hub.GetAllActiveSessions()
	if sessions == nil {
		sessions = []*ws.SessionState{}
	}

	c.JSON(http.StatusOK, gin.H{
		"sessions": sessions,
		"total":    len(sessions),
	})
}

// GetActiveSessions 返回按用户分组的活跃会话列表
func (h *SessionHandler) GetActiveSessions(c *gin.Context) {
	sessionsByUser := h.hub.GetActiveSessionsByUser()
	if sessionsByUser == nil {
		sessionsByUser = make(map[string][]*ws.SessionState)
	}

	c.JSON(http.StatusOK, gin.H{
		"users": sessionsByUser,
	})
}

// GetSession 获取指定会话的详细信息 (管理员)
func (h *SessionHandler) GetSession(c *gin.Context) {
	sessionID := c.Param("id")
	if sessionID == "" {
		c.JSON(http.StatusBadRequest, gin.H{"error": "缺少会话ID"})
		return
	}

	session := h.hub.GetSession(sessionID)
	if session == nil {
		c.JSON(http.StatusNotFound, gin.H{
			"error":     "会话不存在",
			"errorType": "session_not_found",
			"hint":      "该会话可能已断开，或 Gateway 重启后内存数据已清空",
		})
		return
	}

	c.JSON(http.StatusOK, session)
}

// 简单的工具函数
func randomID(n int) string {
	const letters = "abcdefghijklmnopqrstuvwxyz0123456789"
	b := make([]byte, n)
	for i := range b {
		b[i] = letters[i%len(letters)]
	}
	return string(b)
}