package v1

import (
	"net/http"
	"strconv"
	"strings"

	"github.com/gin-gonic/gin"

	"github.com/gochat/gochat/internal/model"
	"github.com/gochat/gochat/internal/search"
	"github.com/gochat/gochat/internal/service"
	"github.com/gochat/gochat/pkg/pagination"
	"github.com/gochat/gochat/pkg/response"

	"gorm.io/datatypes"
)

// ConversationHandler handles conversation-related API endpoints.
// Reference: Chatwoot app/controllers/api/v1/conversations_controller.rb
type ConversationHandler struct {
	conversationSvc *service.ConversationService
	messageSvc      *service.MessageService
	auditSvc        *service.AuditService
}

const chatwootAttachmentResultsPerPage = 100

// NewConversationHandler creates a new ConversationHandler.
func NewConversationHandler(conversationSvc *service.ConversationService, messageSvc *service.MessageService) *ConversationHandler {
	return &ConversationHandler{conversationSvc: conversationSvc, messageSvc: messageSvc}
}

func (h *ConversationHandler) WithAuditService(auditSvc *service.AuditService) *ConversationHandler {
	h.auditSvc = auditSvc
	return h
}

// @Summary List conversations for an account
// @Description Retrieves all conversations for an account with pagination, optionally filtered by status query param
// @Tags Conversations
// @Accept json
// @Produce json
// @Param account_id path uint true "Account ID"
// @Param status query string false "Filter by conversation status (open/pending/resolved/snoozed)"
// @Param page query int false "Page number" default(1)
// @Param page_size query int false "Items per page" default(25)
// @Success 200 {object} []model.Conversation
// @Failure 400 {object} model.ErrorResponse
// @Failure 401 {object} model.ErrorResponse
// @Failure 500 {object} model.ErrorResponse
// @Security ApiKeyAuth
// @Router /api/v1/accounts/{account_id}/conversations [get]
func (h *ConversationHandler) List(c *gin.Context) {
	accountID, err := parseUintParam(c, "account_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account_id")
		return
	}

	p := pagination.Parse(c)

	// Support status filter via query param
	status := c.Query("status")
	var conversations []model.Conversation
	var total int64

	if status != "" {
		result, count, svcErr := h.conversationSvc.ListByStatus(c.Request.Context(), accountID, status, p.Offset, p.PerPage)
		if svcErr != nil {
			handleServiceError(c, svcErr)
			return
		}
		conversations = result
		total = count
	} else {
		result, count, svcErr := h.conversationSvc.ListByAccount(c.Request.Context(), accountID, p.Offset, p.PerPage)
		if svcErr != nil {
			handleServiceError(c, svcErr)
			return
		}
		conversations = result
		total = count
	}

	c.JSON(http.StatusOK, serializeConversationList(c.Request.Context(), h.conversationSvc.DB(), conversations, total))
}

// Create creates a new conversation.
// POST /api/v1/accounts/:account_id/conversations
// Reference: Chatwoot conversations#create
func (h *ConversationHandler) Create(c *gin.Context) {
	accountID, err := parseUintParam(c, "account_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account_id")
		return
	}

	var req service.CreateConversationRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrValidation, err.Error())
		return
	}

	conversation, svcErr := h.conversationSvc.Create(c.Request.Context(), accountID, req)
	if svcErr != nil {
		handleServiceError(c, svcErr)
		return
	}
	recordAuditMutation(c, h.auditSvc, auditMutation{
		AccountID:      accountID,
		AuditableType:  "Conversation",
		AuditableID:    conversation.ID,
		Action:         "update",
		AuditedChanges: gin.H{"status": conversation.Status, "priority": conversation.Priority, "sla_policy_id": conversation.SlaPolicyID},
	})
	c.JSON(http.StatusOK, serializeConversation(c.Request.Context(), h.conversationSvc.DB(), conversation))
}

// @Summary Get a single conversation
// @Description Retrieves detailed information about a specific conversation within an account
// @Tags Conversations
// @Accept json
// @Produce json
// @Param account_id path uint true "Account ID"
// @Param id path uint true "Conversation ID"
// @Success 200 {object} model.Conversation
// @Failure 400 {object} model.ErrorResponse
// @Failure 401 {object} model.ErrorResponse
// @Failure 404 {object} model.ErrorResponse
// @Failure 500 {object} model.ErrorResponse
// @Security ApiKeyAuth
// @Router /api/v1/accounts/{account_id}/conversations/{id} [get]
func (h *ConversationHandler) Get(c *gin.Context) {
	accountID, err := parseUintParam(c, "account_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account_id")
		return
	}
	conversationID, err := parseUintParam(c, "conversation_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid conversation id")
		return
	}

	conversation, svcErr := h.conversationSvc.GetByAccountAndDisplayIDOrID(c.Request.Context(), accountID, conversationID)
	if svcErr != nil {
		handleServiceError(c, svcErr)
		return
	}
	c.JSON(http.StatusOK, serializeConversation(c.Request.Context(), h.conversationSvc.DB(), conversation))
}

// Update updates a conversation (status, priority).
// PATCH /api/v1/accounts/:account_id/conversations/:id
// Reference: Chatwoot conversations#update
func (h *ConversationHandler) Update(c *gin.Context) {
	accountID, err := parseUintParam(c, "account_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account_id")
		return
	}
	conversationID, err := parseUintParam(c, "conversation_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid conversation id")
		return
	}

	var req service.UpdateConversationRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrValidation, err.Error())
		return
	}

	conversation, svcErr := h.conversationSvc.GetByAccountAndDisplayIDOrID(c.Request.Context(), accountID, conversationID)
	if svcErr != nil {
		handleServiceError(c, svcErr)
		return
	}
	conversation, svcErr = h.conversationSvc.Update(c.Request.Context(), accountID, conversation.ID, req)
	if svcErr != nil {
		handleServiceError(c, svcErr)
		return
	}
	c.JSON(http.StatusOK, serializeConversation(c.Request.Context(), h.conversationSvc.DB(), conversation))
}

// Delete soft-deletes a conversation.
// DELETE /api/v1/accounts/:account_id/conversations/:id
func (h *ConversationHandler) Delete(c *gin.Context) {
	accountID, err := parseUintParam(c, "account_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account_id")
		return
	}
	conversationID, err := parseUintParam(c, "conversation_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid conversation id")
		return
	}

	conversation, ok := h.resolveConversationRoute(c, accountID, conversationID)
	if !ok {
		return
	}

	if svcErr := h.conversationSvc.Delete(c.Request.Context(), accountID, conversation.ID); svcErr != nil {
		handleServiceError(c, svcErr)
		return
	}
	recordAuditMutation(c, h.auditSvc, auditMutation{
		AccountID:      accountID,
		AuditableType:  "Conversation",
		AuditableID:    conversation.ID,
		Action:         "destroy",
		AuditedChanges: gin.H{"id": conversation.ID, "display_id": conversation.DisplayID},
	})
	response.NoContent(c)
}

// @Summary Assign an agent to a conversation
// @Description Assigns a specific agent to a conversation by providing the assignee ID
// @Tags Conversations
// @Accept json
// @Produce json
// @Param account_id path uint true "Account ID"
// @Param id path uint true "Conversation ID"
// @Param body body service.AssignAgentRequest true "Agent assignment payload"
// @Success 200 {object} model.Conversation
// @Failure 400 {object} model.ErrorResponse
// @Failure 401 {object} model.ErrorResponse
// @Failure 404 {object} model.ErrorResponse
// @Failure 500 {object} model.ErrorResponse
// @Security ApiKeyAuth
// @Router /api/v1/accounts/{account_id}/conversations/{id}/assign [post]
func (h *ConversationHandler) AssignAgent(c *gin.Context) {
	accountID, err := parseUintParam(c, "account_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account_id")
		return
	}
	conversationID, err := parseUintParam(c, "conversation_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid conversation id")
		return
	}

	var req service.AssignAgentRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrValidation, err.Error())
		return
	}

	conversation, ok := h.resolveConversationRoute(c, accountID, conversationID)
	if !ok {
		return
	}
	conversation, svcErr := h.conversationSvc.AssignAgent(c.Request.Context(), accountID, conversation.ID, req.AssigneeID)
	if svcErr != nil {
		handleServiceError(c, svcErr)
		return
	}
	recordAuditMutation(c, h.auditSvc, auditMutation{
		AccountID:      accountID,
		AuditableType:  "Conversation",
		AuditableID:    conversation.ID,
		Action:         "update",
		AuditedChanges: gin.H{"assignee_id": conversation.AssigneeID},
	})
	c.JSON(http.StatusOK, serializeUserFromDB(c.Request.Context(), h.conversationSvc.DB(), req.AssigneeID, accountID))
}

// @Summary Toggle conversation status
// @Description Toggles the status of a conversation between open, pending, resolved, or snoozed
// @Tags Conversations
// @Accept json
// @Produce json
// @Param account_id path uint true "Account ID"
// @Param id path uint true "Conversation ID"
// @Param body body service.ToggleStatusRequest true "Status toggle payload"
// @Success 200 {object} model.Conversation
// @Failure 400 {object} model.ErrorResponse
// @Failure 401 {object} model.ErrorResponse
// @Failure 404 {object} model.ErrorResponse
// @Failure 500 {object} model.ErrorResponse
// @Security ApiKeyAuth
// @Router /api/v1/accounts/{account_id}/conversations/{id}/toggle_status [post]
// ToggleStatus toggles the conversation status (open/pending/resolved/snoozed).
// POST /api/v1/accounts/:account_id/conversations/:id/toggle_status
// Reference: Chatwoot conversations#toggle_status
func (h *ConversationHandler) ToggleStatus(c *gin.Context) {
	accountID, err := parseUintParam(c, "account_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account_id")
		return
	}
	conversationID, err := parseUintParam(c, "conversation_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid conversation id")
		return
	}

	var req service.ToggleStatusRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrValidation, err.Error())
		return
	}

	conversation, ok := h.resolveConversationRoute(c, accountID, conversationID)
	if !ok {
		return
	}
	conversation, svcErr := h.conversationSvc.ToggleStatus(c.Request.Context(), accountID, conversation.ID, req)
	if svcErr != nil {
		handleServiceError(c, svcErr)
		return
	}
	recordAuditMutation(c, h.auditSvc, auditMutation{
		AccountID:      accountID,
		AuditableType:  "Conversation",
		AuditableID:    conversation.ID,
		Action:         "update",
		AuditedChanges: gin.H{"status": conversation.Status, "snoozed_until": conversation.SnoozedUntil},
	})
	c.JSON(http.StatusOK, gin.H{"meta": gin.H{}, "payload": gin.H{
		"success":         true,
		"conversation_id": conversationDisplayID(conversation),
		"current_status":  conversation.Status,
		"snoozed_until":   conversation.SnoozedUntil,
	}})
}

// @Summary Mute a conversation
// @Description Mutes a conversation to suppress notifications
// @Tags Conversations
// @Accept json
// @Produce json
// @Param account_id path uint true "Account ID"
// @Param id path uint true "Conversation ID"
// @Success 200 {object} model.Conversation
// @Failure 400 {object} model.ErrorResponse
// @Failure 401 {object} model.ErrorResponse
// @Failure 404 {object} model.ErrorResponse
// @Failure 500 {object} model.ErrorResponse
// @Security ApiKeyAuth
// @Router /api/v1/accounts/{account_id}/conversations/{id}/mute [post]
// Mute mutes a conversation.
// POST /api/v1/accounts/:account_id/conversations/:id/mute
func (h *ConversationHandler) Mute(c *gin.Context) {
	accountID, err := parseUintParam(c, "account_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account_id")
		return
	}
	conversationID, err := parseUintParam(c, "conversation_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid conversation id")
		return
	}

	conversation, ok := h.resolveConversationRoute(c, accountID, conversationID)
	if !ok {
		return
	}
	_, svcErr := h.conversationSvc.Mute(c.Request.Context(), accountID, conversation.ID)
	if svcErr != nil {
		handleServiceError(c, svcErr)
		return
	}
	c.Status(http.StatusOK)
}

// @Summary Unmute a conversation
// @Description Unmutes a conversation to restore notifications
// @Tags Conversations
// @Accept json
// @Produce json
// @Param account_id path uint true "Account ID"
// @Param id path uint true "Conversation ID"
// @Success 200 {object} model.Conversation
// @Failure 400 {object} model.ErrorResponse
// @Failure 401 {object} model.ErrorResponse
// @Failure 404 {object} model.ErrorResponse
// @Failure 500 {object} model.ErrorResponse
// @Security ApiKeyAuth
// @Router /api/v1/accounts/{account_id}/conversations/{id}/unmute [post]
// Unmute unmutes a conversation.
// POST /api/v1/accounts/:account_id/conversations/:id/unmute
func (h *ConversationHandler) Unmute(c *gin.Context) {
	accountID, err := parseUintParam(c, "account_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account_id")
		return
	}
	conversationID, err := parseUintParam(c, "conversation_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid conversation id")
		return
	}

	conversation, ok := h.resolveConversationRoute(c, accountID, conversationID)
	if !ok {
		return
	}
	_, svcErr := h.conversationSvc.Unmute(c.Request.Context(), accountID, conversation.ID)
	if svcErr != nil {
		handleServiceError(c, svcErr)
		return
	}
	c.Status(http.StatusOK)
}

// UpdateLabels updates the labels on a conversation.
// PATCH /api/v1/accounts/:account_id/conversations/:id/labels
// Reference: Chatwoot conversations#labels
func (h *ConversationHandler) UpdateLabels(c *gin.Context) {
	accountID, err := parseUintParam(c, "account_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account_id")
		return
	}
	conversationID, err := parseUintParam(c, "conversation_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid conversation id")
		return
	}

	var req service.UpdateLabelsRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrValidation, err.Error())
		return
	}

	conversation, ok := h.resolveConversationRoute(c, accountID, conversationID)
	if !ok {
		return
	}
	conversation, svcErr := h.conversationSvc.UpdateLabels(c.Request.Context(), accountID, conversation.ID, req.Labels)
	if svcErr != nil {
		handleServiceError(c, svcErr)
		return
	}
	c.JSON(http.StatusOK, serializeConversation(c.Request.Context(), h.conversationSvc.DB(), conversation))
}

// @Summary Search conversations
// @Description Searches conversations by query string with pagination and search mode support
// @Tags Conversations
// @Accept json
// @Produce json
// @Param account_id path uint true "Account ID"
// @Param q query string true "Search query"
// @Param search_mode query string false "Search mode (prefix/semantic/fulltext)" default(prefix)
// @Param page query int false "Page number" default(1)
// @Param page_size query int false "Items per page" default(25)
// @Success 200 {object} []model.Conversation
// @Failure 400 {object} model.ErrorResponse
// @Failure 401 {object} model.ErrorResponse
// @Failure 500 {object} model.ErrorResponse
// @Security ApiKeyAuth
// @Router /api/v1/accounts/{account_id}/conversations/search [get]
// Search searches conversations by label or metadata.
// GET /api/v1/accounts/:account_id/conversations/search?q=...
func (h *ConversationHandler) Search(c *gin.Context) {
	accountID, err := parseUintParam(c, "account_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account_id")
		return
	}

	q := c.Query("q")
	if q == "" {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "search query 'q' is required")
		return
	}

	p := pagination.Parse(c)
	searchMode := search.ParseSearchMode(c.DefaultQuery("search_mode", ""))

	conversations, total, svcErr := h.conversationSvc.Search(c.Request.Context(), accountID, q, p.Offset, p.PerPage, searchMode)
	if svcErr != nil {
		handleServiceError(c, svcErr)
		return
	}

	c.JSON(http.StatusOK, serializeConversationList(c.Request.Context(), h.conversationSvc.DB(), conversations, total))
}

// Filter retrieves conversations matching advanced filter criteria.
// POST /api/v1/accounts/:account_id/conversations/filter
// Reference: Chatwoot ConversationsController#filter — uses ConversationFinder with assignee_type/team_id/conversation_type
func (h *ConversationHandler) Filter(c *gin.Context) {
	accountID, err := parseUintParam(c, "account_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account_id")
		return
	}

	userID := getUserID(c)

	var req service.FilterParams
	if err := c.ShouldBindJSON(&req); err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrValidation, err.Error())
		return
	}

	p := pagination.Parse(c)

	result, svcErr := h.conversationSvc.Filter(c.Request.Context(), accountID, userID, req, p.Offset, p.PerPage)
	if svcErr != nil {
		handleServiceError(c, svcErr)
		return
	}

	payload := serializeConversationList(c.Request.Context(), h.conversationSvc.DB(), result.Conversations, result.Count.AllCount)
	payload.Data.Meta = chatwootConversationCounts{
		MineCount:       result.Count.MineCount,
		AssignedCount:   result.Count.AssignedCount,
		UnassignedCount: result.Count.UnassignedCount,
		AllCount:        result.Count.AllCount,
	}
	c.JSON(http.StatusOK, payload.Data)
}

// UpdatePriority updates the priority of a conversation.
// PATCH /api/v1/accounts/:account_id/conversations/:id/priority
func (h *ConversationHandler) UpdatePriority(c *gin.Context) {
	accountID, err := parseUintParam(c, "account_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account_id")
		return
	}
	conversationID, err := parseUintParam(c, "conversation_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid conversation id")
		return
	}

	var req struct {
		Priority string `json:"priority" binding:"required,oneof=urgent high medium low none"`
	}
	if err := c.ShouldBindJSON(&req); err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrValidation, err.Error())
		return
	}

	conversation, ok := h.resolveConversationRoute(c, accountID, conversationID)
	if !ok {
		return
	}
	conversation, svcErr := h.conversationSvc.UpdatePriority(c.Request.Context(), accountID, conversation.ID, req.Priority)
	if svcErr != nil {
		handleServiceError(c, svcErr)
		return
	}
	c.JSON(http.StatusOK, serializeConversation(c.Request.Context(), h.conversationSvc.DB(), conversation))
}

// TogglePriority updates a conversation priority using Chatwoot's member action path.
// POST /api/v1/accounts/:account_id/conversations/:conversation_id/toggle_priority
// Reference: Chatwoot conversations#toggle_priority returns head :ok.
func (h *ConversationHandler) TogglePriority(c *gin.Context) {
	accountID, err := parseUintParam(c, "account_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account_id")
		return
	}
	conversationID, err := parseUintParam(c, "conversation_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid conversation id")
		return
	}

	var req struct {
		Priority *string `json:"priority"`
	}
	if err := c.ShouldBindJSON(&req); err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrValidation, err.Error())
		return
	}
	priority := ""
	if req.Priority != nil {
		priority = *req.Priority
	}

	conversation, ok := h.resolveConversationRoute(c, accountID, conversationID)
	if !ok {
		return
	}
	if _, svcErr := h.conversationSvc.UpdatePriority(c.Request.Context(), accountID, conversation.ID, priority); svcErr != nil {
		handleServiceError(c, svcErr)
		return
	}
	c.Status(http.StatusOK)
}

// ListMessages lists messages in a conversation.
// GET /api/v1/accounts/:account_id/conversations/:conversation_id/messages
func (h *ConversationHandler) ListMessages(c *gin.Context) {
	accountID, err := parseUintParam(c, "account_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account_id")
		return
	}
	conversationID, err := parseUintParam(c, "conversation_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid conversation_id")
		return
	}
	conversation, ok := h.resolveConversationRoute(c, accountID, conversationID)
	if !ok {
		return
	}

	after, _ := strconv.ParseUint(c.Query("after"), 10, 64)
	before, _ := strconv.ParseUint(c.Query("before"), 10, 64)
	filterInternal := c.Query("filter_internal_messages") != ""
	messages, _, svcErr := h.messageSvc.ListByConversationFinder(c.Request.Context(), conversation.ID, uint(after), uint(before), filterInternal)
	if svcErr != nil {
		handleServiceError(c, svcErr)
		return
	}

	c.JSON(http.StatusOK, serializeMessageIndex(c.Request.Context(), h.conversationSvc.DB(), conversation, messages))
}

// Meta retrieves aggregated conversation metadata (status counts, label counts) for an account.
// GET /api/v1/accounts/:account_id/conversations/meta
// Reference: Chatwoot conversations_controller#meta
func (h *ConversationHandler) Meta(c *gin.Context) {
	accountID, err := parseUintParam(c, "account_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account_id")
		return
	}

	meta, svcErr := h.conversationSvc.GetMeta(c.Request.Context(), accountID)
	if svcErr != nil {
		handleServiceError(c, svcErr)
		return
	}

	response.OK(c, meta)
}

// Unread marks a conversation as unread by resetting agent_last_seen_at.
// POST /api/v1/accounts/:account_id/conversations/:id/unread
// Reference: Chatwoot conversations_controller#unread
func (h *ConversationHandler) Unread(c *gin.Context) {
	accountID, err := parseUintParam(c, "account_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account_id")
		return
	}

	conversationID, err := parseUintParam(c, "conversation_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid id")
		return
	}

	conversation, ok := h.resolveConversationRoute(c, accountID, conversationID)
	if !ok {
		return
	}
	conversation, svcErr := h.conversationSvc.MarkUnread(c.Request.Context(), accountID, conversation.ID)
	if svcErr != nil {
		handleServiceError(c, svcErr)
		return
	}

	c.JSON(http.StatusOK, serializeConversation(c.Request.Context(), h.conversationSvc.DB(), conversation))
}

// Transcript sends a conversation transcript via email.
// POST /api/v1/accounts/:account_id/conversations/:id/transcript
// Reference: Chatwoot conversations_controller#transcript
func (h *ConversationHandler) Transcript(c *gin.Context) {
	accountID, err := parseUintParam(c, "account_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account_id")
		return
	}

	conversationID, err := parseUintParam(c, "conversation_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid id")
		return
	}

	var req struct {
		Email string `json:"email"`
	}
	if err := c.ShouldBindJSON(&req); err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrValidation, err.Error())
		return
	}
	if strings.TrimSpace(req.Email) == "" {
		c.JSON(http.StatusUnprocessableEntity, gin.H{"error": "email param missing"})
		return
	}

	conversation, ok := h.resolveConversationRoute(c, accountID, conversationID)
	if !ok {
		return
	}
	if svcErr := h.conversationSvc.SendTranscript(c.Request.Context(), accountID, conversation.ID, req.Email); svcErr != nil {
		handleServiceError(c, svcErr)
		return
	}

	c.Status(http.StatusOK)
}

// UpdateCustomAttributes updates the custom attributes of a conversation.
// PATCH /api/v1/accounts/:account_id/conversations/:id/custom_attributes
// Reference: Chatwoot conversations_controller#custom_attributes
func (h *ConversationHandler) UpdateCustomAttributes(c *gin.Context) {
	accountID, err := parseUintParam(c, "account_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account_id")
		return
	}

	conversationID, err := parseUintParam(c, "conversation_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid id")
		return
	}

	var req struct {
		CustomAttributes datatypes.JSON `json:"custom_attributes" binding:"required"`
	}
	if err := c.ShouldBindJSON(&req); err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrValidation, err.Error())
		return
	}

	conversation, ok := h.resolveConversationRoute(c, accountID, conversationID)
	if !ok {
		return
	}
	conversation, svcErr := h.conversationSvc.UpdateCustomAttributes(c.Request.Context(), accountID, conversation.ID, req.CustomAttributes)
	if svcErr != nil {
		handleServiceError(c, svcErr)
		return
	}

	c.JSON(http.StatusOK, gin.H{"custom_attributes": jsonObject(conversation.CustomAttributes)})
}

// ListAttachments returns paginated message attachments for a conversation.
// GET /api/v1/accounts/:account_id/conversations/:id/attachments
// Reference: Chatwoot conversations_controller#attachments (member route)
func (h *ConversationHandler) ListAttachments(c *gin.Context) {
	accountID, err := parseUintParam(c, "account_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account_id")
		return
	}

	conversationID, err := parseUintParam(c, "conversation_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid id")
		return
	}

	_, offset := fixedPageOffset(c, chatwootAttachmentResultsPerPage)
	conversation, ok := h.resolveConversationRoute(c, accountID, conversationID)
	if !ok {
		return
	}
	attachments, total, svcErr := h.messageSvc.ListAttachments(c.Request.Context(), accountID, conversation.ID, offset, chatwootAttachmentResultsPerPage)
	if svcErr != nil {
		handleServiceError(c, svcErr)
		return
	}

	payload := make([]any, 0, len(attachments))
	for i := range attachments {
		payload = append(payload, serializeAttachment(c.Request.Context(), h.conversationSvc.DB(), &attachments[i]))
	}
	c.JSON(http.StatusOK, gin.H{"meta": gin.H{"total_count": total}, "payload": payload})
}

// InboxAssistant returns the Captain assistant connected to the conversation inbox.
// GET /api/v1/accounts/:account_id/conversations/:conversation_id/inbox_assistant
// Reference: Chatwoot enterprise conversations_controller#inbox_assistant.
func (h *ConversationHandler) InboxAssistant(c *gin.Context) {
	accountID, err := parseUintParam(c, "account_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account_id")
		return
	}

	conversationID, err := parseUintParam(c, "conversation_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid conversation_id")
		return
	}

	assistant, svcErr := h.conversationSvc.GetInboxAssistant(c.Request.Context(), accountID, conversationID)
	if svcErr != nil {
		handleServiceError(c, svcErr)
		return
	}
	if assistant == nil {
		c.JSON(http.StatusOK, gin.H{"assistant": nil})
		return
	}
	c.JSON(http.StatusOK, gin.H{"assistant": gin.H{"id": assistant.ID, "name": assistant.Name}})
}

// ReportingEvents returns raw reporting events for a conversation.
// GET /api/v1/accounts/:account_id/conversations/:conversation_id/reporting_events
// Reference: Chatwoot enterprise conversations_controller#reporting_events.
func (h *ConversationHandler) ReportingEvents(c *gin.Context) {
	accountID, err := parseUintParam(c, "account_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account_id")
		return
	}

	conversationID, err := parseUintParam(c, "conversation_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid conversation_id")
		return
	}

	events, svcErr := h.conversationSvc.ListReportingEvents(c.Request.Context(), accountID, conversationID)
	if svcErr != nil {
		handleServiceError(c, svcErr)
		return
	}

	payload := make([]gin.H, 0, len(events))
	for i := range events {
		payload = append(payload, serializeReportingEvent(events[i]))
	}
	c.JSON(http.StatusOK, payload)
}

func serializeReportingEvent(event model.ReportingEvent) gin.H {
	return gin.H{
		"id":                      event.ID,
		"name":                    event.Name,
		"value":                   event.Value,
		"value_in_business_hours": event.ValueInBusinessHours,
		"event_start_time":        event.EventStartTime,
		"event_end_time":          event.EventEndTime,
		"account_id":              event.AccountID,
		"inbox_id":                event.InboxID,
		"user_id":                 event.UserID,
		"conversation_id":         event.ConversationID,
		"created_at":              event.CreatedAt,
		"updated_at":              event.UpdatedAt,
	}
}

// ToggleTyping toggles the typing status for an agent in a conversation.
// POST /api/v1/accounts/:account_id/conversations/:id/toggle_typing_status
// Reference: Chatwoot conversations_controller#toggle_typing_status (member route)
func (h *ConversationHandler) ToggleTyping(c *gin.Context) {
	accountID, err := parseUintParam(c, "account_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account_id")
		return
	}

	conversationID, err := parseUintParam(c, "conversation_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid id")
		return
	}

	var req struct {
		TypingStatus string `json:"typing_status" binding:"required"`
	}
	if err := c.ShouldBindJSON(&req); err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrValidation, err.Error())
		return
	}

	conversation, ok := h.resolveConversationRoute(c, accountID, conversationID)
	if !ok {
		return
	}
	svcErr := h.conversationSvc.ToggleTyping(c.Request.Context(), accountID, conversation.ID, req.TypingStatus)
	if svcErr != nil {
		handleServiceError(c, svcErr)
		return
	}

	c.Status(http.StatusOK)
}

// UpdateLastSeen updates the agent's last seen timestamp for a conversation.
// POST /api/v1/accounts/:account_id/conversations/:id/update_last_seen
// Reference: Chatwoot conversations_controller#update_last_seen (member route)
func (h *ConversationHandler) UpdateLastSeen(c *gin.Context) {
	accountID, err := parseUintParam(c, "account_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account_id")
		return
	}

	conversationID, err := parseUintParam(c, "conversation_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid id")
		return
	}

	conversation, ok := h.resolveConversationRoute(c, accountID, conversationID)
	if !ok {
		return
	}
	svcErr := h.conversationSvc.UpdateLastSeen(c.Request.Context(), accountID, conversation.ID)
	if svcErr != nil {
		handleServiceError(c, svcErr)
		return
	}

	c.Status(http.StatusOK)
}

// @Summary Assign a team to a conversation
// @Description Assigns a team (and optionally an agent) to a conversation
// @Tags Conversations
// @Accept json
// @Produce json
// @Param account_id path uint true "Account ID"
// @Param id path uint true "Conversation ID"
// @Param body body object true "Team assignment payload" example({"agent_id":1,"team_id":2})
// @Success 200 {object} model.Conversation
// @Failure 400 {object} model.ErrorResponse
// @Failure 401 {object} model.ErrorResponse
// @Failure 404 {object} model.ErrorResponse
// @Failure 500 {object} model.ErrorResponse
// @Security ApiKeyAuth
// @Router /api/v1/accounts/{account_id}/conversations/{id}/assignments [post]
// AssignTeam assigns a team to a conversation (supports both agent_id and team_id).
// POST /api/v1/accounts/:account_id/conversations/:id/assignments
// Reference: Chatwoot app/controllers/api/v1/accounts/conversations/assignments_controller.rb
func (h *ConversationHandler) AssignTeam(c *gin.Context) {
	accountID, err := parseUintParam(c, "account_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account_id")
		return
	}

	conversationID, err := parseUintParam(c, "conversation_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid id")
		return
	}

	var req struct {
		AgentID *uint `json:"agent_id"`
		TeamID  *uint `json:"team_id"`
	}
	if err := c.ShouldBindJSON(&req); err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrValidation, err.Error())
		return
	}

	conversation, ok := h.resolveConversationRoute(c, accountID, conversationID)
	if !ok {
		return
	}
	conversation, svcErr := h.conversationSvc.AssignTeam(c.Request.Context(), accountID, conversation.ID, req.AgentID, req.TeamID)
	if svcErr != nil {
		handleServiceError(c, svcErr)
		return
	}

	if req.AgentID != nil {
		c.JSON(http.StatusOK, serializeUserFromDB(c.Request.Context(), h.conversationSvc.DB(), *req.AgentID, accountID))
		return
	}
	if req.TeamID != nil {
		c.JSON(http.StatusOK, serializeTeamFromDB(c.Request.Context(), h.conversationSvc.DB(), *req.TeamID, accountID))
		return
	}
	c.JSON(http.StatusOK, serializeConversation(c.Request.Context(), h.conversationSvc.DB(), conversation))
}

// handleServiceError maps service-layer errors to appropriate HTTP responses.
// GORM record-not-found → 404, validation/invalid/required → 400, other → 500.
func handleServiceError(c *gin.Context, err error) {
	if err == nil {
		return
	}
	errMsg := err.Error()
	lower := strings.ToLower(errMsg)
	if strings.Contains(lower, "not found") || strings.Contains(lower, "record not found") {
		response.AbortWithStatusError(c, http.StatusNotFound, response.ErrNotFound, errMsg)
		return
	}
	if strings.Contains(lower, "invalid") || strings.Contains(lower, "validation") || strings.Contains(lower, "required") {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrValidation, errMsg)
		return
	}
	if strings.Contains(lower, "only allowed") || strings.Contains(lower, "forbidden") {
		response.AbortWithStatusError(c, http.StatusForbidden, response.ErrForbidden, errMsg)
		return
	}
	response.AbortWithStatusError(c, http.StatusInternalServerError, response.ErrInternal, errMsg)
}

// toInterfaceSlice converts a typed slice to []interface{} for JSON serialization.
func toInterfaceSlice[T any](slice []T) []interface{} {
	result := make([]interface{}, len(slice))
	for i, v := range slice {
		result[i] = v
	}
	return result
}

func (h *ConversationHandler) resolveConversationRoute(c *gin.Context, accountID, routeID uint) (*model.Conversation, bool) {
	conversation, svcErr := h.conversationSvc.GetByAccountAndDisplayIDOrID(c.Request.Context(), accountID, routeID)
	if svcErr != nil {
		handleServiceError(c, svcErr)
		return nil, false
	}
	return conversation, true
}

// UnreadCounts returns unread conversation counts grouped by inbox, label, and team.
// GET /api/v1/accounts/:account_id/conversations/unread_counts
// Reference: Chatwoot app/controllers/api/v1/accounts/conversations/unread_counts_controller.rb
func (h *ConversationHandler) UnreadCounts(c *gin.Context) {
	accountID, err := parseUintParam(c, "account_id")
	if err != nil {
		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid account_id")
		return
	}

	payload, svcErr := h.conversationSvc.GetUnreadCounts(c.Request.Context(), accountID)
	if svcErr != nil {
		handleServiceError(c, svcErr)
		return
	}

	response.OK(c, payload)
}