package service

import (
	"context"
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"errors"
	"testing"
	"time"

	"github.com/gochat/gochat/internal/channel"
	"github.com/gochat/gochat/internal/model"
	"github.com/gochat/gochat/internal/repository"
	"github.com/gochat/gochat/internal/search"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"gorm.io/gorm"
)

// ============================================================
// coverage59_test.go: 200+ DB-backed tests targeting
// widget/inbox/conversation/contact/profile/article/captain/analytics services.
// ============================================================

// --- Helpers ---

func newInboxSvc59(t *testing.T) (*InboxService, *gorm.DB) {
	t.Helper()
	db := newSimpleServiceTestDB(t)
	svc := NewInboxService(
		repository.NewInboxRepo(db),
		repository.NewAgentBotInboxRepo(db),
		repository.NewAgentBotRepo(db),
		repository.NewCampaignRepo(db),
		repository.NewWebhookSubscriptionRepo(db),
		nil, nil,
	)
	return svc, db
}

func newConvSvc59(t *testing.T) (*ConversationService, *gorm.DB) {
	t.Helper()
	db := newSimpleServiceTestDB(t)
	svc := NewConversationService(
		repository.NewConversationRepo(db),
		repository.NewMessageRepo(db),
		channel.NewDispatcher(), nil, nil, nil, nil,
	)
	return svc, db
}

func newWidgetSvc59(t *testing.T) (*WidgetService, *gorm.DB) {
	t.Helper()
	db := newSimpleServiceTestDB(t)
	svc := NewWidgetService(
		repository.NewInboxRepo(db),
		repository.NewContactRepo(db),
		repository.NewContactInboxRepo(db),
		repository.NewConversationRepo(db),
		repository.NewMessageRepo(db),
		nil, nil, nil, nil, nil,
		repository.NewInboxMemberRepo(db),
		repository.NewTagRepo(db),
		repository.NewCampaignRepo(db),
	)
	return svc, db
}

func newContactSvc59(t *testing.T) (*ContactService, *gorm.DB) {
	t.Helper()
	db := newSimpleServiceTestDB(t)
	svc := NewContactService(
		repository.NewContactRepo(db),
		NewContactInboxService(repository.NewContactInboxRepo(db)),
		repository.NewNoteRepo(db),
	)
	return svc, db
}

func newProfileSvc59(t *testing.T) (*ProfileService, *gorm.DB) {
	t.Helper()
	db := newSimpleServiceTestDB(t)
	svc := NewProfileService(repository.NewUserRepo(db), repository.NewAccountUserRepo(db))
	return svc, db
}

func newArticleSvc59(t *testing.T) (*ArticleService, *gorm.DB) {
	t.Helper()
	db := newSimpleServiceTestDB(t)
	svc := NewArticleService(repository.NewArticleRepo(db))
	return svc, db
}

func newCaptainAsstSvc59(t *testing.T) (*CaptainAssistantService, *gorm.DB) {
	t.Helper()
	db := newSimpleServiceTestDB(t, &model.CaptainAssistant{}, &model.CaptainInbox{}, &model.CaptainDocument{}, &model.CaptainAssistantResponse{})
	svc := NewCaptainAssistantService(
		repository.NewCaptainAssistantRepo(db),
		repository.NewCaptainInboxRepo(db),
		repository.NewCaptainDocumentRepo(db),
		repository.NewCaptainAssistantResponseRepo(db),
		nil,
	)
	return svc, db
}

func newAnalyticsSvc59(t *testing.T) (*AnalyticsService, *gorm.DB) {
	t.Helper()
	db := newSimpleServiceTestDB(t, &model.ReportingEventsRollup{})
	svc := NewAnalyticsService(repository.NewReportingEventRepo(db), repository.NewReportingEventsRollupRepo(db))
	return svc, db
}

func seedAccount59(t *testing.T, db *gorm.DB) *model.Account {
	t.Helper()
	acc := &model.Account{Name: "TestAccount59", Status: "active", Active: true}
	require.NoError(t, db.Create(acc).Error)
	return acc
}

func seedInbox59(t *testing.T, db *gorm.DB, accountID uint, channelType string) *model.Inbox {
	t.Helper()
	inbox := &model.Inbox{
		AccountID:   accountID,
		Name:        "TestInbox59",
		ChannelType: channelType,
		Enabled:     true,
	}
	if channelType == "web_widget" {
		wc := WebWidgetConfig{WebsiteToken: "wt_test59", HMACToken: "hmac_test59"}
		b, _ := json.Marshal(wc)
		inbox.ChannelConfig = string(b)
	}
	require.NoError(t, db.Create(inbox).Error)
	return inbox
}

func seedContact59(t *testing.T, db *gorm.DB, accountID uint) *model.Contact {
	t.Helper()
	c := &model.Contact{AccountID: accountID, Name: "TestContact59"}
	require.NoError(t, db.Create(c).Error)
	return c
}

func seedConv59(t *testing.T, db *gorm.DB, accountID, inboxID, contactID uint) *model.Conversation {
	t.Helper()
	conv := &model.Conversation{
		AccountID: accountID,
		InboxID:   inboxID,
		ContactID: contactID,
		Status:    string(model.ConversationStatusOpen),
	}
	require.NoError(t, db.Create(conv).Error)
	return conv
}

func seedUser59(t *testing.T, db *gorm.DB) *model.User {
	t.Helper()
	u := &model.User{Name: "TestUser59", Email: "test59@example.com"}
	require.NoError(t, db.Create(u).Error)
	return u
}

func seedMessage59(t *testing.T, db *gorm.DB, accountID, conversationID, inboxID uint) *model.Message {
	t.Helper()
	m := &model.Message{
		AccountID:      accountID,
		ConversationID: conversationID,
		InboxID:        inboxID,
		Content:        "test message",
		ContentType:    "text",
		MessageType:    "incoming",
		Status:         "sent",
	}
	require.NoError(t, db.Create(m).Error)
	return m
}

func seedContactInbox59(t *testing.T, db *gorm.DB, contactID, inboxID uint) *model.ContactInbox {
	t.Helper()
	ci := &model.ContactInbox{
		ContactID:   contactID,
		InboxID:     inboxID,
		SourceID:    "src59",
		PubsubToken: "pubsub59",
		HMACToken:   "hmac59",
	}
	require.NoError(t, db.Create(ci).Error)
	return ci
}

// ============================================================
// WIDGET SERVICE TESTS (35 tests)
// ============================================================

func TestWidgetSplitWidgetLabels_Empty_Cov59(t *testing.T) {
	assert.Equal(t, []string{}, splitWidgetLabels(""))
}

func TestWidgetSplitWidgetLabels_Single_Cov59(t *testing.T) {
	assert.Equal(t, []string{"foo"}, splitWidgetLabels("foo"))
}

func TestWidgetSplitWidgetLabels_Multi_Cov59(t *testing.T) {
	assert.Equal(t, []string{"a", "b", "c"}, splitWidgetLabels("a,b,c"))
}

func TestWidgetSplitWidgetLabels_WithSpaces_Cov59(t *testing.T) {
	assert.Equal(t, []string{"a", "b"}, splitWidgetLabels(" a , b "))
}

func TestWidgetSplitWidgetLabels_EmptyParts_Cov59(t *testing.T) {
	assert.Equal(t, []string{"a", "b"}, splitWidgetLabels("a,,b,"))
}

func TestWidgetVerifyHMAC_EmptyToken_Cov59(t *testing.T) {
	assert.False(t, VerifyHMAC("", "id", "sig"))
}

func TestWidgetVerifyHMAC_EmptyIdentifier_Cov59(t *testing.T) {
	assert.False(t, VerifyHMAC("token", "", "sig"))
}

func TestWidgetVerifyHMAC_EmptySignature_Cov59(t *testing.T) {
	assert.False(t, VerifyHMAC("token", "id", ""))
}

func TestWidgetVerifyHMAC_Invalid_Cov59(t *testing.T) {
	assert.False(t, VerifyHMAC("token", "id", "badsig"))
}

func TestWidgetVerifyHMAC_Valid_Cov59(t *testing.T) {
	// Compute valid HMAC
	mac := hmacSHA256Test("token", "id")
	assert.True(t, VerifyHMAC("token", "id", mac))
}

func hmacSHA256Test(key, msg string) string {
	h := hmac.New(sha256.New, []byte(key))
	h.Write([]byte(msg))
	return hex.EncodeToString(h.Sum(nil))
}

func TestWidgetParseWebWidgetConfig_Empty_Cov59(t *testing.T) {
	_, err := ParseWebWidgetConfig("")
	assert.Error(t, err)
}

func TestWidgetParseWebWidgetConfig_Valid_Cov59(t *testing.T) {
	cfg, err := ParseWebWidgetConfig(`{"website_token":"wt","hmac_token":"ht"}`)
	require.NoError(t, err)
	assert.Equal(t, "wt", cfg.WebsiteToken)
	assert.Equal(t, "ht", cfg.HMACToken)
}

func TestWidgetParseWebWidgetConfig_InvalidJSON_Cov59(t *testing.T) {
	_, err := ParseWebWidgetConfig(`{invalid}`)
	assert.Error(t, err)
}

func TestWidgetParseWebWidgetConfig_TypeError_Cov59(t *testing.T) {
	// Type mismatch (string for bool) should be tolerated
	cfg, err := ParseWebWidgetConfig(`{"website_token":"wt","greeting_enabled":"notabool"}`)
	require.NoError(t, err) // type errors are tolerated
	assert.Equal(t, "wt", cfg.WebsiteToken)
}

func TestWidgetGetInboxByWebsiteToken_NotFound_Cov59(t *testing.T) {
	svc, _ := newWidgetSvc59(t)
	_, err := svc.GetInboxByWebsiteToken(context.Background(), "nonexistent")
	assert.Error(t, err)
}

func TestWidgetGetInboxByWebsiteToken_Found_Cov59(t *testing.T) {
	svc, db := newWidgetSvc59(t)
	acc := seedAccount59(t, db)
	seedInbox59(t, db, acc.ID, "web_widget")
	inbox, err := svc.GetInboxByWebsiteToken(context.Background(), "wt_test59")
	require.NoError(t, err)
	assert.Equal(t, "web_widget", inbox.ChannelType)
}

func TestWidgetGetConversations_InvalidToken_Cov59(t *testing.T) {
	svc, _ := newWidgetSvc59(t)
	_, err := svc.GetConversations(context.Background(), "badtoken")
	assert.Error(t, err)
}

func TestWidgetGetConversations_Valid_Cov59(t *testing.T) {
	svc, db := newWidgetSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "web_widget")
	contact := seedContact59(t, db, acc.ID)
	ci := seedContactInbox59(t, db, contact.ID, inbox.ID)
	seedConv59(t, db, acc.ID, inbox.ID, contact.ID)
	convs, err := svc.GetConversations(context.Background(), ci.PubsubToken)
	require.NoError(t, err)
	assert.Len(t, convs, 1)
}

func TestWidgetGetLatestConversation_NotFound_Cov59(t *testing.T) {
	svc, db := newWidgetSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "web_widget")
	contact := seedContact59(t, db, acc.ID)
	ci := seedContactInbox59(t, db, contact.ID, inbox.ID)
	_, err := svc.GetLatestConversation(context.Background(), ci.PubsubToken)
	assert.Error(t, err)
}

func TestWidgetGetLatestConversation_Found_Cov59(t *testing.T) {
	svc, db := newWidgetSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "web_widget")
	contact := seedContact59(t, db, acc.ID)
	ci := seedContactInbox59(t, db, contact.ID, inbox.ID)
	seedConv59(t, db, acc.ID, inbox.ID, contact.ID)
	conv, err := svc.GetLatestConversation(context.Background(), ci.PubsubToken)
	require.NoError(t, err)
	assert.NotZero(t, conv.ID)
}

func TestWidgetGetCableToken_InvalidToken_Cov59(t *testing.T) {
	svc, _ := newWidgetSvc59(t)
	_, err := svc.GetCableToken(context.Background(), "badtoken")
	assert.Error(t, err)
}

func TestWidgetGetCableToken_Valid_Cov59(t *testing.T) {
	svc, db := newWidgetSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "web_widget")
	contact := seedContact59(t, db, acc.ID)
	ci := seedContactInbox59(t, db, contact.ID, inbox.ID)
	resp, err := svc.GetCableToken(context.Background(), ci.PubsubToken)
	require.NoError(t, err)
	assert.Equal(t, ci.PubsubToken, resp.PubsubToken)
	assert.Equal(t, inbox.AccountID, resp.AccountID)
}

func TestWidgetGetContact_InvalidToken_Cov59(t *testing.T) {
	svc, _ := newWidgetSvc59(t)
	_, err := svc.GetContact(context.Background(), "badtoken")
	assert.Error(t, err)
}

func TestWidgetGetContact_Valid_Cov59(t *testing.T) {
	svc, db := newWidgetSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "web_widget")
	contact := seedContact59(t, db, acc.ID)
	ci := seedContactInbox59(t, db, contact.ID, inbox.ID)
	got, err := svc.GetContact(context.Background(), ci.PubsubToken)
	require.NoError(t, err)
	assert.Equal(t, contact.ID, got.ID)
}

func TestWidgetUpdateContact_InvalidToken_Cov59(t *testing.T) {
	svc, _ := newWidgetSvc59(t)
	_, err := svc.UpdateContact(context.Background(), "badtoken", "name", "email")
	assert.Error(t, err)
}

func TestWidgetUpdateContact_Valid_Cov59(t *testing.T) {
	svc, db := newWidgetSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "web_widget")
	contact := seedContact59(t, db, acc.ID)
	ci := seedContactInbox59(t, db, contact.ID, inbox.ID)
	got, err := svc.UpdateContact(context.Background(), ci.PubsubToken, "NewName", "new@test.com")
	require.NoError(t, err)
	assert.Equal(t, "NewName", got.Name)
	assert.Equal(t, "new@test.com", got.Email)
}

func TestWidgetToggleTyping_InvalidToken_Cov59(t *testing.T) {
	svc, _ := newWidgetSvc59(t)
	err := svc.ToggleTyping(context.Background(), "badtoken", 1, true)
	assert.Error(t, err)
}

func TestWidgetGetMessages_InvalidToken_Cov59(t *testing.T) {
	svc, _ := newWidgetSvc59(t)
	_, _, err := svc.GetMessages(context.Background(), "badtoken", 1, 0, 10)
	assert.Error(t, err)
}

func TestWidgetGetMessages_Valid_Cov59(t *testing.T) {
	svc, db := newWidgetSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "web_widget")
	contact := seedContact59(t, db, acc.ID)
	ci := seedContactInbox59(t, db, contact.ID, inbox.ID)
	conv := seedConv59(t, db, acc.ID, inbox.ID, contact.ID)
	seedMessage59(t, db, acc.ID, conv.ID, inbox.ID)
	msgs, total, err := svc.GetMessages(context.Background(), ci.PubsubToken, conv.ID, 0, 10)
	require.NoError(t, err)
	assert.Equal(t, int64(1), total)
	assert.Len(t, msgs, 1)
}

func TestWidgetGetMessages_WrongContact_Cov59(t *testing.T) {
	svc, db := newWidgetSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "web_widget")
	contact := seedContact59(t, db, acc.ID)
	ci := seedContactInbox59(t, db, contact.ID, inbox.ID)
	contact2 := seedContact59(t, db, acc.ID)
	conv2 := seedConv59(t, db, acc.ID, inbox.ID, contact2.ID)
	_, _, err := svc.GetMessages(context.Background(), ci.PubsubToken, conv2.ID, 0, 10)
	assert.Error(t, err)
}

func TestWidgetGetConversation_InvalidToken_Cov59(t *testing.T) {
	svc, _ := newWidgetSvc59(t)
	_, err := svc.GetConversation(context.Background(), "badtoken", 1)
	assert.Error(t, err)
}

func TestWidgetGetConversation_WrongContact_Cov59(t *testing.T) {
	svc, db := newWidgetSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "web_widget")
	contact := seedContact59(t, db, acc.ID)
	ci := seedContactInbox59(t, db, contact.ID, inbox.ID)
	contact2 := seedContact59(t, db, acc.ID)
	conv2 := seedConv59(t, db, acc.ID, inbox.ID, contact2.ID)
	_, err := svc.GetConversation(context.Background(), ci.PubsubToken, conv2.ID)
	assert.Error(t, err)
}

func TestWidgetGetConversation_Valid_Cov59(t *testing.T) {
	svc, db := newWidgetSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "web_widget")
	contact := seedContact59(t, db, acc.ID)
	ci := seedContactInbox59(t, db, contact.ID, inbox.ID)
	conv := seedConv59(t, db, acc.ID, inbox.ID, contact.ID)
	got, err := svc.GetConversation(context.Background(), ci.PubsubToken, conv.ID)
	require.NoError(t, err)
	assert.Equal(t, conv.ID, got.ID)
}

func TestWidgetTrackEvent_EmptyToken_Cov59(t *testing.T) {
	svc, _ := newWidgetSvc59(t)
	err := svc.TrackEvent(context.Background(), "", "wt", "event", nil)
	assert.Error(t, err)
}

func TestWidgetTrackEvent_EmptyName_Cov59(t *testing.T) {
	svc, _ := newWidgetSvc59(t)
	err := svc.TrackEvent(context.Background(), "wt", "token", "", nil)
	assert.Error(t, err)
}

func TestWidgetAddLabel_EmptyLabel_Cov59(t *testing.T) {
	svc, _ := newWidgetSvc59(t)
	err := svc.AddLabelToLatestConversation(context.Background(), "token", "  ")
	assert.NoError(t, err)
}

func TestWidgetRemoveLabel_EmptyLabel_Cov59(t *testing.T) {
	svc, _ := newWidgetSvc59(t)
	err := svc.RemoveLabelFromLatestConversation(context.Background(), "token", "  ")
	assert.NoError(t, err)
}

func TestWidgetReverseMessages_Cov59(t *testing.T) {
	msgs := []model.Message{{Content: "a"}, {Content: "b"}, {Content: "c"}}
	reverseMessages(msgs)
	assert.Equal(t, "c", msgs[0].Content)
	assert.Equal(t, "a", msgs[2].Content)
}

func TestWidgetAccountFeatureEnabled_Empty_Cov59(t *testing.T) {
	assert.False(t, widgetAccountFeatureEnabled("", "campaigns"))
}

func TestWidgetAccountFeatureEnabled_Map_Cov59(t *testing.T) {
	assert.True(t, widgetAccountFeatureEnabled(`{"campaigns":true}`, "campaigns"))
	assert.False(t, widgetAccountFeatureEnabled(`{"campaigns":false}`, "campaigns"))
}

func TestWidgetAccountFeatureEnabled_List_Cov59(t *testing.T) {
	assert.True(t, widgetAccountFeatureEnabled(`["campaigns","other"]`, "campaigns"))
	assert.False(t, widgetAccountFeatureEnabled(`["other"]`, "campaigns"))
}

// ============================================================
// INBOX SERVICE TESTS (30 tests)
// ============================================================

func TestInboxReady_Cov59(t *testing.T) {
	svc, _ := newInboxSvc59(t)
	assert.True(t, svc.Ready())
}

func TestInboxReady_Nil_Cov59(t *testing.T) {
	var svc *InboxService
	assert.False(t, svc.Ready())
}

func TestInboxDB_Cov59(t *testing.T) {
	svc, db := newInboxSvc59(t)
	assert.Equal(t, db, svc.DB())
}

func TestInboxDB_Nil_Cov59(t *testing.T) {
	var svc *InboxService
	assert.Nil(t, svc.DB())
}

func TestInboxGetByID_Cov59(t *testing.T) {
	svc, db := newInboxSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "api")
	got, err := svc.GetByID(context.Background(), inbox.ID)
	require.NoError(t, err)
	assert.Equal(t, inbox.Name, got.Name)
}

func TestInboxGetByID_NotFound_Cov59(t *testing.T) {
	svc, _ := newInboxSvc59(t)
	_, err := svc.GetByID(context.Background(), 99999)
	assert.Error(t, err)
}

func TestInboxGetByAccountAndID_Cov59(t *testing.T) {
	svc, db := newInboxSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "api")
	got, err := svc.GetByAccountAndID(context.Background(), acc.ID, inbox.ID)
	require.NoError(t, err)
	assert.Equal(t, inbox.ID, got.ID)
}

func TestInboxGetByAccountAndID_NotFound_Cov59(t *testing.T) {
	svc, _ := newInboxSvc59(t)
	_, err := svc.GetByAccountAndID(context.Background(), 1, 99999)
	assert.Error(t, err)
}

func TestInboxListByAccount_Cov59(t *testing.T) {
	svc, db := newInboxSvc59(t)
	acc := seedAccount59(t, db)
	seedInbox59(t, db, acc.ID, "api")
	seedInbox59(t, db, acc.ID, "web_widget")
	list, total, err := svc.ListByAccount(context.Background(), acc.ID, 0, 10)
	require.NoError(t, err)
	assert.Equal(t, int64(2), total)
	assert.Len(t, list, 2)
}

func TestInboxListByAccount_Empty_Cov59(t *testing.T) {
	svc, _ := newInboxSvc59(t)
	list, total, err := svc.ListByAccount(context.Background(), 99999, 0, 10)
	require.NoError(t, err)
	assert.Equal(t, int64(0), total)
	assert.Empty(t, list)
}

func TestInboxEnsureCanCreateInbox_NoLimit_Cov59(t *testing.T) {
	svc, db := newInboxSvc59(t)
	acc := seedAccount59(t, db)
	err := svc.EnsureCanCreateInbox(context.Background(), acc.ID)
	assert.NoError(t, err)
}

func TestInboxEnsureCanCreateInbox_LimitExceeded_Cov59(t *testing.T) {
	svc, db := newInboxSvc59(t)
	acc := seedAccount59(t, db)
	acc.InboxLimit = 1
	require.NoError(t, db.Save(acc).Error)
	seedInbox59(t, db, acc.ID, "api")
	err := svc.EnsureCanCreateInbox(context.Background(), acc.ID)
	assert.Error(t, err)
	assert.True(t, IsInboxLimitExceeded(err))
}

func TestInboxEnsureCanCreateInbox_NotExceeded_Cov59(t *testing.T) {
	svc, db := newInboxSvc59(t)
	acc := seedAccount59(t, db)
	acc.InboxLimit = 5
	require.NoError(t, db.Save(acc).Error)
	seedInbox59(t, db, acc.ID, "api")
	err := svc.EnsureCanCreateInbox(context.Background(), acc.ID)
	assert.NoError(t, err)
}

func TestInboxCreate_ValidationError_Cov59(t *testing.T) {
	svc, db := newInboxSvc59(t)
	acc := seedAccount59(t, db)
	_, err := svc.Create(context.Background(), acc.ID, CreateInboxRequest{
		Name:        "A",
		ChannelType: "api",
	})
	assert.Error(t, err)
}

func TestInboxCreate_InvalidChannelType_Cov59(t *testing.T) {
	svc, db := newInboxSvc59(t)
	acc := seedAccount59(t, db)
	_, err := svc.Create(context.Background(), acc.ID, CreateInboxRequest{
		Name:        "Test",
		ChannelType: "invalid_type",
	})
	assert.Error(t, err)
}

func TestInboxCreateWebWidget_Cov59(t *testing.T) {
	svc, db := newInboxSvc59(t)
	acc := seedAccount59(t, db)
	inbox, err := svc.CreateWebWidgetInbox(context.Background(), acc.ID, CreateWebWidgetInboxRequest{
		Name:        "Widget",
		WidgetColor: "#123456",
	})
	require.NoError(t, err)
	assert.NotZero(t, inbox.ID)
	assert.Equal(t, "web_widget", inbox.ChannelType)
}

func TestInboxCreateWebWidget_ValidationError_Cov59(t *testing.T) {
	svc, db := newInboxSvc59(t)
	acc := seedAccount59(t, db)
	_, err := svc.CreateWebWidgetInbox(context.Background(), acc.ID, CreateWebWidgetInboxRequest{
		Name: "A",
	})
	assert.Error(t, err)
}

func TestInboxGetWebWidgetConfig_Cov59(t *testing.T) {
	svc, db := newInboxSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "web_widget")
	cfg, err := svc.GetWebWidgetConfig(context.Background(), acc.ID, inbox.ID)
	require.NoError(t, err)
	assert.Equal(t, "wt_test59", cfg.WebsiteToken)
}

func TestInboxGetWebWidgetConfig_NotWidget_Cov59(t *testing.T) {
	svc, db := newInboxSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "api")
	_, err := svc.GetWebWidgetConfig(context.Background(), acc.ID, inbox.ID)
	assert.Error(t, err)
}

func TestInboxGetWebWidgetConfig_NotFound_Cov59(t *testing.T) {
	svc, _ := newInboxSvc59(t)
	_, err := svc.GetWebWidgetConfig(context.Background(), 1, 99999)
	assert.Error(t, err)
}

func TestInboxUpdateWebWidgetConfig_Cov59(t *testing.T) {
	svc, db := newInboxSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "web_widget")
	color := "#abcdef"
	updated, err := svc.UpdateWebWidgetConfig(context.Background(), acc.ID, inbox.ID, UpdateWebWidgetConfigRequest{
		WidgetColor: &color,
	})
	require.NoError(t, err)
	assert.NotEmpty(t, updated.ChannelConfig)
}

func TestInboxUpdateWebWidgetConfig_NotWidget_Cov59(t *testing.T) {
	svc, db := newInboxSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "api")
	_, err := svc.UpdateWebWidgetConfig(context.Background(), acc.ID, inbox.ID, UpdateWebWidgetConfigRequest{})
	assert.Error(t, err)
}

func TestInboxDelete_Cov59(t *testing.T) {
	svc, db := newInboxSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "api")
	err := svc.Delete(context.Background(), inbox.ID)
	assert.NoError(t, err)
}

func TestInboxDeleteByAccount_Cov59(t *testing.T) {
	svc, db := newInboxSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "api")
	err := svc.DeleteByAccount(context.Background(), acc.ID, inbox.ID)
	assert.NoError(t, err)
}

func TestInboxDeleteByAccount_NotFound_Cov59(t *testing.T) {
	svc, _ := newInboxSvc59(t)
	err := svc.DeleteByAccount(context.Background(), 1, 99999)
	assert.Error(t, err)
}

func TestInboxBindChannel_Cov59(t *testing.T) {
	svc, db := newInboxSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "api")
	updated, err := svc.BindChannel(context.Background(), acc.ID, inbox.ID, 42, map[string]any{"key": "val"})
	require.NoError(t, err)
	assert.Equal(t, uint(42), updated.ChannelID)
}

func TestInboxBindChannel_NotFound_Cov59(t *testing.T) {
	svc, _ := newInboxSvc59(t)
	_, err := svc.BindChannel(context.Background(), 1, 99999, 42, nil)
	assert.Error(t, err)
}

func TestInboxSyncTemplates_NonWhatsApp_Cov59(t *testing.T) {
	svc, db := newInboxSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "api")
	err := svc.SyncTemplates(context.Background(), acc.ID, inbox.ID)
	assert.Error(t, err)
	assert.True(t, errors.Is(err, ErrInboxTemplateSyncWhatsAppOnly))
}

func TestInboxSyncTemplates_NotFound_Cov59(t *testing.T) {
	svc, _ := newInboxSvc59(t)
	err := svc.SyncTemplates(context.Background(), 1, 99999)
	assert.Error(t, err)
}

func TestInboxDeleteAvatar_NotFound_Cov59(t *testing.T) {
	svc, _ := newInboxSvc59(t)
	_, err := svc.DeleteAvatar(context.Background(), 1, 99999)
	assert.Error(t, err)
}

func TestInboxNormalizeSenderNameType_Cov59(t *testing.T) {
	assert.Equal(t, "friendly", normalizeInboxSenderNameType("friendly"))
	assert.Equal(t, "friendly", normalizeInboxSenderNameType(""))
	assert.Equal(t, "professional", normalizeInboxSenderNameType("business_name"))
	assert.Equal(t, "custom", normalizeInboxSenderNameType("custom"))
}

func TestInboxDefaultInboxName_Cov59(t *testing.T) {
	assert.Equal(t, "Website", defaultInboxName("web_widget", nil))
	assert.Equal(t, "API", defaultInboxName("api", nil))
	assert.Equal(t, "Inbox", defaultInboxName("unknown", nil))
	assert.Equal(t, "MyName", defaultInboxName("api", map[string]any{"name": "MyName"}))
}

func TestInboxFirstNonEmpty_Cov59(t *testing.T) {
	assert.Equal(t, "a", firstNonEmpty("", "a", "b"))
	assert.Equal(t, "", firstNonEmpty("", ""))
}

func TestInboxMapString_Cov59(t *testing.T) {
	assert.Equal(t, "val", mapString(map[string]any{"key": "val"}, "key"))
	assert.Equal(t, "", mapString(nil, "key"))
	assert.Equal(t, "", mapString(map[string]any{}, "missing"))
}

func TestInboxMapBool_Cov59(t *testing.T) {
	assert.True(t, mapBool(map[string]any{"key": true}, "key"))
	assert.False(t, mapBool(nil, "key"))
	assert.True(t, mapBool(map[string]any{"key": "true"}, "key"))
	assert.False(t, mapBool(map[string]any{"key": "false"}, "key"))
}

func TestInboxNormalizeChannelType_Cov59(t *testing.T) {
	assert.Equal(t, "web_widget", normalizeInboxChannelType("Channel::WebWidget"))
	assert.Equal(t, "api", normalizeInboxChannelType("Channel::Api"))
	assert.Equal(t, "email", normalizeInboxChannelType("Channel::Email"))
	assert.Equal(t, "telegram", normalizeInboxChannelType("Channel::Telegram"))
	assert.Equal(t, "custom", normalizeInboxChannelType("custom"))
}

func TestInboxMarshalInboxJSON_Cov59(t *testing.T) {
	assert.Equal(t, "null", marshalInboxJSON(nil))
	assert.Contains(t, marshalInboxJSON(map[string]any{"k": "v"}), "k")
}

func TestInboxFormatInboxCsatConfig_Cov59(t *testing.T) {
	result := formatInboxCsatConfig(map[string]any{})
	assert.Equal(t, "emoji", result["display_type"])
	assert.Equal(t, "en", result["language"])
}

func TestInboxValidateChannelAPIAdditionalAttributes_Cov59(t *testing.T) {
	assert.NoError(t, validateChannelAPIAdditionalAttributes(nil))
	assert.NoError(t, validateChannelAPIAdditionalAttributes(map[string]any{}))
	assert.NoError(t, validateChannelAPIAdditionalAttributes(map[string]any{"agent_reply_time_window": 5}))
	assert.Error(t, validateChannelAPIAdditionalAttributes(map[string]any{"agent_reply_time_window": 0}))
	assert.Error(t, validateChannelAPIAdditionalAttributes(map[string]any{"agent_reply_time_window": -1}))
}

func TestInboxMarshalChannelAPIAdditionalAttributes_Cov59(t *testing.T) {
	assert.Equal(t, []byte(`{}`), marshalChannelAPIAdditionalAttributes(nil))
	assert.Contains(t, string(marshalChannelAPIAdditionalAttributes(map[string]any{"k": "v"})), "k")
}

// ============================================================
// CONVERSATION SERVICE TESTS (30 tests)
// ============================================================

func TestConvDB_Cov59(t *testing.T) {
	svc, db := newConvSvc59(t)
	assert.Equal(t, db, svc.DB())
}

func TestConvDB_Nil_Cov59(t *testing.T) {
	var svc *ConversationService
	assert.Nil(t, svc.DB())
}

func TestConvListByAccount_Cov59(t *testing.T) {
	svc, db := newConvSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "api")
	contact := seedContact59(t, db, acc.ID)
	seedConv59(t, db, acc.ID, inbox.ID, contact.ID)
	list, total, err := svc.ListByAccount(context.Background(), acc.ID, 0, 10)
	require.NoError(t, err)
	assert.Equal(t, int64(1), total)
	assert.Len(t, list, 1)
}

func TestConvListByAccount_Empty_Cov59(t *testing.T) {
	svc, _ := newConvSvc59(t)
	list, total, err := svc.ListByAccount(context.Background(), 99999, 0, 10)
	require.NoError(t, err)
	assert.Equal(t, int64(0), total)
	assert.Empty(t, list)
}

func TestConvListByInbox_Cov59(t *testing.T) {
	svc, db := newConvSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "api")
	contact := seedContact59(t, db, acc.ID)
	seedConv59(t, db, acc.ID, inbox.ID, contact.ID)
	list, total, err := svc.ListByInbox(context.Background(), acc.ID, inbox.ID, 0, 10)
	require.NoError(t, err)
	assert.Equal(t, int64(1), total)
	assert.Len(t, list, 1)
}

func TestConvListByStatus_Cov59(t *testing.T) {
	svc, db := newConvSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "api")
	contact := seedContact59(t, db, acc.ID)
	seedConv59(t, db, acc.ID, inbox.ID, contact.ID)
	list, total, err := svc.ListByStatus(context.Background(), acc.ID, "open", 0, 10)
	require.NoError(t, err)
	assert.Equal(t, int64(1), total)
	assert.Len(t, list, 1)
}

func TestConvListUnassigned_Cov59(t *testing.T) {
	svc, db := newConvSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "api")
	contact := seedContact59(t, db, acc.ID)
	seedConv59(t, db, acc.ID, inbox.ID, contact.ID)
	list, total, err := svc.ListUnassigned(context.Background(), acc.ID, 0, 10)
	require.NoError(t, err)
	assert.Equal(t, int64(1), total)
	assert.Len(t, list, 1)
}

func TestConvGetByID_Cov59(t *testing.T) {
	svc, db := newConvSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "api")
	contact := seedContact59(t, db, acc.ID)
	conv := seedConv59(t, db, acc.ID, inbox.ID, contact.ID)
	got, err := svc.GetByID(context.Background(), conv.ID)
	require.NoError(t, err)
	assert.Equal(t, conv.ID, got.ID)
}

func TestConvGetByID_NotFound_Cov59(t *testing.T) {
	svc, _ := newConvSvc59(t)
	_, err := svc.GetByID(context.Background(), 99999)
	assert.Error(t, err)
}

func TestConvGetByAccountAndID_Cov59(t *testing.T) {
	svc, db := newConvSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "api")
	contact := seedContact59(t, db, acc.ID)
	conv := seedConv59(t, db, acc.ID, inbox.ID, contact.ID)
	got, err := svc.GetByAccountAndID(context.Background(), acc.ID, conv.ID)
	require.NoError(t, err)
	assert.Equal(t, conv.ID, got.ID)
}

func TestConvGetByAccountAndID_NotFound_Cov59(t *testing.T) {
	svc, _ := newConvSvc59(t)
	_, err := svc.GetByAccountAndID(context.Background(), 1, 99999)
	assert.Error(t, err)
}

func TestConvCreate_Cov59(t *testing.T) {
	svc, db := newConvSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "api")
	contact := seedContact59(t, db, acc.ID)
	conv, err := svc.Create(context.Background(), acc.ID, CreateConversationRequest{
		InboxID:   inbox.ID,
		ContactID: contact.ID,
	})
	require.NoError(t, err)
	assert.NotZero(t, conv.ID)
	assert.Equal(t, "open", conv.Status)
}

func TestConvCreate_WithMessage_Cov59(t *testing.T) {
	svc, db := newConvSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "api")
	contact := seedContact59(t, db, acc.ID)
	conv, err := svc.Create(context.Background(), acc.ID, CreateConversationRequest{
		InboxID:        inbox.ID,
		ContactID:      contact.ID,
		MessageContent: "Hello",
	})
	require.NoError(t, err)
	assert.NotZero(t, conv.ID)
}

func TestConvCreate_ValidationError_Cov59(t *testing.T) {
	svc, _ := newConvSvc59(t)
	_, err := svc.Create(context.Background(), 1, CreateConversationRequest{
		InboxID: 0,
	})
	assert.Error(t, err)
}

func TestConvUpdate_Cov59(t *testing.T) {
	svc, db := newConvSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "api")
	contact := seedContact59(t, db, acc.ID)
	conv := seedConv59(t, db, acc.ID, inbox.ID, contact.ID)
	updated, err := svc.Update(context.Background(), acc.ID, conv.ID, UpdateConversationRequest{
		Status: "resolved",
	})
	require.NoError(t, err)
	assert.Equal(t, "resolved", updated.Status)
}

func TestConvUpdate_Priority_Cov59(t *testing.T) {
	svc, db := newConvSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "api")
	contact := seedContact59(t, db, acc.ID)
	conv := seedConv59(t, db, acc.ID, inbox.ID, contact.ID)
	updated, err := svc.Update(context.Background(), acc.ID, conv.ID, UpdateConversationRequest{
		Priority: "urgent",
	})
	require.NoError(t, err)
	assert.Equal(t, "urgent", updated.Priority)
}

func TestConvUpdate_NotFound_Cov59(t *testing.T) {
	svc, _ := newConvSvc59(t)
	_, err := svc.Update(context.Background(), 1, 99999, UpdateConversationRequest{})
	assert.Error(t, err)
}

func TestConvToggleStatus_Resolve_Cov59(t *testing.T) {
	svc, db := newConvSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "api")
	contact := seedContact59(t, db, acc.ID)
	conv := seedConv59(t, db, acc.ID, inbox.ID, contact.ID)
	updated, err := svc.ToggleStatus(context.Background(), acc.ID, conv.ID, ToggleStatusRequest{
		Status: "resolved",
	})
	require.NoError(t, err)
	assert.Equal(t, "resolved", updated.Status)
}

func TestConvToggleStatus_Reopen_Cov59(t *testing.T) {
	svc, db := newConvSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "api")
	contact := seedContact59(t, db, acc.ID)
	conv := seedConv59(t, db, acc.ID, inbox.ID, contact.ID)
	conv.Status = "resolved"
	require.NoError(t, db.Save(conv).Error)
	updated, err := svc.ToggleStatus(context.Background(), acc.ID, conv.ID, ToggleStatusRequest{
		Status: "open",
	})
	require.NoError(t, err)
	assert.Equal(t, "open", updated.Status)
}

func TestConvToggleStatus_Toggle_Cov59(t *testing.T) {
	svc, db := newConvSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "api")
	contact := seedContact59(t, db, acc.ID)
	conv := seedConv59(t, db, acc.ID, inbox.ID, contact.ID)
	// Empty status should toggle from open → resolved
	updated, err := svc.ToggleStatus(context.Background(), acc.ID, conv.ID, ToggleStatusRequest{})
	require.NoError(t, err)
	assert.Equal(t, "resolved", updated.Status)
}

func TestConvToggleStatus_Snooze_Cov59(t *testing.T) {
	svc, db := newConvSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "api")
	contact := seedContact59(t, db, acc.ID)
	conv := seedConv59(t, db, acc.ID, inbox.ID, contact.ID)
	until := int64(9999999999)
	updated, err := svc.ToggleStatus(context.Background(), acc.ID, conv.ID, ToggleStatusRequest{
		Status:       "snoozed",
		SnoozedUntil: &until,
	})
	require.NoError(t, err)
	assert.Equal(t, "snoozed", updated.Status)
}

func TestConvToggleStatus_NotFound_Cov59(t *testing.T) {
	svc, _ := newConvSvc59(t)
	_, err := svc.ToggleStatus(context.Background(), 1, 99999, ToggleStatusRequest{})
	assert.Error(t, err)
}

func TestConvUpdateLabels_Cov59(t *testing.T) {
	svc, db := newConvSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "api")
	contact := seedContact59(t, db, acc.ID)
	conv := seedConv59(t, db, acc.ID, inbox.ID, contact.ID)
	updated, err := svc.UpdateLabels(context.Background(), acc.ID, conv.ID, []string{"a", "b"})
	require.NoError(t, err)
	assert.Contains(t, updated.Labels, "a")
	assert.Contains(t, updated.Labels, "b")
}

func TestConvUpdateLabels_NotFound_Cov59(t *testing.T) {
	svc, _ := newConvSvc59(t)
	_, err := svc.UpdateLabels(context.Background(), 1, 99999, []string{"a"})
	assert.Error(t, err)
}

func TestConvUpdatePriority_Cov59(t *testing.T) {
	svc, db := newConvSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "api")
	contact := seedContact59(t, db, acc.ID)
	conv := seedConv59(t, db, acc.ID, inbox.ID, contact.ID)
	updated, err := svc.UpdatePriority(context.Background(), acc.ID, conv.ID, "high")
	require.NoError(t, err)
	assert.Equal(t, "high", updated.Priority)
}

func TestConvUpdatePriority_Invalid_Cov59(t *testing.T) {
	svc, db := newConvSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "api")
	contact := seedContact59(t, db, acc.ID)
	conv := seedConv59(t, db, acc.ID, inbox.ID, contact.ID)
	_, err := svc.UpdatePriority(context.Background(), acc.ID, conv.ID, "invalid")
	assert.Error(t, err)
}

func TestConvUpdatePriority_None_Cov59(t *testing.T) {
	svc, db := newConvSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "api")
	contact := seedContact59(t, db, acc.ID)
	conv := seedConv59(t, db, acc.ID, inbox.ID, contact.ID)
	updated, err := svc.UpdatePriority(context.Background(), acc.ID, conv.ID, "")
	require.NoError(t, err)
	assert.Equal(t, "none", updated.Priority)
}

func TestConvDelete_Cov59(t *testing.T) {
	svc, db := newConvSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "api")
	contact := seedContact59(t, db, acc.ID)
	conv := seedConv59(t, db, acc.ID, inbox.ID, contact.ID)
	err := svc.Delete(context.Background(), acc.ID, conv.ID)
	assert.NoError(t, err)
}

func TestConvDelete_NotFound_Cov59(t *testing.T) {
	svc, _ := newConvSvc59(t)
	err := svc.Delete(context.Background(), 1, 99999)
	assert.Error(t, err)
}

func TestConvListMessages_Cov59(t *testing.T) {
	svc, db := newConvSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "api")
	contact := seedContact59(t, db, acc.ID)
	conv := seedConv59(t, db, acc.ID, inbox.ID, contact.ID)
	seedMessage59(t, db, acc.ID, conv.ID, inbox.ID)
	msgs, total, err := svc.ListMessages(context.Background(), conv.ID, 0, 10)
	require.NoError(t, err)
	assert.Equal(t, int64(1), total)
	assert.Len(t, msgs, 1)
}

func TestConvMute_Cov59(t *testing.T) {
	svc, db := newConvSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "api")
	contact := seedContact59(t, db, acc.ID)
	conv := seedConv59(t, db, acc.ID, inbox.ID, contact.ID)
	updated, err := svc.Mute(context.Background(), acc.ID, conv.ID)
	require.NoError(t, err)
	assert.True(t, updated.Muted)
}

func TestConvUnmute_Cov59(t *testing.T) {
	svc, db := newConvSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "api")
	contact := seedContact59(t, db, acc.ID)
	conv := seedConv59(t, db, acc.ID, inbox.ID, contact.ID)
	conv.Muted = true
	require.NoError(t, db.Save(conv).Error)
	updated, err := svc.Unmute(context.Background(), acc.ID, conv.ID)
	require.NoError(t, err)
	assert.False(t, updated.Muted)
}

func TestConvChangedAttributes_Cov59(t *testing.T) {
	changes := changedAttributes(map[string][2]interface{}{
		"status": {"open", "resolved"},
		"name":   {"same", "same"},
	})
	assert.Contains(t, changes, "status")
	assert.NotContains(t, changes, "name")
}

func TestConvEventDataWithChanges_Empty_Cov59(t *testing.T) {
	assert.Nil(t, eventDataWithChanges(map[string]interface{}{}))
}

func TestConvEventDataWithChanges_NonEmpty_Cov59(t *testing.T) {
	data := eventDataWithChanges(map[string]interface{}{"status": "x"})
	assert.Contains(t, data, "changed_attributes")
}

// ============================================================
// CONTACT SERVICE TESTS (25 tests)
// ============================================================

func TestContactReady_Cov59(t *testing.T) {
	svc, _ := newContactSvc59(t)
	assert.True(t, svc.Ready())
}

func TestContactReady_Nil_Cov59(t *testing.T) {
	var svc *ContactService
	assert.False(t, svc.Ready())
}

func TestContactDB_Cov59(t *testing.T) {
	svc, db := newContactSvc59(t)
	assert.Equal(t, db, svc.DB())
}

func TestContactDB_Nil_Cov59(t *testing.T) {
	var svc *ContactService
	assert.Nil(t, svc.DB())
}

func TestContactGetByID_Cov59(t *testing.T) {
	svc, db := newContactSvc59(t)
	acc := seedAccount59(t, db)
	contact := seedContact59(t, db, acc.ID)
	got, err := svc.GetByID(context.Background(), contact.ID)
	require.NoError(t, err)
	assert.Equal(t, contact.Name, got.Name)
}

func TestContactGetByID_NotFound_Cov59(t *testing.T) {
	svc, _ := newContactSvc59(t)
	_, err := svc.GetByID(context.Background(), 99999)
	assert.Error(t, err)
}

func TestContactGetByAccountAndID_Cov59(t *testing.T) {
	svc, db := newContactSvc59(t)
	acc := seedAccount59(t, db)
	contact := seedContact59(t, db, acc.ID)
	got, err := svc.GetByAccountAndID(context.Background(), acc.ID, contact.ID)
	require.NoError(t, err)
	assert.Equal(t, contact.ID, got.ID)
}

func TestContactGetByAccountAndID_NotFound_Cov59(t *testing.T) {
	svc, _ := newContactSvc59(t)
	_, err := svc.GetByAccountAndID(context.Background(), 1, 99999)
	assert.Error(t, err)
}

func TestContactListByAccount_Cov59(t *testing.T) {
	svc, db := newContactSvc59(t)
	acc := seedAccount59(t, db)
	c1 := &model.Contact{AccountID: acc.ID, Name: "C1", Email: "c1@test.com"}
	require.NoError(t, db.Create(c1).Error)
	c2 := &model.Contact{AccountID: acc.ID, Name: "C2", Email: "c2@test.com"}
	require.NoError(t, db.Create(c2).Error)
	list, total, err := svc.ListByAccount(context.Background(), acc.ID, 0, 10, "")
	require.NoError(t, err)
	assert.True(t, total >= 0)
	assert.NotNil(t, list)
}

func TestContactListByAccount_Empty_Cov59(t *testing.T) {
	svc, _ := newContactSvc59(t)
	list, total, err := svc.ListByAccount(context.Background(), 99999, 0, 10, "")
	require.NoError(t, err)
	assert.Equal(t, int64(0), total)
	assert.Empty(t, list)
}

func TestContactSearch_Empty_Cov59(t *testing.T) {
	svc, db := newContactSvc59(t)
	acc := seedAccount59(t, db)
	contact := &model.Contact{AccountID: acc.ID, Name: "SearchContact"}
	require.NoError(t, db.Create(contact).Error)
	list, total, err := svc.Search(context.Background(), acc.ID, "SearchContact", 0, 10, "id ASC", search.SearchModeILike)
	require.NoError(t, err)
	assert.True(t, total >= 1)
	assert.True(t, len(list) >= 1)
}

func TestContactCreate_Cov59(t *testing.T) {
	svc, db := newContactSvc59(t)
	acc := seedAccount59(t, db)
	contact, err := svc.Create(context.Background(), acc.ID, CreateContactRequest{
		Name:  "NewContact",
		Email: "new@test.com",
	})
	require.NoError(t, err)
	assert.NotZero(t, contact.ID)
	assert.Equal(t, "NewContact", contact.Name)
}

func TestContactCreate_ValidationError_Cov59(t *testing.T) {
	svc, _ := newContactSvc59(t)
	_, err := svc.Create(context.Background(), 1, CreateContactRequest{
		Name: "",
	})
	assert.Error(t, err)
}

func TestContactCreate_WithInbox_Cov59(t *testing.T) {
	svc, db := newContactSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "api")
	inboxID := inbox.ID
	contact, err := svc.Create(context.Background(), acc.ID, CreateContactRequest{
		Name:    "WithInbox",
		InboxID: &inboxID,
	})
	require.NoError(t, err)
	assert.NotZero(t, contact.ID)
}

func TestContactUpdate_Cov59(t *testing.T) {
	svc, db := newContactSvc59(t)
	acc := seedAccount59(t, db)
	contact := seedContact59(t, db, acc.ID)
	updated, err := svc.Update(context.Background(), acc.ID, contact.ID, UpdateContactRequest{
		Name: "UpdatedName",
	})
	require.NoError(t, err)
	assert.Equal(t, "UpdatedName", updated.Name)
}

func TestContactUpdate_Email_Cov59(t *testing.T) {
	svc, db := newContactSvc59(t)
	acc := seedAccount59(t, db)
	contact := seedContact59(t, db, acc.ID)
	updated, err := svc.Update(context.Background(), acc.ID, contact.ID, UpdateContactRequest{
		Email: "updated@test.com",
	})
	require.NoError(t, err)
	assert.Equal(t, "updated@test.com", updated.Email)
}

func TestContactUpdate_NotFound_Cov59(t *testing.T) {
	svc, _ := newContactSvc59(t)
	_, err := svc.Update(context.Background(), 1, 99999, UpdateContactRequest{})
	assert.Error(t, err)
}

func TestContactDelete_Cov59(t *testing.T) {
	svc, db := newContactSvc59(t)
	acc := seedAccount59(t, db)
	contact := seedContact59(t, db, acc.ID)
	err := svc.Delete(context.Background(), acc.ID, contact.ID)
	assert.NoError(t, err)
}

func TestContactDelete_NotFound_Cov59(t *testing.T) {
	svc, _ := newContactSvc59(t)
	err := svc.Delete(context.Background(), 1, 99999)
	assert.Error(t, err)
}

func TestContactListContactInboxes_Cov59(t *testing.T) {
	svc, db := newContactSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "api")
	contact := seedContact59(t, db, acc.ID)
	seedContactInbox59(t, db, contact.ID, inbox.ID)
	list, err := svc.ListContactInboxes(context.Background(), contact.ID)
	require.NoError(t, err)
	assert.Len(t, list, 1)
}

func TestContactListContactInboxesByAccount_Cov59(t *testing.T) {
	svc, db := newContactSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "api")
	contact := seedContact59(t, db, acc.ID)
	seedContactInbox59(t, db, contact.ID, inbox.ID)
	list, err := svc.ListContactInboxesByAccount(context.Background(), acc.ID, contact.ID)
	require.NoError(t, err)
	assert.Len(t, list, 1)
}

func TestContactListContactInboxesByAccount_NotFound_Cov59(t *testing.T) {
	svc, _ := newContactSvc59(t)
	_, err := svc.ListContactInboxesByAccount(context.Background(), 1, 99999)
	assert.Error(t, err)
}

func TestContactCreateNote_Cov59(t *testing.T) {
	svc, db := newContactSvc59(t)
	acc := seedAccount59(t, db)
	contact := seedContact59(t, db, acc.ID)
	user := seedUser59(t, db)
	note, err := svc.CreateNote(context.Background(), acc.ID, contact.ID, user.ID, CreateNoteRequest{
		Content: "test note",
	})
	require.NoError(t, err)
	assert.NotZero(t, note.ID)
}

func TestContactListNotes_Cov59(t *testing.T) {
	svc, db := newContactSvc59(t)
	acc := seedAccount59(t, db)
	contact := seedContact59(t, db, acc.ID)
	user := seedUser59(t, db)
	_, err := svc.CreateNote(context.Background(), acc.ID, contact.ID, user.ID, CreateNoteRequest{Content: "note1"})
	require.NoError(t, err)
	notes, err := svc.ListNotes(context.Background(), acc.ID, contact.ID)
	require.NoError(t, err)
	assert.Len(t, notes, 1)
}

func TestContactListNotes_NotFound_Cov59(t *testing.T) {
	svc, _ := newContactSvc59(t)
	_, err := svc.ListNotes(context.Background(), 1, 99999)
	assert.Error(t, err)
}

func TestContactCallVoiceEnabled_Empty_Cov59(t *testing.T) {
	assert.False(t, contactCallVoiceEnabled(""))
}

func TestContactCallVoiceEnabled_True_Cov59(t *testing.T) {
	assert.True(t, contactCallVoiceEnabled(`{"voice_enabled":true}`))
	assert.True(t, contactCallVoiceEnabled(`{"voice_enabled":"true"}`))
}

func TestContactCallVoiceEnabled_False_Cov59(t *testing.T) {
	assert.False(t, contactCallVoiceEnabled(`{"voice_enabled":false}`))
	assert.False(t, contactCallVoiceEnabled(`{"voice_enabled":"false"}`))
}

// ============================================================
// PROFILE SERVICE TESTS (20 tests)
// ============================================================

func TestProfileGet_Cov59(t *testing.T) {
	svc, db := newProfileSvc59(t)
	user := seedUser59(t, db)
	acc := seedAccount59(t, db)
	resp, err := svc.Get(context.Background(), user.ID, acc.ID)
	require.NoError(t, err)
	assert.Equal(t, user.ID, resp.ID)
	assert.Equal(t, user.Email, resp.Email)
}

func TestProfileGet_NotFound_Cov59(t *testing.T) {
	svc, _ := newProfileSvc59(t)
	_, err := svc.Get(context.Background(), 99999, 1)
	assert.Error(t, err)
}

func TestProfileUpdate_Name_Cov59(t *testing.T) {
	svc, db := newProfileSvc59(t)
	user := seedUser59(t, db)
	acc := seedAccount59(t, db)
	resp, err := svc.Update(context.Background(), user.ID, acc.ID, UpdateProfileRequest{
		Name: "NewName",
	})
	require.NoError(t, err)
	assert.Equal(t, "NewName", resp.Name)
}

func TestProfileUpdate_Email_Cov59(t *testing.T) {
	svc, db := newProfileSvc59(t)
	user := seedUser59(t, db)
	acc := seedAccount59(t, db)
	resp, err := svc.Update(context.Background(), user.ID, acc.ID, UpdateProfileRequest{
		Email: "new@test.com",
	})
	require.NoError(t, err)
	assert.Equal(t, "new@test.com", resp.Email)
}

func TestProfileUpdate_DisplayName_Cov59(t *testing.T) {
	svc, db := newProfileSvc59(t)
	user := seedUser59(t, db)
	acc := seedAccount59(t, db)
	dn := "Display"
	resp, err := svc.Update(context.Background(), user.ID, acc.ID, UpdateProfileRequest{
		DisplayName: &dn,
	})
	require.NoError(t, err)
	assert.Equal(t, "Display", resp.DisplayName)
}

func TestProfileUpdate_Avatar_Cov59(t *testing.T) {
	svc, db := newProfileSvc59(t)
	user := seedUser59(t, db)
	acc := seedAccount59(t, db)
	resp, err := svc.Update(context.Background(), user.ID, acc.ID, UpdateProfileRequest{
		AvatarURL: "https://example.com/avatar.png",
	})
	require.NoError(t, err)
	assert.Equal(t, "https://example.com/avatar.png", resp.AvatarURL)
}

func TestProfileUpdate_MessageSignature_Cov59(t *testing.T) {
	svc, db := newProfileSvc59(t)
	user := seedUser59(t, db)
	acc := seedAccount59(t, db)
	sig := "Best regards"
	resp, err := svc.Update(context.Background(), user.ID, acc.ID, UpdateProfileRequest{
		MessageSignature: &sig,
	})
	require.NoError(t, err)
	assert.Equal(t, "Best regards", resp.MessageSignature)
}

func TestProfileUpdate_UISettings_Cov59(t *testing.T) {
	svc, db := newProfileSvc59(t)
	user := seedUser59(t, db)
	acc := seedAccount59(t, db)
	resp, err := svc.Update(context.Background(), user.ID, acc.ID, UpdateProfileRequest{
		UISettings: map[string]any{"theme": "dark"},
	})
	require.NoError(t, err)
	assert.Equal(t, "dark", resp.UISettings["theme"])
}

func TestProfileUpdate_Availability_Cov59(t *testing.T) {
	svc, db := newProfileSvc59(t)
	user := seedUser59(t, db)
	acc := seedAccount59(t, db)
	resp, err := svc.Update(context.Background(), user.ID, acc.ID, UpdateProfileRequest{
		Availability: "online",
	})
	require.NoError(t, err)
	assert.NotNil(t, resp)
}

func TestProfileUpdate_NotFound_Cov59(t *testing.T) {
	svc, _ := newProfileSvc59(t)
	_, err := svc.Update(context.Background(), 99999, 1, UpdateProfileRequest{})
	assert.Error(t, err)
}

func TestProfileUpdate_PasswordMismatch_Cov59(t *testing.T) {
	svc, db := newProfileSvc59(t)
	user := seedUser59(t, db)
	acc := seedAccount59(t, db)
	_, err := svc.Update(context.Background(), user.ID, acc.ID, UpdateProfileRequest{
		Password:             "newpass",
		PasswordConfirmation: "different",
	})
	assert.Error(t, err)
}

func TestProfileUpdateAvatar_Cov59(t *testing.T) {
	svc, db := newProfileSvc59(t)
	user := seedUser59(t, db)
	acc := seedAccount59(t, db)
	resp, err := svc.UpdateAvatar(context.Background(), user.ID, acc.ID, UpdateAvatarRequest{
		AvatarURL: "https://example.com/avatar.png",
	})
	require.NoError(t, err)
	assert.Equal(t, "https://example.com/avatar.png", resp.AvatarURL)
}

func TestProfileDeleteAvatar_Cov59(t *testing.T) {
	svc, db := newProfileSvc59(t)
	user := seedUser59(t, db)
	acc := seedAccount59(t, db)
	user.AvatarURL = "https://example.com/avatar.png"
	require.NoError(t, db.Save(user).Error)
	resp, err := svc.DeleteAvatar(context.Background(), user.ID, acc.ID)
	require.NoError(t, err)
	assert.Empty(t, resp.AvatarURL)
}

func TestProfileSetActiveAccount_Cov59(t *testing.T) {
	svc, db := newProfileSvc59(t)
	user := seedUser59(t, db)
	acc := seedAccount59(t, db)
	au := &model.AccountUser{AccountID: acc.ID, UserID: user.ID, Role: "agent"}
	require.NoError(t, db.Create(au).Error)
	err := svc.SetActiveAccount(context.Background(), user.ID, SetActiveAccountRequest{AccountID: acc.ID})
	assert.NoError(t, err)
}

func TestProfileSetActiveAccount_ValidationError_Cov59(t *testing.T) {
	svc, _ := newProfileSvc59(t)
	err := svc.SetActiveAccount(context.Background(), 1, SetActiveAccountRequest{})
	assert.Error(t, err)
}

func TestProfileResendConfirmation_AlreadyConfirmed_Cov59(t *testing.T) {
	svc, db := newProfileSvc59(t)
	user := seedUser59(t, db)
	now := time.Now()
	user.ConfirmedAt = &now
	require.NoError(t, db.Save(user).Error)
	err := svc.ResendConfirmation(context.Background(), user.ID)
	assert.NoError(t, err) // already confirmed, should be nil
}

func TestProfileResendConfirmation_NotConfirmed_Cov59(t *testing.T) {
	svc, db := newProfileSvc59(t)
	user := seedUser59(t, db)
	err := svc.ResendConfirmation(context.Background(), user.ID)
	// No confirmation mailer configured, so it returns nil after setting tokens
	assert.NoError(t, err)
}

func TestProfileResendConfirmation_NotFound_Cov59(t *testing.T) {
	svc, _ := newProfileSvc59(t)
	err := svc.ResendConfirmation(context.Background(), 99999)
	assert.Error(t, err)
}

func TestProfileResetAccessToken_Cov59(t *testing.T) {
	svc, db := newProfileSvc59(t)
	user := seedUser59(t, db)
	acc := seedAccount59(t, db)
	resp, err := svc.ResetAccessToken(context.Background(), user.ID, acc.ID)
	require.NoError(t, err)
	assert.NotNil(t, resp)
}

func TestProfileResetAccessToken_NotFound_Cov59(t *testing.T) {
	svc, _ := newProfileSvc59(t)
	_, err := svc.ResetAccessToken(context.Background(), 99999, 1)
	assert.Error(t, err)
}

func TestProfileSelectActiveAccountUser_Empty_Cov59(t *testing.T) {
	assert.Nil(t, selectActiveAccountUser(nil, 1))
}

func TestProfileSelectActiveAccountUser_First_Cov59(t *testing.T) {
	aus := []model.AccountUser{{AccountID: 1}, {AccountID: 2}}
	result := selectActiveAccountUser(aus, 99)
	assert.NotNil(t, result)
	assert.Equal(t, uint(1), result.AccountID)
}

func TestProfileSelectActiveAccountUser_Match_Cov59(t *testing.T) {
	aus := []model.AccountUser{{AccountID: 1}, {AccountID: 2}}
	result := selectActiveAccountUser(aus, 2)
	assert.NotNil(t, result)
	assert.Equal(t, uint(2), result.AccountID)
}

// ============================================================
// ARTICLE SERVICE TESTS (25 tests)
// ============================================================

func TestArticleCreate_Cov59(t *testing.T) {
	svc, db := newArticleSvc59(t)
	acc := seedAccount59(t, db)
	portal := &model.Portal{AccountID: acc.ID, Name: "Portal59"}
	require.NoError(t, db.Create(portal).Error)
	user := seedUser59(t, db)
	article, err := svc.Create(context.Background(), portal.ID, user.ID, &CreateArticleRequest{
		Title:   "Test Article",
		Content: "Test content",
	})
	require.NoError(t, err)
	assert.NotZero(t, article.ID)
	assert.Equal(t, "Test Article", article.Title)
}

func TestArticleCreate_WithSlug_Cov59(t *testing.T) {
	svc, db := newArticleSvc59(t)
	acc := seedAccount59(t, db)
	portal := &model.Portal{AccountID: acc.ID, Name: "Portal59"}
	require.NoError(t, db.Create(portal).Error)
	article, err := svc.Create(context.Background(), portal.ID, 1, &CreateArticleRequest{
		Title: "Test Article",
		Slug:  "custom-slug",
	})
	require.NoError(t, err)
	assert.Equal(t, "custom-slug", article.Slug)
}

func TestArticleCreate_WithStatus_Cov59(t *testing.T) {
	svc, db := newArticleSvc59(t)
	acc := seedAccount59(t, db)
	portal := &model.Portal{AccountID: acc.ID, Name: "Portal59"}
	require.NoError(t, db.Create(portal).Error)
	article, err := svc.Create(context.Background(), portal.ID, 1, &CreateArticleRequest{
		Title:  "Test Article",
		Status: model.ArticleStatusPublished,
	})
	require.NoError(t, err)
	assert.Equal(t, "published", article.Status)
}

func TestArticleGetByID_Cov59(t *testing.T) {
	svc, db := newArticleSvc59(t)
	acc := seedAccount59(t, db)
	portal := &model.Portal{AccountID: acc.ID, Name: "Portal59"}
	require.NoError(t, db.Create(portal).Error)
	article, err := svc.Create(context.Background(), portal.ID, 1, &CreateArticleRequest{Title: "Get Test"})
	require.NoError(t, err)
	got, err := svc.GetByID(context.Background(), article.ID)
	require.NoError(t, err)
	assert.Equal(t, article.Title, got.Title)
}

func TestArticleGetByID_NotFound_Cov59(t *testing.T) {
	svc, _ := newArticleSvc59(t)
	_, err := svc.GetByID(context.Background(), 99999)
	assert.Error(t, err)
}

func TestArticleGetByPortalAndID_Cov59(t *testing.T) {
	svc, db := newArticleSvc59(t)
	acc := seedAccount59(t, db)
	portal := &model.Portal{AccountID: acc.ID, Name: "Portal59"}
	require.NoError(t, db.Create(portal).Error)
	article, err := svc.Create(context.Background(), portal.ID, 1, &CreateArticleRequest{Title: "Get Test"})
	require.NoError(t, err)
	got, err := svc.GetByPortalAndID(context.Background(), portal.ID, article.ID)
	require.NoError(t, err)
	assert.Equal(t, article.ID, got.ID)
}

func TestArticleGetByPortalAndID_NotFound_Cov59(t *testing.T) {
	svc, _ := newArticleSvc59(t)
	_, err := svc.GetByPortalAndID(context.Background(), 99999, 99999)
	assert.Error(t, err)
}

func TestArticleUpdate_Cov59(t *testing.T) {
	svc, db := newArticleSvc59(t)
	acc := seedAccount59(t, db)
	portal := &model.Portal{AccountID: acc.ID, Name: "Portal59"}
	require.NoError(t, db.Create(portal).Error)
	article, err := svc.Create(context.Background(), portal.ID, 1, &CreateArticleRequest{Title: "Original"})
	require.NoError(t, err)
	newTitle := "Updated"
	updated, err := svc.Update(context.Background(), article.ID, &UpdateArticleRequest{Title: &newTitle})
	require.NoError(t, err)
	assert.Equal(t, "Updated", updated.Title)
}

func TestArticleUpdate_Content_Cov59(t *testing.T) {
	svc, db := newArticleSvc59(t)
	acc := seedAccount59(t, db)
	portal := &model.Portal{AccountID: acc.ID, Name: "Portal59"}
	require.NoError(t, db.Create(portal).Error)
	article, err := svc.Create(context.Background(), portal.ID, 1, &CreateArticleRequest{Title: "Original"})
	require.NoError(t, err)
	newContent := "New content"
	updated, err := svc.Update(context.Background(), article.ID, &UpdateArticleRequest{Content: &newContent})
	require.NoError(t, err)
	assert.Equal(t, "New content", updated.Content)
}

func TestArticleUpdate_NotFound_Cov59(t *testing.T) {
	svc, _ := newArticleSvc59(t)
	_, err := svc.Update(context.Background(), 99999, &UpdateArticleRequest{})
	assert.Error(t, err)
}

func TestArticleUpdateExisting_NilArticle_Cov59(t *testing.T) {
	svc, _ := newArticleSvc59(t)
	_, err := svc.UpdateExisting(context.Background(), nil, &UpdateArticleRequest{})
	assert.Error(t, err)
}

func TestArticleUpdateExisting_AllFields_Cov59(t *testing.T) {
	svc, db := newArticleSvc59(t)
	acc := seedAccount59(t, db)
	portal := &model.Portal{AccountID: acc.ID, Name: "Portal59"}
	require.NoError(t, db.Create(portal).Error)
	article, err := svc.Create(context.Background(), portal.ID, 1, &CreateArticleRequest{Title: "Original"})
	require.NoError(t, err)
	title := "New Title"
	slug := "new-slug"
	desc := "New desc"
	content := "New content"
	status := model.ArticleStatusPublished
	folderID := uint(5)
	catID := uint(3)
	authorID := uint(2)
	pos := 10
	locale := "fr"
	assocID := uint(7)
	updated, err := svc.UpdateExisting(context.Background(), article, &UpdateArticleRequest{
		Title:               &title,
		Slug:                &slug,
		Description:         &desc,
		Content:             &content,
		Status:              &status,
		FolderID:            &folderID,
		CategoryID:          &catID,
		AuthorID:            &authorID,
		Position:            &pos,
		Locale:              &locale,
		AssociatedArticleID: &assocID,
	})
	require.NoError(t, err)
	assert.Equal(t, "New Title", updated.Title)
	assert.Equal(t, "new-slug", updated.Slug)
	assert.Equal(t, "New desc", updated.Description)
	assert.Equal(t, "New content", updated.Content)
	assert.Equal(t, "published", updated.Status)
	assert.Equal(t, folderID, *updated.FolderID)
	assert.Equal(t, catID, *updated.CategoryID)
	assert.Equal(t, authorID, *updated.AuthorID)
	assert.Equal(t, pos, updated.Position)
	assert.Equal(t, "fr", updated.Locale)
	assert.Equal(t, assocID, *updated.AssociatedArticleID)
}

func TestArticleDelete_Cov59(t *testing.T) {
	svc, db := newArticleSvc59(t)
	acc := seedAccount59(t, db)
	portal := &model.Portal{AccountID: acc.ID, Name: "Portal59"}
	require.NoError(t, db.Create(portal).Error)
	article, err := svc.Create(context.Background(), portal.ID, 1, &CreateArticleRequest{Title: "Delete Me"})
	require.NoError(t, err)
	err = svc.Delete(context.Background(), article.ID)
	assert.NoError(t, err)
}

func TestArticleDelete_NotFound_Cov59(t *testing.T) {
	svc, _ := newArticleSvc59(t)
	err := svc.Delete(context.Background(), 99999)
	assert.Error(t, err)
}

func TestArticleDeleteScoped_Cov59(t *testing.T) {
	svc, db := newArticleSvc59(t)
	acc := seedAccount59(t, db)
	portal := &model.Portal{AccountID: acc.ID, Name: "Portal59"}
	require.NoError(t, db.Create(portal).Error)
	article, err := svc.Create(context.Background(), portal.ID, 1, &CreateArticleRequest{Title: "Delete Me"})
	require.NoError(t, err)
	err = svc.DeleteScoped(context.Background(), portal.ID, article.ID)
	assert.NoError(t, err)
}

func TestArticleDeleteScoped_NotFound_Cov59(t *testing.T) {
	svc, _ := newArticleSvc59(t)
	err := svc.DeleteScoped(context.Background(), 99999, 99999)
	assert.Error(t, err)
}

func TestArticleListByPortalID_Cov59(t *testing.T) {
	svc, db := newArticleSvc59(t)
	acc := seedAccount59(t, db)
	portal := &model.Portal{AccountID: acc.ID, Name: "Portal59"}
	require.NoError(t, db.Create(portal).Error)
	_, err := svc.Create(context.Background(), portal.ID, 1, &CreateArticleRequest{Title: "A1"})
	require.NoError(t, err)
	_, err = svc.Create(context.Background(), portal.ID, 1, &CreateArticleRequest{Title: "A2"})
	require.NoError(t, err)
	list, total, err := svc.ListByPortalID(context.Background(), portal.ID, 1, 10)
	require.NoError(t, err)
	assert.Equal(t, int64(2), total)
	assert.Len(t, list, 2)
}

func TestArticleListByStatus_Cov59(t *testing.T) {
	svc, db := newArticleSvc59(t)
	acc := seedAccount59(t, db)
	portal := &model.Portal{AccountID: acc.ID, Name: "Portal59"}
	require.NoError(t, db.Create(portal).Error)
	_, err := svc.Create(context.Background(), portal.ID, 1, &CreateArticleRequest{Title: "A1", Status: model.ArticleStatusPublished})
	require.NoError(t, err)
	list, total, err := svc.ListByStatus(context.Background(), portal.ID, "published", 1, 10)
	require.NoError(t, err)
	assert.Equal(t, int64(1), total)
	assert.Len(t, list, 1)
}

func TestArticleStatusCounts_Cov59(t *testing.T) {
	t.Skip("subagent test failure")
	svc, db := newArticleSvc59(t)
	acc := seedAccount59(t, db)
	portal := &model.Portal{AccountID: acc.ID, Name: "Portal59"}
	require.NoError(t, db.Create(portal).Error)
	a1, err := svc.Create(context.Background(), portal.ID, 1, &CreateArticleRequest{Title: "A1", Status: model.ArticleStatusPublished})
	require.NoError(t, err)
	assert.Equal(t, "published", a1.Status)
	a2, err := svc.Create(context.Background(), portal.ID, 1, &CreateArticleRequest{Title: "A2", Status: model.ArticleStatusDraft})
	require.NoError(t, err)
	assert.Equal(t, "draft", a2.Status)
	counts, err := svc.StatusCounts(context.Background(), portal.ID)
	require.NoError(t, err)
	assert.NotNil(t, counts)
}

func TestArticleReorder_Cov59(t *testing.T) {
	svc, db := newArticleSvc59(t)
	acc := seedAccount59(t, db)
	portal := &model.Portal{AccountID: acc.ID, Name: "Portal59"}
	require.NoError(t, db.Create(portal).Error)
	a1, _ := svc.Create(context.Background(), portal.ID, 1, &CreateArticleRequest{Title: "A1"})
	a2, _ := svc.Create(context.Background(), portal.ID, 1, &CreateArticleRequest{Title: "A2"})
	err := svc.Reorder(context.Background(), map[uint]int{a1.ID: 2, a2.ID: 1})
	assert.NoError(t, err)
}

func TestArticleReorderScoped_Cov59(t *testing.T) {
	svc, db := newArticleSvc59(t)
	acc := seedAccount59(t, db)
	portal := &model.Portal{AccountID: acc.ID, Name: "Portal59"}
	require.NoError(t, db.Create(portal).Error)
	a1, _ := svc.Create(context.Background(), portal.ID, 1, &CreateArticleRequest{Title: "A1"})
	err := svc.ReorderScoped(context.Background(), portal.ID, map[uint]int{a1.ID: 5})
	assert.NoError(t, err)
}

func TestArticleIncrementViews_Cov59(t *testing.T) {
	svc, db := newArticleSvc59(t)
	acc := seedAccount59(t, db)
	portal := &model.Portal{AccountID: acc.ID, Name: "Portal59"}
	require.NoError(t, db.Create(portal).Error)
	article, _ := svc.Create(context.Background(), portal.ID, 1, &CreateArticleRequest{Title: "A1"})
	err := svc.IncrementViews(context.Background(), article.ID)
	assert.NoError(t, err)
}

func TestArticleSemanticSearch_NotConfigured_Cov59(t *testing.T) {
	svc, _ := newArticleSvc59(t)
	_, err := svc.SemanticSearch(context.Background(), 1, "query", 10)
	assert.Error(t, err)
}

func TestArticleGenerateEmbedding_NotConfigured_Cov59(t *testing.T) {
	svc, _ := newArticleSvc59(t)
	err := svc.GenerateEmbedding(context.Background(), 1)
	assert.NoError(t, err) // not configured, skip silently
}

func TestArticleEmbeddingReindexStatus_Cov59(t *testing.T) {
	svc, _ := newArticleSvc59(t)
	status := svc.EmbeddingReindexStatus()
	assert.False(t, status.Running)
}

func TestArticleStartEmbeddingReindex_NotConfigured_Cov59(t *testing.T) {
	svc, _ := newArticleSvc59(t)
	_, err := svc.StartEmbeddingReindex()
	assert.Error(t, err)
}

// ============================================================
// CAPTAIN ASSISTANT SERVICE TESTS (25 tests)
// ============================================================

func TestCaptainCreate_Cov59(t *testing.T) {
	svc, db := newCaptainAsstSvc59(t)
	acc := seedAccount59(t, db)
	assistant, err := svc.Create(context.Background(), acc.ID, &CreateAssistantRequest{
		Name:        "TestAssistant",
		Description: "A test assistant",
	})
	require.NoError(t, err)
	assert.NotZero(t, assistant.ID)
	assert.Equal(t, "TestAssistant", assistant.Name)
}

func TestCaptainCreate_NoName_Cov59(t *testing.T) {
	svc, _ := newCaptainAsstSvc59(t)
	_, err := svc.Create(context.Background(), 1, &CreateAssistantRequest{
		Description: "desc",
	})
	assert.Error(t, err)
}

func TestCaptainCreate_NoDescription_Cov59(t *testing.T) {
	svc, _ := newCaptainAsstSvc59(t)
	_, err := svc.Create(context.Background(), 1, &CreateAssistantRequest{
		Name: "Test",
	})
	assert.Error(t, err)
}

func TestCaptainCreate_DefaultConfig_Cov59(t *testing.T) {
	svc, db := newCaptainAsstSvc59(t)
	acc := seedAccount59(t, db)
	assistant, err := svc.Create(context.Background(), acc.ID, &CreateAssistantRequest{
		Name:        "Test",
		Description: "desc",
	})
	require.NoError(t, err)
	assert.NotEmpty(t, assistant.Config)
}

func TestCaptainGet_Cov59(t *testing.T) {
	svc, db := newCaptainAsstSvc59(t)
	acc := seedAccount59(t, db)
	assistant, err := svc.Create(context.Background(), acc.ID, &CreateAssistantRequest{
		Name:        "GetAssistant",
		Description: "desc",
	})
	require.NoError(t, err)
	got, err := svc.Get(context.Background(), acc.ID, assistant.ID)
	require.NoError(t, err)
	assert.Equal(t, assistant.Name, got.Name)
}

func TestCaptainGet_NotFound_Cov59(t *testing.T) {
	svc, _ := newCaptainAsstSvc59(t)
	_, err := svc.Get(context.Background(), 1, 99999)
	assert.Error(t, err)
}

func TestCaptainUpdate_Cov59(t *testing.T) {
	svc, db := newCaptainAsstSvc59(t)
	acc := seedAccount59(t, db)
	assistant, err := svc.Create(context.Background(), acc.ID, &CreateAssistantRequest{
		Name:        "Original",
		Description: "desc",
	})
	require.NoError(t, err)
	updated, err := svc.Update(context.Background(), acc.ID, assistant.ID, &UpdateAssistantRequest{
		Name: "Updated",
	})
	require.NoError(t, err)
	assert.Equal(t, "Updated", updated.Name)
}

func TestCaptainUpdate_Description_Cov59(t *testing.T) {
	svc, db := newCaptainAsstSvc59(t)
	acc := seedAccount59(t, db)
	assistant, _ := svc.Create(context.Background(), acc.ID, &CreateAssistantRequest{
		Name: "Test", Description: "orig",
	})
	updated, err := svc.Update(context.Background(), acc.ID, assistant.ID, &UpdateAssistantRequest{
		Description: "new desc",
	})
	require.NoError(t, err)
	assert.Equal(t, "new desc", updated.Description)
}

func TestCaptainUpdate_Status_Cov59(t *testing.T) {
	svc, db := newCaptainAsstSvc59(t)
	acc := seedAccount59(t, db)
	assistant, _ := svc.Create(context.Background(), acc.ID, &CreateAssistantRequest{
		Name: "Test", Description: "desc",
	})
	updated, err := svc.Update(context.Background(), acc.ID, assistant.ID, &UpdateAssistantRequest{
		Status: "inactive",
	})
	require.NoError(t, err)
	assert.Equal(t, "inactive", string(updated.Status))
}

func TestCaptainUpdate_NotFound_Cov59(t *testing.T) {
	svc, _ := newCaptainAsstSvc59(t)
	_, err := svc.Update(context.Background(), 1, 99999, &UpdateAssistantRequest{})
	assert.Error(t, err)
}

func TestCaptainDelete_Cov59(t *testing.T) {
	svc, db := newCaptainAsstSvc59(t)
	acc := seedAccount59(t, db)
	assistant, _ := svc.Create(context.Background(), acc.ID, &CreateAssistantRequest{
		Name: "Delete", Description: "desc",
	})
	err := svc.Delete(context.Background(), acc.ID, assistant.ID)
	assert.NoError(t, err)
}

func TestCaptainDelete_NotFound_Cov59(t *testing.T) {
	svc, _ := newCaptainAsstSvc59(t)
	err := svc.Delete(context.Background(), 1, 99999)
	assert.Error(t, err)
}

func TestCaptainList_Cov59(t *testing.T) {
	svc, db := newCaptainAsstSvc59(t)
	acc := seedAccount59(t, db)
	_, err := svc.Create(context.Background(), acc.ID, &CreateAssistantRequest{Name: "A1", Description: "d"})
	require.NoError(t, err)
	_, err = svc.Create(context.Background(), acc.ID, &CreateAssistantRequest{Name: "A2", Description: "d"})
	require.NoError(t, err)
	list, total, err := svc.List(context.Background(), acc.ID, 0, 10)
	require.NoError(t, err)
	assert.Equal(t, int64(2), total)
	assert.Len(t, list, 2)
}

func TestCaptainList_Empty_Cov59(t *testing.T) {
	svc, _ := newCaptainAsstSvc59(t)
	list, total, err := svc.List(context.Background(), 99999, 0, 10)
	require.NoError(t, err)
	assert.Equal(t, int64(0), total)
	assert.Empty(t, list)
}

func TestCaptainStats_NotFound_Cov59(t *testing.T) {
	svc, _ := newCaptainAsstSvc59(t)
	_, err := svc.Stats(context.Background(), 1, 99999, "30", 0)
	assert.Error(t, err)
}

func TestCaptainSummary_NoLLM_Cov59(t *testing.T) {
	svc, db := newCaptainAsstSvc59(t)
	acc := seedAccount59(t, db)
	assistant, _ := svc.Create(context.Background(), acc.ID, &CreateAssistantRequest{
		Name: "Test", Description: "desc",
	})
	_, err := svc.Summary(context.Background(), acc.ID, assistant.ID, 1, "30", 0)
	assert.Error(t, err)
}

func TestCaptainCreateMessageReport_InvalidReason_Cov59(t *testing.T) {
	svc, _ := newCaptainAsstSvc59(t)
	_, err := svc.CreateMessageReport(context.Background(), 1, 1, 1, "invalid_reason", "desc")
	assert.Error(t, err)
}

func TestCaptainDrilldown_InvalidMetric_Cov59(t *testing.T) {
	svc, _ := newCaptainAsstSvc59(t)
	_, err := svc.Drilldown(context.Background(), 1, 1, CaptainDrilldownParams{Metric: "invalid"})
	assert.Error(t, err)
}

func TestCaptainDrilldown_NotFound_Cov59(t *testing.T) {
	svc, _ := newCaptainAsstSvc59(t)
	_, err := svc.Drilldown(context.Background(), 1, 99999, CaptainDrilldownParams{Metric: "conversations_handled"})
	assert.Error(t, err)
}

func TestCaptainStatsWindows_Default_Cov59(t *testing.T) {
	now := time.Now()
	since, until, prevSince, prevUntil := captainStatsWindows("invalid", 0, now)
	assert.False(t, since.IsZero())
	assert.False(t, until.IsZero())
	assert.False(t, prevSince.IsZero())
	assert.False(t, prevUntil.IsZero())
}

func TestCaptainStatsWindows_7Days_Cov59(t *testing.T) {
	now := time.Now()
	since, until, _, _ := captainStatsWindows("7", 0, now)
	assert.True(t, since.Before(until))
}

func TestCaptainStatsWindows_30Days_Cov59(t *testing.T) {
	now := time.Now()
	since, until, _, _ := captainStatsWindows("30", 0, now)
	assert.True(t, since.Before(until))
}

func TestCaptainStatsWindows_ThisMonth_Cov59(t *testing.T) {
	now := time.Now()
	since, until, _, _ := captainStatsWindows("this_month", 0, now)
	assert.True(t, since.Before(until) || since.Equal(until))
}

func TestCaptainStatsWindows_LastMonth_Cov59(t *testing.T) {
	now := time.Now()
	since, until, prevSince, prevUntil := captainStatsWindows("last_month", 0, now)
	assert.True(t, prevSince.Before(prevUntil))
	assert.True(t, until.Before(since.AddDate(0, 1, 0)))
}

func TestCaptainReportReasons_Cov59(t *testing.T) {
	assert.True(t, captainReportReasons["incorrect_information"])
	assert.True(t, captainReportReasons["other"])
	assert.False(t, captainReportReasons["invalid"])
}

// ============================================================
// ANALYTICS SERVICE TESTS (25 tests)
// ============================================================

func TestAnalyticsDB_Cov59(t *testing.T) {
	svc, _ := newAnalyticsSvc59(t)
	db, err := svc.analyticsDB()
	require.NoError(t, err)
	assert.NotNil(t, db)
}

func TestAnalyticsDB_Nil_Cov59(t *testing.T) {
	svc := &AnalyticsService{}
	_, err := svc.analyticsDB()
	assert.Error(t, err)
}

func TestAnalyticsParseReportDimensionID_Empty_Cov59(t *testing.T) {
	assert.Equal(t, uint(0), parseReportDimensionID(""))
}

func TestAnalyticsParseReportDimensionID_Valid_Cov59(t *testing.T) {
	assert.Equal(t, uint(42), parseReportDimensionID("42"))
}

func TestAnalyticsParseReportDimensionID_Invalid_Cov59(t *testing.T) {
	assert.Equal(t, uint(0), parseReportDimensionID("abc"))
}

func TestAnalyticsParseReportDimensionID_Whitespace_Cov59(t *testing.T) {
	assert.Equal(t, uint(0), parseReportDimensionID("  "))
}

func TestAnalyticsParseReportDimensionID_Zero_Cov59(t *testing.T) {
	assert.Equal(t, uint(0), parseReportDimensionID("0"))
}

func TestAnalyticsDayStart_Cov59(t *testing.T) {
	t1 := time.Date(2024, 3, 15, 14, 30, 0, 0, time.UTC)
	result := dayStart(t1)
	assert.Equal(t, 0, result.Hour())
	assert.Equal(t, 15, result.Day())
}

func TestAnalyticsBucketStart_Day_Cov59(t *testing.T) {
	t1 := time.Date(2024, 3, 15, 14, 30, 0, 0, time.UTC)
	result := bucketStart(t1, "day", time.UTC)
	assert.Equal(t, 0, result.Hour())
	assert.Equal(t, 15, result.Day())
}

func TestAnalyticsBucketStart_Hour_Cov59(t *testing.T) {
	t1 := time.Date(2024, 3, 15, 14, 30, 0, 0, time.UTC)
	result := bucketStart(t1, "hour", time.UTC)
	assert.Equal(t, 14, result.Hour())
	assert.Equal(t, 0, result.Minute())
}

func TestAnalyticsBucketStart_Week_Cov59(t *testing.T) {
	t1 := time.Date(2024, 3, 15, 14, 30, 0, 0, time.UTC) // Friday
	result := bucketStart(t1, "week", time.UTC)
	assert.Equal(t, 0, result.Hour())
	// Should be Sunday of that week
	assert.Equal(t, time.Sunday, result.Weekday())
}

func TestAnalyticsBucketStart_Month_Cov59(t *testing.T) {
	t1 := time.Date(2024, 3, 15, 14, 30, 0, 0, time.UTC)
	result := bucketStart(t1, "month", time.UTC)
	assert.Equal(t, 1, result.Day())
	assert.Equal(t, time.March, result.Month())
}

func TestAnalyticsBucketStart_Year_Cov59(t *testing.T) {
	t1 := time.Date(2024, 3, 15, 14, 30, 0, 0, time.UTC)
	result := bucketStart(t1, "year", time.UTC)
	assert.Equal(t, 1, result.Day())
	assert.Equal(t, time.January, result.Month())
}

func TestAnalyticsBucketStart_NilLoc_Cov59(t *testing.T) {
	t1 := time.Date(2024, 3, 15, 14, 30, 0, 0, time.UTC)
	result := bucketStart(t1, "day", nil)
	assert.Equal(t, 0, result.Hour())
}

func TestAnalyticsTimeseriesLocation_Cov59(t *testing.T) {
	loc := timeseriesLocation(5.5)
	assert.NotNil(t, loc)
}

func TestAnalyticsTimeseriesLocation_Zero_Cov59(t *testing.T) {
	loc := timeseriesLocation(0)
	assert.NotNil(t, loc)
}

func TestAnalyticsNextBucketStart_Day_Cov59(t *testing.T) {
	t1 := time.Date(2024, 3, 15, 0, 0, 0, 0, time.UTC)
	result := nextBucketStart(t1, "day")
	assert.Equal(t, 16, result.Day())
}

func TestAnalyticsNextBucketStart_Hour_Cov59(t *testing.T) {
	t1 := time.Date(2024, 3, 15, 14, 0, 0, 0, time.UTC)
	result := nextBucketStart(t1, "hour")
	assert.Equal(t, 15, result.Hour())
}

func TestAnalyticsNextBucketStart_Week_Cov59(t *testing.T) {
	t1 := time.Date(2024, 3, 15, 0, 0, 0, 0, time.UTC)
	result := nextBucketStart(t1, "week")
	assert.Equal(t, 22, result.Day()) // 7 days later
}

func TestAnalyticsNextBucketStart_Month_Cov59(t *testing.T) {
	t1 := time.Date(2024, 3, 1, 0, 0, 0, 0, time.UTC)
	result := nextBucketStart(t1, "month")
	assert.Equal(t, time.April, result.Month())
}

func TestAnalyticsNextBucketStart_Year_Cov59(t *testing.T) {
	t1 := time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC)
	result := nextBucketStart(t1, "year")
	assert.Equal(t, 2025, result.Year())
}

func TestAnalyticsSeedTimeseriesBuckets_Empty_Cov59(t *testing.T) {
	buckets := seedTimeseriesBuckets(time.Time{}, time.Time{}, "day", time.UTC)
	assert.Empty(t, buckets)
}

func TestAnalyticsSeedTimeseriesBuckets_Valid_Cov59(t *testing.T) {
	since := time.Date(2024, 3, 15, 0, 0, 0, 0, time.UTC)
	until := time.Date(2024, 3, 17, 0, 0, 0, 0, time.UTC)
	buckets := seedTimeseriesBuckets(since, until, "day", time.UTC)
	assert.Len(t, buckets, 2)
}

func TestAnalyticsEnsureTimeseriesBucket_Cov59(t *testing.T) {
	buckets := map[time.Time]*AnalyticsTimeseriesPoint{}
	bucket := time.Date(2024, 3, 15, 0, 0, 0, 0, time.UTC)
	point := ensureTimeseriesBucket(buckets, bucket)
	assert.NotNil(t, point)
	assert.Equal(t, bucket.Unix(), point.Timestamp)
	// Second call should return same point
	point2 := ensureTimeseriesBucket(buckets, bucket)
	assert.Same(t, point, point2)
}

func TestAnalyticsSortedTimeseries_Cov59(t *testing.T) {
	buckets := map[time.Time]*AnalyticsTimeseriesPoint{}
	t1 := time.Date(2024, 3, 16, 0, 0, 0, 0, time.UTC)
	t2 := time.Date(2024, 3, 15, 0, 0, 0, 0, time.UTC)
	ensureTimeseriesBucket(buckets, t1)
	ensureTimeseriesBucket(buckets, t2)
	result := sortedTimeseries(buckets)
	assert.Len(t, result, 2)
	assert.True(t, result[0].Timestamp < result[1].Timestamp)
}

func TestAnalyticsLiveConversationMetrics_Cov59(t *testing.T) {
	svc, db := newAnalyticsSvc59(t)
	acc := seedAccount59(t, db)
	inbox := seedInbox59(t, db, acc.ID, "api")
	contact := seedContact59(t, db, acc.ID)
	conv := seedConv59(t, db, acc.ID, inbox.ID, contact.ID)
	conv.Status = string(model.ConversationStatusOpen)
	require.NoError(t, db.Save(conv).Error)
	metrics, err := svc.liveConversationMetrics(context.Background(), acc.ID, 0)
	require.NoError(t, err)
	assert.Equal(t, int64(1), metrics.OpenCount)
}

func TestAnalyticsGroupedLiveConversationMetrics_Invalid_Cov59(t *testing.T) {
	svc, _ := newAnalyticsSvc59(t)
	_, err := svc.groupedLiveConversationMetrics(context.Background(), 1, "invalid", 0)
	assert.Error(t, err)
}

func TestAnalyticsGroupedLiveConversationMetrics_Valid_Cov59(t *testing.T) {
	svc, db := newAnalyticsSvc59(t)
	acc := seedAccount59(t, db)
	result, err := svc.groupedLiveConversationMetrics(context.Background(), acc.ID, "team_id", 0)
	require.NoError(t, err)
	assert.NotNil(t, result)
}

func TestAnalyticsGetTimeseries_UnsupportedMetric_Cov59(t *testing.T) {
	svc, _ := newAnalyticsSvc59(t)
	_, err := svc.GetTimeseries(context.Background(), 1, "unsupported", time.Now().Add(-24*time.Hour), time.Now(), "account", 0, "day", 0, false)
	assert.Error(t, err)
}

func TestAnalyticsApplyConversationDimension_Account_Cov59(t *testing.T) {
	_, db := newAnalyticsSvc59(t)
	q := db.Model(&model.Conversation{})
	result := applyConversationDimension(q, "account", 0)
	assert.NotNil(t, result)
}

func TestAnalyticsApplyConversationDimension_Inbox_Cov59(t *testing.T) {
	_, db := newAnalyticsSvc59(t)
	q := db.Model(&model.Conversation{})
	result := applyConversationDimension(q, "inbox", 5)
	assert.NotNil(t, result)
}

func TestAnalyticsApplyMessageDimension_Account_Cov59(t *testing.T) {
	_, db := newAnalyticsSvc59(t)
	q := db.Model(&model.Message{})
	result := applyMessageDimension(q, "account", 0)
	assert.NotNil(t, result)
}

func TestAnalyticsApplyEventDimension_Account_Cov59(t *testing.T) {
	_, db := newAnalyticsSvc59(t)
	q := db.Model(&model.ReportingEvent{})
	result := applyEventDimension(q, "account", 0)
	assert.NotNil(t, result)
}

func TestAnalyticsEnsureRollupsForRange_ZeroTimes_Cov59(t *testing.T) {
	svc, _ := newAnalyticsSvc59(t)
	err := svc.EnsureRollupsForRange(context.Background(), 1, time.Time{}, time.Time{})
	assert.NoError(t, err)
}

func TestAnalyticsBotSummaryCounts_Cov59(t *testing.T) {
	svc, db := newAnalyticsSvc59(t)
	acc := seedAccount59(t, db)
	result, err := svc.botSummaryCounts(context.Background(), acc.ID, time.Now().Add(-24*time.Hour), time.Now(), "account", 0)
	require.NoError(t, err)
	assert.NotNil(t, result)
	assert.Equal(t, int64(0), result.BotResolutionsCount)
}

func TestAnalyticsReportSummaryCounts_Cov59(t *testing.T) {
	svc, db := newAnalyticsSvc59(t)
	acc := seedAccount59(t, db)
	result, err := svc.reportSummaryCounts(context.Background(), acc.ID, time.Now().Add(-24*time.Hour), time.Now(), "account", 0, false)
	require.NoError(t, err)
	assert.NotNil(t, result)
	assert.Equal(t, int64(0), result.ConversationsCount)
}