package v1

import (
	"encoding/json"
	"errors"
	"io"
	"net/http"
	"strconv"
	"strings"

	"github.com/gin-gonic/gin"
	"github.com/gochat/gochat/internal/model"
	"github.com/gochat/gochat/internal/repository"
	"github.com/gochat/gochat/internal/service"
	"github.com/gochat/gochat/pkg/response"
)

// InboxHandler handles inbox-related API endpoints.
// Reference: Chatwoot app/controllers/api/v1/inboxes_controller.rb
type InboxHandler struct {
	svc      *service.InboxService
	auditSvc *service.AuditService
}

// NewInboxHandler creates a new InboxHandler.
func NewInboxHandler(svc *service.InboxService) *InboxHandler {
	return &InboxHandler{svc: svc}
}

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

// @Summary List inboxes for an account
// @Description Retrieves all inboxes for an account with pagination
// @Tags Inboxes
// @Accept json
// @Produce json
// @Param id path uint true "Account ID"
// @Param page query int false "Page number" default(1)
// @Param page_size query int false "Items per page" default(25)
// @Success 200 {object} []model.Inbox
// @Failure 400 {object} model.ErrorResponse
// @Failure 401 {object} model.ErrorResponse
// @Failure 500 {object} model.ErrorResponse
// @Security ApiKeyAuth
// @Router /api/v1/accounts/{id}/inboxes [get]
// List retrieves all inboxes for an account.
// GET /api/v1/accounts/:id/inboxes
func (h *InboxHandler) List(c *gin.Context) {
	accountID, err := parseUintParam(c, "id")
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid account id"})
		return
	}

	page := getPage(c)
	perPage := getPageSize(c)
	offset := (page - 1) * perPage

	inboxes, _, svcErr := h.svc.ListByAccount(c.Request.Context(), accountID, offset, perPage)
	if svcErr != nil {
		c.JSON(http.StatusUnprocessableEntity, gin.H{"error": "failed to list inboxes"})
		return
	}

	c.JSON(http.StatusOK, inboxListResponse(inboxes))
}

// @Summary Get a single inbox
// @Description Retrieves detailed information about a specific inbox within an account
// @Tags Inboxes
// @Accept json
// @Produce json
// @Param id path uint true "Account ID"
// @Param inbox_id path uint true "Inbox ID"
// @Success 200 {object} model.Inbox
// @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/{id}/inboxes/{inbox_id} [get]
// Get retrieves a single inbox.
// GET /api/v1/accounts/:id/inboxes/:inbox_id
func (h *InboxHandler) Get(c *gin.Context) {
	accountID, err := parseUintParam(c, "id")
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid account id"})
		return
	}

	inboxID, err := parseUintParam(c, "inbox_id")
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid inbox id"})
		return
	}

	inbox, svcErr := h.svc.GetByAccountAndID(c.Request.Context(), accountID, inboxID)
	if svcErr != nil {
		c.JSON(http.StatusNotFound, gin.H{"error": "inbox not found"})
		return
	}

	c.JSON(http.StatusOK, serializeInbox(inbox))
}

// @Summary Create a new inbox
// @Description Creates a new inbox for an account
// @Tags Inboxes
// @Accept json
// @Produce json
// @Param id path uint true "Account ID"
// @Param body body service.CreateInboxRequest true "Inbox creation payload"
// @Success 201 {object} model.Inbox
// @Failure 400 {object} model.ErrorResponse
// @Failure 401 {object} model.ErrorResponse
// @Failure 500 {object} model.ErrorResponse
// @Security ApiKeyAuth
// @Router /api/v1/accounts/{id}/inboxes [post]
// Create creates a new inbox.
// POST /api/v1/accounts/:id/inboxes
func (h *InboxHandler) Create(c *gin.Context) {
	accountID, err := parseUintParam(c, "id")
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid account id"})
		return
	}

	var req service.CreateInboxRequest
	if bindErr := bindCreateInboxRequest(c, &req); bindErr != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": bindErr.Error()})
		return
	}

	inbox, svcErr := h.svc.Create(c.Request.Context(), accountID, req)
	if svcErr != nil {
		if renderInboxLimitExceeded(c, svcErr) {
			return
		}
		c.JSON(http.StatusUnprocessableEntity, gin.H{"error": "failed to create inbox"})
		return
	}
	recordAuditMutation(c, h.auditSvc, auditMutation{
		AccountID:      accountID,
		AuditableType:  "Inbox",
		AuditableID:    inbox.ID,
		Action:         "create",
		AuditedChanges: serializeInbox(inbox),
	})

	c.JSON(http.StatusOK, serializeInbox(inbox))
}

// @Summary Update an inbox
// @Description Updates an existing inbox's configuration
// @Tags Inboxes
// @Accept json
// @Produce json
// @Param id path uint true "Account ID"
// @Param inbox_id path uint true "Inbox ID"
// @Param body body service.UpdateInboxRequest true "Inbox update payload"
// @Success 200 {object} model.Inbox
// @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/{id}/inboxes/{inbox_id} [put]
// Update updates an inbox.
// PUT /api/v1/accounts/:id/inboxes/:inbox_id
// Reference: Chatwoot inboxes#update
func (h *InboxHandler) Update(c *gin.Context) {
	accountID, err := parseUintParam(c, "id")
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid account id"})
		return
	}

	inboxID, err := parseUintParam(c, "inbox_id")
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid inbox id"})
		return
	}

	var req service.UpdateInboxRequest
	if bindErr := bindUpdateInboxRequest(c, &req); bindErr != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": bindErr.Error()})
		return
	}

	inbox, svcErr := h.svc.Update(c.Request.Context(), accountID, inboxID, req)
	if svcErr != nil {
		c.JSON(http.StatusUnprocessableEntity, gin.H{"error": "failed to update inbox"})
		return
	}
	recordAuditMutation(c, h.auditSvc, auditMutation{
		AccountID:      accountID,
		AuditableType:  "Inbox",
		AuditableID:    inbox.ID,
		Action:         "update",
		AuditedChanges: serializeInbox(inbox),
	})

	c.JSON(http.StatusOK, serializeInbox(inbox))
}

// @Summary Delete an inbox
// @Description Deletes an inbox from an account
// @Tags Inboxes
// @Accept json
// @Produce json
// @Param id path uint true "Account ID"
// @Param inbox_id path uint true "Inbox ID"
// @Success 200 {object} object
// @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/{id}/inboxes/{inbox_id} [delete]
// Delete deletes an inbox.
// DELETE /api/v1/accounts/:id/inboxes/:inbox_id
// Reference: Chatwoot inboxes#destroy
func (h *InboxHandler) Delete(c *gin.Context) {
	accountID, err := parseUintParam(c, "id")
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid account id"})
		return
	}

	inboxID, err := parseUintParam(c, "inbox_id")
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid inbox id"})
		return
	}

	if svcErr := h.svc.DeleteByAccount(c.Request.Context(), accountID, inboxID); svcErr != nil {
		c.JSON(http.StatusUnprocessableEntity, gin.H{"error": "failed to delete inbox"})
		return
	}

	c.JSON(http.StatusOK, gin.H{"message": "Your inbox deletion request will be processed in some time."})
}

func renderInboxLimitExceeded(c *gin.Context, err error) bool {
	if !service.IsInboxLimitExceeded(err) {
		return false
	}
	c.JSON(http.StatusPaymentRequired, gin.H{"error": service.InboxLimitExceededMessage})
	return true
}

func bindCreateInboxRequest(c *gin.Context, req *service.CreateInboxRequest) error {
	if strings.Contains(c.ContentType(), "json") {
		return bindCreateInboxJSON(c, req)
	}
	values, err := inboxFormValues(c)
	if err != nil {
		return err
	}
	applyCreateInboxForm(req, values)
	return nil
}

func bindUpdateInboxRequest(c *gin.Context, req *service.UpdateInboxRequest) error {
	if strings.Contains(c.ContentType(), "json") {
		return bindUpdateInboxJSON(c, req)
	}
	values, err := inboxFormValues(c)
	if err != nil {
		return err
	}
	applyUpdateInboxForm(req, values)
	return nil
}

func inboxFormValues(c *gin.Context) (map[string][]string, error) {
	values := map[string][]string{}
	if strings.Contains(c.ContentType(), "multipart/form-data") {
		if err := c.Request.ParseMultipartForm(32 << 20); err != nil {
			return nil, err
		}
		if c.Request.MultipartForm != nil {
			for key, list := range c.Request.MultipartForm.Value {
				values[key] = append(values[key], list...)
			}
		}
		return values, nil
	} else if err := c.Request.ParseForm(); err != nil {
		return nil, err
	}
	for key, list := range c.Request.PostForm {
		values[key] = append(values[key], list...)
	}
	for key, list := range c.Request.Form {
		if _, ok := values[key]; !ok {
			values[key] = append(values[key], list...)
		}
	}
	return values, nil
}

func bindCreateInboxJSON(c *gin.Context, req *service.CreateInboxRequest) error {
	body, err := io.ReadAll(c.Request.Body)
	if err != nil {
		return err
	}
	if err := json.Unmarshal(body, req); err != nil {
		return err
	}
	var raw map[string]any
	if err := json.Unmarshal(body, &raw); err != nil {
		return err
	}
	hoistInboxChannelJSONFields(&req.Channel, raw)
	return nil
}

func bindUpdateInboxJSON(c *gin.Context, req *service.UpdateInboxRequest) error {
	body, err := io.ReadAll(c.Request.Body)
	if err != nil {
		return err
	}
	if err := json.Unmarshal(body, req); err != nil {
		return err
	}
	var raw map[string]any
	if err := json.Unmarshal(body, &raw); err != nil {
		return err
	}
	hoistInboxChannelJSONFields(&req.Channel, raw)
	return nil
}

func hoistInboxChannelJSONFields(channel *map[string]any, raw map[string]any) {
	for key, value := range raw {
		if !isInboxChannelConfigKey(key) || value == nil {
			continue
		}
		if *channel == nil {
			*channel = map[string]any{}
		}
		if _, exists := (*channel)[key]; !exists {
			(*channel)[key] = value
		}
	}
}

func isInboxChannelConfigKey(key string) bool {
	switch key {
	case "website_url", "widget_color", "welcome_title", "welcome_tagline", "reply_time",
		"pre_chat_form_enabled", "pre_chat_form_options", "continuity_via_email", "hmac_mandatory",
		"allowed_domains", "selected_feature_flags", "webhook_url", "additional_attributes",
		"email", "forward_to_email", "imap_login", "imap_password", "imap_address", "imap_port",
		"imap_enabled", "imap_enable_ssl", "imap_authentication", "smtp_login", "smtp_password",
		"smtp_address", "smtp_port", "smtp_enabled", "smtp_domain", "smtp_enable_ssl_tls",
		"smtp_enable_starttls_auto", "smtp_openssl_verify_mode", "smtp_authentication", "provider",
		"provider_config", "phone_number", "message_templates", "account_sid", "auth_token", "api_key_sid",
		"api_key_secret", "messaging_service_sid", "medium", "content_templates", "twiml_app_sid",
		"voice_enabled", "line_channel_id", "line_channel_secret", "line_channel_token", "bot_token":
		return true
	default:
		return false
	}
}

func applyCreateInboxForm(req *service.CreateInboxRequest, values map[string][]string) {
	req.Channel = map[string]any{}
	for key, list := range values {
		value := inboxFormValue(list)
		if strings.HasPrefix(key, "channel[") {
			applyInboxNestedValue(req.Channel, key, list)
			continue
		}
		if strings.HasPrefix(key, "csat_config[") {
			if req.CsatConfig == nil {
				req.CsatConfig = map[string]any{}
			}
			applyInboxNestedValue(req.CsatConfig, key, list)
			continue
		}
		switch key {
		case "name":
			req.Name = value
		case "channel_type":
			req.ChannelType = value
		case "enabled":
			req.Enabled = inboxBool(value)
		case "enable_auto_assignment":
			req.EnableAutoAssignment = inboxBool(value)
		case "greeting_enabled":
			req.GreetingEnabled = inboxBoolPtr(value)
		case "greeting_message":
			req.GreetingMessage = inboxStringPtr(value)
		case "enable_email_collect":
			req.EnableEmailCollect = inboxBoolPtr(value)
		case "csat_survey_enabled":
			req.CsatSurveyEnabled = inboxBoolPtr(value)
		case "working_hours_enabled":
			req.WorkingHoursEnabled = inboxBoolPtr(value)
		case "out_of_office_message":
			req.OutOfOfficeMessage = inboxStringPtr(value)
		case "timezone":
			req.Timezone = inboxStringPtr(value)
		case "allow_messages_after_resolved":
			req.AllowMessagesAfterResolved = inboxBoolPtr(value)
		case "lock_to_single_conversation":
			req.LockToSingleConversation = inboxBoolPtr(value)
		case "portal_id":
			req.PortalID = inboxUintPtr(value)
		case "sender_name_type":
			req.SenderNameType = inboxStringPtr(value)
		case "business_name":
			req.BusinessName = inboxStringPtr(value)
		case "csat_config":
			req.CsatConfig = inboxJSONObject(value)
		case "working_hours":
			req.WorkingHours = inboxWorkingHours(value)
		}
	}
}

func applyUpdateInboxForm(req *service.UpdateInboxRequest, values map[string][]string) {
	req.Channel = map[string]any{}
	for key, list := range values {
		value := inboxFormValue(list)
		if strings.HasPrefix(key, "channel[") {
			applyInboxNestedValue(req.Channel, key, list)
			continue
		}
		if strings.HasPrefix(key, "csat_config[") {
			if req.CsatConfig == nil {
				req.CsatConfig = map[string]any{}
			}
			applyInboxNestedValue(req.CsatConfig, key, list)
			continue
		}
		switch key {
		case "name":
			req.Name = value
		case "enabled":
			req.Enabled = inboxBoolPtr(value)
		case "enable_auto_assignment":
			req.EnableAutoAssignment = inboxBoolPtr(value)
		case "greeting_enabled":
			req.GreetingEnabled = inboxBoolPtr(value)
		case "greeting_message":
			req.GreetingMessage = inboxStringPtr(value)
		case "enable_email_collect":
			req.EnableEmailCollect = inboxBoolPtr(value)
		case "csat_survey_enabled":
			req.CsatSurveyEnabled = inboxBoolPtr(value)
		case "working_hours_enabled":
			req.WorkingHoursEnabled = inboxBoolPtr(value)
		case "out_of_office_message":
			req.OutOfOfficeMessage = inboxStringPtr(value)
		case "timezone":
			req.Timezone = inboxStringPtr(value)
		case "allow_messages_after_resolved":
			req.AllowMessagesAfterResolved = inboxBoolPtr(value)
		case "lock_to_single_conversation":
			req.LockToSingleConversation = inboxBoolPtr(value)
		case "portal_id":
			req.PortalID = inboxUintPtr(value)
		case "sender_name_type":
			req.SenderNameType = inboxStringPtr(value)
		case "business_name":
			req.BusinessName = inboxStringPtr(value)
		case "csat_config":
			req.CsatConfig = inboxJSONObject(value)
		case "working_hours":
			req.WorkingHours = inboxWorkingHours(value)
		}
	}
}

func applyInboxNestedValue(target map[string]any, key string, values []string) {
	inner := strings.TrimSuffix(strings.TrimPrefix(key[strings.Index(key, "[")+1:], ""), "]")
	parts := strings.Split(inner, "][")
	if len(parts) == 0 || parts[0] == "" {
		return
	}
	if len(parts) == 1 || (len(parts) == 2 && parts[1] == "") {
		if len(parts) == 2 && parts[1] == "" {
			target[parts[0]] = append([]string(nil), values...)
			return
		}
		target[parts[0]] = inboxFormValue(values)
		return
	}
	nested, _ := target[parts[0]].(map[string]any)
	if nested == nil {
		nested = map[string]any{}
		target[parts[0]] = nested
	}
	if len(parts) == 3 && parts[2] == "" {
		nested[parts[1]] = append([]string(nil), values...)
		return
	}
	nested[parts[1]] = inboxFormValue(values)
}

func inboxFormValue(values []string) string {
	if len(values) == 0 || values[0] == "null" {
		return ""
	}
	return values[0]
}

func inboxBool(value string) bool {
	parsed, _ := strconv.ParseBool(value)
	return parsed
}

func inboxBoolPtr(value string) *bool {
	parsed := inboxBool(value)
	return &parsed
}

func inboxStringPtr(value string) *string {
	return &value
}

func inboxUintPtr(value string) *uint {
	if value == "" {
		return nil
	}
	parsed, err := strconv.ParseUint(value, 10, 64)
	if err != nil {
		return nil
	}
	uintValue := uint(parsed)
	return &uintValue
}

func inboxJSONObject(value string) map[string]any {
	if value == "" {
		return nil
	}
	var data map[string]any
	if err := json.Unmarshal([]byte(value), &data); err != nil {
		return nil
	}
	return data
}

func inboxWorkingHours(value string) []repository.WorkingHourUpdateParam {
	if value == "" {
		return nil
	}
	var data []repository.WorkingHourUpdateParam
	if err := json.Unmarshal([]byte(value), &data); err != nil {
		return nil
	}
	return data
}

// ========================================
// Member-action handlers (Chatwoot InboxesController member routes)
// ========================================

// SetAgentBot sets or removes an agent bot from an inbox.
// POST /api/v1/accounts/:id/inboxes/:inbox_id/set_agent_bot
// Reference: Chatwoot InboxesController#set_agent_bot
func (h *InboxHandler) SetAgentBot(c *gin.Context) {
	accountID := parseAccountIDParam(c)
	if accountID == 0 {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid account id"})
		return
	}

	inboxID, err := parseUintParam(c, "inbox_id")
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid inbox id"})
		return
	}

	req := service.SetAgentBotRequest{}
	if c.Request.Body != nil && c.Request.ContentLength != 0 {
		if err := c.ShouldBindJSON(&req); err != nil {
			if c.Request.ContentLength < 0 && errors.Is(err, io.EOF) {
				// Chunked empty body behaves like omitted params in Chatwoot and disconnects the bot.
			} else {
				c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request body: " + err.Error()})
				return
			}
		}
	}
	if !h.svc.Ready() {
		response.AbortWithStatusError(c, http.StatusUnprocessableEntity, response.ErrInternal, "failed to set agent bot")
		return
	}

	_, svcErr := h.svc.SetAgentBot(c.Request.Context(), accountID, inboxID, req)
	if svcErr != nil {
		handleServiceError(c, svcErr)
		return
	}

	c.Status(http.StatusOK)
}

// Health checks the health status of an inbox's channel connection.
// GET /api/v1/accounts/:id/inboxes/:inbox_id/health
// Reference: Chatwoot InboxesController#health
func (h *InboxHandler) Health(c *gin.Context) {
	accountID := parseAccountIDParam(c)
	if accountID == 0 {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid account id"})
		return
	}

	inboxID, err := parseUintParam(c, "inbox_id")
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid inbox id"})
		return
	}

	if !h.svc.Ready() {
		response.AbortWithStatusError(c, http.StatusUnprocessableEntity, response.ErrInternal, "failed to check inbox health")
		return
	}

	result, svcErr := h.svc.Health(c.Request.Context(), accountID, inboxID)
	if svcErr != nil {
		if errors.Is(svcErr, service.ErrInboxHealthWhatsAppCloudOnly) {
			c.JSON(http.StatusBadRequest, gin.H{"error": service.InboxHealthWhatsAppCloudOnlyMessage})
			return
		}
		handleServiceError(c, svcErr)
		return
	}

	c.JSON(http.StatusOK, result)
}

// SyncTemplates syncs message templates for an inbox's channel (WhatsApp only).
// POST /api/v1/accounts/:id/inboxes/:inbox_id/sync_templates
// Reference: Chatwoot InboxesController#sync_templates
func (h *InboxHandler) SyncTemplates(c *gin.Context) {
	accountID := parseAccountIDParam(c)
	if accountID == 0 {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid account id"})
		return
	}

	inboxID, err := parseUintParam(c, "inbox_id")
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid inbox id"})
		return
	}

	if !h.svc.Ready() {
		response.AbortWithStatusError(c, http.StatusUnprocessableEntity, response.ErrInternal, "failed to sync templates")
		return
	}

	svcErr := h.svc.SyncTemplates(c.Request.Context(), accountID, inboxID)
	if svcErr != nil {
		if errors.Is(svcErr, service.ErrInboxTemplateSyncWhatsAppOnly) {
			c.JSON(http.StatusUnprocessableEntity, gin.H{"error": service.InboxTemplateSyncWhatsAppOnlyMessage})
			return
		}
		handleServiceError(c, svcErr)
		return
	}

	c.JSON(http.StatusOK, gin.H{"message": service.InboxTemplateSyncInitiatedMessage})
}

// RegisterWebhook registers a webhook URL with the channel provider for an inbox.
// POST /api/v1/accounts/:id/inboxes/:inbox_id/register_webhook
// Reference: Chatwoot InboxesController#register_webhook
func (h *InboxHandler) RegisterWebhook(c *gin.Context) {
	accountID := parseAccountIDParam(c)
	if accountID == 0 {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid account id"})
		return
	}

	inboxID, err := parseUintParam(c, "inbox_id")
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid inbox id"})
		return
	}

	var req service.RegisterWebhookRequest
	if c.Request.Body != nil && c.Request.ContentLength != 0 {
		if err := c.ShouldBindJSON(&req); err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request body: " + err.Error()})
			return
		}
	}
	if !h.svc.Ready() {
		response.AbortWithStatusError(c, http.StatusUnprocessableEntity, response.ErrInternal, "failed to register webhook")
		return
	}

	svcErr := h.svc.RegisterWebhook(c.Request.Context(), accountID, inboxID, req)
	if svcErr != nil {
		if errors.Is(svcErr, service.ErrInboxHealthWhatsAppCloudOnly) {
			c.JSON(http.StatusBadRequest, gin.H{"error": service.InboxHealthWhatsAppCloudOnlyMessage})
			return
		}
		handleServiceError(c, svcErr)
		return
	}

	c.JSON(http.StatusOK, gin.H{"message": "Webhook registered successfully"})
}

// GetAgentBot retrieves the currently active agent bot for an inbox.
// GET /api/v1/accounts/:id/inboxes/:inbox_id/agent_bot
// Reference: Chatwoot InboxesController#agent_bot
func (h *InboxHandler) GetAgentBot(c *gin.Context) {
	accountID := parseAccountIDParam(c)
	if accountID == 0 {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid account id"})
		return
	}

	inboxID, err := parseUintParam(c, "inbox_id")
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid inbox id"})
		return
	}

	if !h.svc.Ready() {
		response.AbortWithStatusError(c, http.StatusUnprocessableEntity, response.ErrInternal, "failed to get agent bot")
		return
	}

	agentBot, svcErr := h.svc.GetAgentBot(c.Request.Context(), accountID, inboxID)
	if svcErr != nil {
		handleServiceError(c, svcErr)
		return
	}

	if agentBot == nil {
		c.JSON(http.StatusOK, gin.H{"agent_bot": gin.H{}})
		return
	}

	c.JSON(http.StatusOK, gin.H{"agent_bot": serializeAgentBot(agentBot)})
}

func serializeAgentBot(bot *model.AgentBot) gin.H {
	if bot == nil {
		return gin.H{}
	}
	return gin.H{
		"id":           bot.ID,
		"name":         bot.Name,
		"description":  bot.Description,
		"thumbnail":    bot.AvatarURL,
		"outgoing_url": bot.OutgoingURL,
		"bot_type":     bot.BotType,
		"bot_config":   bot.Config,
		"account_id":   bot.AccountID,
		"access_token": bot.AccessToken,
	}
}

// DeleteAvatar removes the avatar URL from an inbox.
// DELETE /api/v1/accounts/:id/inboxes/:inbox_id/avatar
// Reference: Chatwoot InboxesController#destroy_avatar
func (h *InboxHandler) DeleteAvatar(c *gin.Context) {
	accountID := parseAccountIDParam(c)
	if accountID == 0 {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid account id"})
		return
	}

	inboxID, err := parseUintParam(c, "inbox_id")
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid inbox id"})
		return
	}

	if !h.svc.Ready() {
		response.AbortWithStatusError(c, http.StatusUnprocessableEntity, response.ErrInternal, "failed to delete inbox avatar")
		return
	}

	_, svcErr := h.svc.DeleteAvatar(c.Request.Context(), accountID, inboxID)
	if svcErr != nil {
		handleServiceError(c, svcErr)
		return
	}

	c.Status(http.StatusOK)
}

// ListCampaigns retrieves all campaigns for a specific inbox.
// GET /api/v1/accounts/:id/inboxes/:inbox_id/campaigns
// Reference: Chatwoot InboxesController#campaigns
func (h *InboxHandler) ListCampaigns(c *gin.Context) {
	accountID := parseAccountIDParam(c)
	if accountID == 0 {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid account id"})
		return
	}

	inboxID, err := parseUintParam(c, "inbox_id")
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid inbox id"})
		return
	}

	if !h.svc.Ready() {
		response.AbortWithStatusError(c, http.StatusUnprocessableEntity, response.ErrInternal, "failed to list campaigns")
		return
	}

	campaigns, svcErr := h.svc.ListCampaigns(c.Request.Context(), accountID, inboxID)
	if svcErr != nil {
		handleServiceError(c, svcErr)
		return
	}

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

// ResetSecret regenerates the HMAC token for an API-type inbox.
// POST /api/v1/accounts/:id/inboxes/:inbox_id/reset_secret
// Reference: Chatwoot inboxes_controller#reset_secret — only works for API inboxes
func (h *InboxHandler) ResetSecret(c *gin.Context) {
	accountID, err := parseUintParam(c, "id")
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid account id"})
		return
	}

	inboxID, err := parseUintParam(c, "inbox_id")
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid inbox id"})
		return
	}

	inbox, svcErr := h.svc.ResetSecret(c.Request.Context(), accountID, inboxID)
	if svcErr != nil {
		handleServiceError(c, svcErr)
		return
	}

	c.JSON(http.StatusOK, serializeInbox(inbox))
}