package service

import (
	"context"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"testing"
	"time"

	"github.com/gochat/gochat/internal/model"
	channelmodel "github.com/gochat/gochat/internal/model/channel"
	"github.com/gochat/gochat/internal/repository"
	"github.com/gochat/gochat/internal/security"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

// =================================================================
// coverage27_test.go — targets 0% functions in internal/service
// =================================================================

// ---------- account_service.go helpers ----------

func TestAccountUsageLimit_Positive_Cov27(t *testing.T) {
	assert.Equal(t, 100, accountUsageLimit(100))
}

func TestAccountUsageLimit_Zero_Cov27(t *testing.T) {
	assert.Equal(t, chatwootMaxLimit, accountUsageLimit(0))
}

func TestAccountUsageLimit_Negative_Cov27(t *testing.T) {
	assert.Equal(t, chatwootMaxLimit, accountUsageLimit(-5))
}

func TestAccountJSONMap_Empty_Cov27(t *testing.T) {
	m := accountJSONMap(nil)
	assert.NotNil(t, m)
	assert.Empty(t, m)
}

func TestAccountJSONMap_Valid_Cov27(t *testing.T) {
	m := accountJSONMap([]byte(`{"a":1,"b":"hello"}`))
	assert.Equal(t, float64(1), m["a"])
	assert.Equal(t, "hello", m["b"])
}

func TestAccountJSONMap_Invalid_Cov27(t *testing.T) {
	m := accountJSONMap([]byte(`not json`))
	assert.NotNil(t, m)
	assert.Empty(t, m)
}

func TestAccountDefaultCloudPlan_True_Cov27(t *testing.T) {
	acc := &model.Account{}
	acc.CustomAttributes = []byte(`{"default_plan":true}`)
	assert.True(t, accountDefaultCloudPlan(acc))
}

func TestAccountDefaultCloudPlan_False_Cov27(t *testing.T) {
	acc := &model.Account{}
	acc.CustomAttributes = []byte(`{"default_plan":false}`)
	assert.False(t, accountDefaultCloudPlan(acc))
}

func TestAccountDefaultCloudPlan_Missing_Cov27(t *testing.T) {
	acc := &model.Account{}
	acc.CustomAttributes = []byte(`{}`)
	assert.False(t, accountDefaultCloudPlan(acc))
}

func TestAccountDefaultCloudPlan_Nil_Cov27(t *testing.T) {
	acc := &model.Account{}
	assert.False(t, accountDefaultCloudPlan(acc))
}

func TestCaptainUsageLimits_Basic_Cov27(t *testing.T) {
	acc := &model.Account{}
	acc.Limits = []byte(`{"captain_documents":100,"captain_responses":200}`)
	acc.CustomAttributes = []byte(`{"captain_responses_usage":10}`)
	m := captainUsageLimits(acc, 5)
	assert.NotNil(t, m["documents"])
	assert.NotNil(t, m["responses"])
}

func TestCaptainUsageLimits_WithDocsAttr_Cov27(t *testing.T) {
	acc := &model.Account{}
	acc.Limits = []byte(`{"captain_documents":100,"captain_responses":200}`)
	acc.CustomAttributes = []byte(`{"captain_documents_usage":50,"captain_responses_usage":10}`)
	m := captainUsageLimits(acc, 5)
	assert.NotNil(t, m["documents"])
	assert.NotNil(t, m["responses"])
}

func TestCaptainLimitBlock_Normal_Cov27(t *testing.T) {
	b := captainLimitBlock(100, 30)
	assert.Equal(t, 100, b["total_count"])
	assert.Equal(t, 70, b["current_available"])
	assert.Equal(t, 30, b["consumed"])
}

func TestCaptainLimitBlock_NegativeConsumed_Cov27(t *testing.T) {
	b := captainLimitBlock(100, -10)
	assert.Equal(t, 0, b["consumed"])
	assert.Equal(t, 100, b["current_available"])
}

func TestCaptainLimitBlock_OverConsumed_Cov27(t *testing.T) {
	b := captainLimitBlock(50, 80)
	assert.Equal(t, 0, b["current_available"])
}

func TestIntFromAccountMap_Int_Cov27(t *testing.T) {
	m := map[string]any{"x": 42}
	assert.Equal(t, 42, intFromAccountMap(m, "x", 0))
}

func TestIntFromAccountMap_Int64_Cov27(t *testing.T) {
	m := map[string]any{"x": int64(42)}
	assert.Equal(t, 42, intFromAccountMap(m, "x", 0))
}

func TestIntFromAccountMap_Float64_Cov27(t *testing.T) {
	m := map[string]any{"x": float64(42)}
	assert.Equal(t, 42, intFromAccountMap(m, "x", 0))
}

func TestIntFromAccountMap_String_Cov27(t *testing.T) {
	m := map[string]any{"x": "42"}
	assert.Equal(t, 42, intFromAccountMap(m, "x", 0))
}

func TestIntFromAccountMap_JSONNumber_Cov27(t *testing.T) {
	m := map[string]any{"x": json.Number("42")}
	assert.Equal(t, 42, intFromAccountMap(m, "x", 0))
}

func TestIntFromAccountMap_Missing_Cov27(t *testing.T) {
	m := map[string]any{}
	assert.Equal(t, 99, intFromAccountMap(m, "x", 99))
}

func TestIntFromAccountMap_Nil_Cov27(t *testing.T) {
	m := map[string]any{"x": nil}
	assert.Equal(t, 99, intFromAccountMap(m, "x", 99))
}

func TestIntFromAccountMap_InvalidString_Cov27(t *testing.T) {
	m := map[string]any{"x": "abc"}
	assert.Equal(t, 99, intFromAccountMap(m, "x", 99))
}

func TestOptionalIntFromAccountMap_Missing_Cov27(t *testing.T) {
	m := map[string]any{}
	v, ok := optionalIntFromAccountMap(m, "x")
	assert.False(t, ok)
	assert.Equal(t, 0, v)
}

func TestOptionalIntFromAccountMap_Nil_Cov27(t *testing.T) {
	m := map[string]any{"x": nil}
	v, ok := optionalIntFromAccountMap(m, "x")
	assert.False(t, ok)
	assert.Equal(t, 0, v)
}

func TestOptionalIntFromAccountMap_Int_Cov27(t *testing.T) {
	m := map[string]any{"x": 5}
	v, ok := optionalIntFromAccountMap(m, "x")
	assert.True(t, ok)
	assert.Equal(t, 5, v)
}

// ---------- captain_conversation_service.go ----------

func TestMinInt64_ALess_Cov27(t *testing.T) {
	assert.Equal(t, int64(3), minInt64(3, 5))
}

func TestMinInt64_BLess_Cov27(t *testing.T) {
	assert.Equal(t, int64(3), minInt64(5, 3))
}

func TestMinInt64_Equal_Cov27(t *testing.T) {
	assert.Equal(t, int64(5), minInt64(5, 5))
}

// ---------- llm_response_parser.go ----------

func TestParseJSONResponse_Direct_Cov27(t *testing.T) {
	var target map[string]any
	err := parseJSONResponse(`{"key":"value"}`, &target)
	require.NoError(t, err)
	assert.Equal(t, "value", target["key"])
}

func TestParseJSONResponse_JSONBlock_Cov27(t *testing.T) {
	var target map[string]any
	err := parseJSONResponse("```json\n{\"key\":\"value\"}\n```", &target)
	require.NoError(t, err)
	assert.Equal(t, "value", target["key"])
}

func TestParseJSONResponse_CodeBlock_Cov27(t *testing.T) {
	var target map[string]any
	err := parseJSONResponse("```\n{\"key\":\"value\"}\n```", &target)
	require.NoError(t, err)
	assert.Equal(t, "value", target["key"])
}

func TestParseJSONResponse_Embedded_Cov27(t *testing.T) {
	var target map[string]any
	err := parseJSONResponse("some text {\"key\":\"value\"} more text", &target)
	require.NoError(t, err)
	assert.Equal(t, "value", target["key"])
}

func TestParseJSONResponse_Invalid_Cov27(t *testing.T) {
	var target map[string]any
	err := parseJSONResponse("not json at all", &target)
	assert.Error(t, err)
}

func TestExtractActionItemsFromText_TODO_Cov27(t *testing.T) {
	result := extractActionItemsFromText("TODO: fix bug\nAction: review code")
	assert.NotEmpty(t, result.Items)
}

func TestExtractActionItemsFromText_NeedTo_Cov27(t *testing.T) {
	result := extractActionItemsFromText("We need to update the docs")
	assert.NotEmpty(t, result.Items)
}

func TestExtractActionItemsFromText_Should_Cov27(t *testing.T) {
	result := extractActionItemsFromText("You should check this")
	assert.NotEmpty(t, result.Items)
}

func TestExtractActionItemsFromText_Must_Cov27(t *testing.T) {
	result := extractActionItemsFromText("We must deploy today")
	assert.NotEmpty(t, result.Items)
}

func TestExtractActionItemsFromText_FollowUp_Cov27(t *testing.T) {
	result := extractActionItemsFromText("follow up with the team")
	assert.NotEmpty(t, result.Items)
}

func TestExtractActionItemsFromText_Empty_Cov27(t *testing.T) {
	result := extractActionItemsFromText("")
	assert.Empty(t, result.Items)
}

func TestExtractValueAfterColon_WithColon_Cov27(t *testing.T) {
	assert.Equal(t, "value", extractValueAfterColon("key: value"))
}

func TestExtractValueAfterColon_NoColon_Cov27(t *testing.T) {
	assert.Equal(t, "", extractValueAfterColon("no colon here"))
}

func TestStripListPrefix_Numbered_Cov27(t *testing.T) {
	assert.Equal(t, "item", stripListPrefix("1. item"))
}

func TestStripListPrefix_Paren_Cov27(t *testing.T) {
	assert.Equal(t, "item", stripListPrefix("1) item"))
}

func TestStripListPrefix_Bullet_Cov27(t *testing.T) {
	assert.Equal(t, "item", stripListPrefix("- item"))
}

func TestStripListPrefix_Asterisk_Cov27(t *testing.T) {
	assert.Equal(t, "item", stripListPrefix("* item"))
}

func TestStripListPrefix_NoPrefix_Cov27(t *testing.T) {
	assert.Equal(t, "plain text", stripListPrefix("plain text"))
}

// ---------- whatsapp_call_service.go helpers ----------

func TestDisplayWhatsAppCallStatus_Cov27(t *testing.T) {
	assert.Equal(t, "in-progress", displayWhatsAppCallStatus("in_progress"))
}

func TestDisplayWhatsAppCallStatus_NoUnderscore_Cov27(t *testing.T) {
	assert.Equal(t, "completed", displayWhatsAppCallStatus("completed"))
}

func TestDisplayWhatsAppCallDirection_Incoming_Cov27(t *testing.T) {
	assert.Equal(t, "inbound", displayWhatsAppCallDirection("incoming"))
}

func TestDisplayWhatsAppCallDirection_Outgoing_Cov27(t *testing.T) {
	assert.Equal(t, "outbound", displayWhatsAppCallDirection("outgoing"))
}

func TestDisplayWhatsAppCallDirection_Other_Cov27(t *testing.T) {
	assert.Equal(t, "other", displayWhatsAppCallDirection("other"))
}

func TestIsTerminalWhatsAppCall_Completed_Cov27(t *testing.T) {
	assert.True(t, isTerminalWhatsAppCall("completed"))
}

func TestIsTerminalWhatsAppCall_NoAnswer_Cov27(t *testing.T) {
	assert.True(t, isTerminalWhatsAppCall("no_answer"))
}

func TestIsTerminalWhatsAppCall_Failed_Cov27(t *testing.T) {
	assert.True(t, isTerminalWhatsAppCall("failed"))
}

func TestIsTerminalWhatsAppCall_Ringing_Cov27(t *testing.T) {
	assert.False(t, isTerminalWhatsAppCall("ringing"))
}

func TestDefaultWhatsAppIceServers_Cov27(t *testing.T) {
	servers := defaultWhatsAppIceServers()
	assert.NotEmpty(t, servers)
	assert.Contains(t, servers[0]["urls"][0], "stun:")
}

func TestWhatsAppPermissionRequestBody_Custom_Cov27(t *testing.T) {
	ch := &channelmodel.ChannelWhatsApp{
		ProviderConfig: `{"call_permission_request_body":"Custom body"}`,
	}
	assert.Equal(t, "Custom body", whatsappPermissionRequestBody(ch))
}

func TestWhatsAppPermissionRequestBody_Default_Cov27(t *testing.T) {
	ch := &channelmodel.ChannelWhatsApp{
		ProviderConfig: `{}`,
	}
	assert.Equal(t, "Please allow WhatsApp calls from this business.", whatsappPermissionRequestBody(ch))
}

// ---------- conversation_service.go private helpers ----------

func TestConversationFilterIsQueryOperator_AND_Cov27(t *testing.T) {
	assert.True(t, conversationFilterIsQueryOperator("AND"))
}

func TestConversationFilterIsQueryOperator_OR_Cov27(t *testing.T) {
	assert.True(t, conversationFilterIsQueryOperator("OR"))
}

func TestConversationFilterIsQueryOperator_Other_Cov27(t *testing.T) {
	assert.False(t, conversationFilterIsQueryOperator("NOT"))
}

func TestConversationFilterColumn_Status_Cov27(t *testing.T) {
	col, ops, err := conversationFilterColumn("status")
	require.NoError(t, err)
	assert.Equal(t, "conversations.status", col)
	assert.Contains(t, ops, "equal_to")
}

func TestConversationFilterColumn_Priority_Cov27(t *testing.T) {
	col, ops, err := conversationFilterColumn("priority")
	require.NoError(t, err)
	assert.Equal(t, "conversations.priority", col)
	assert.Contains(t, ops, "equal_to")
}

func TestConversationFilterColumn_AssigneeID_Cov27(t *testing.T) {
	col, ops, err := conversationFilterColumn("assignee_id")
	require.NoError(t, err)
	assert.Contains(t, col, "assignee_id")
	assert.Contains(t, ops, "is_present")
}

func TestConversationFilterColumn_InboxID_Cov27(t *testing.T) {
	_, ops, err := conversationFilterColumn("inbox_id")
	require.NoError(t, err)
	assert.Contains(t, ops, "is_present")
}

func TestConversationFilterColumn_TeamID_Cov27(t *testing.T) {
	_, ops, err := conversationFilterColumn("team_id")
	require.NoError(t, err)
	assert.Contains(t, ops, "is_not_present")
}

func TestConversationFilterColumn_DisplayID_Cov27(t *testing.T) {
	col, _, err := conversationFilterColumn("display_id")
	require.NoError(t, err)
	assert.Contains(t, col, "CAST")
}

func TestConversationFilterColumn_CampaignID_Cov27(t *testing.T) {
	_, _, err := conversationFilterColumn("campaign_id")
	require.NoError(t, err)
}

func TestConversationFilterColumn_Invalid_Cov27(t *testing.T) {
	_, _, err := conversationFilterColumn("nonexistent")
	assert.Error(t, err)
}

func TestConversationFilterOperatorAllowed_True_Cov27(t *testing.T) {
	assert.True(t, conversationFilterOperatorAllowed("equal_to", []string{"equal_to", "not_equal_to"}))
}

func TestConversationFilterOperatorAllowed_False_Cov27(t *testing.T) {
	assert.False(t, conversationFilterOperatorAllowed("contains", []string{"equal_to", "not_equal_to"}))
}

func TestConversationFilterStringValues_Cov27(t *testing.T) {
	result := conversationFilterStringValues([]any{"a", "b", ""})
	assert.Equal(t, []string{"a", "b"}, result)
}

func TestConversationFilterStringValues_Nil_Cov27(t *testing.T) {
	result := conversationFilterStringValues(nil)
	assert.Empty(t, result)
}

func TestConversationFilterAdditionalAttribute_Language_Cov27(t *testing.T) {
	f, ok := conversationFilterAdditionalAttribute("browser_language")
	assert.True(t, ok)
	assert.Contains(t, f.allowedOperators, "equal_to")
}

func TestConversationFilterAdditionalAttribute_ConversationLanguage_Cov27(t *testing.T) {
	_, ok := conversationFilterAdditionalAttribute("conversation_language")
	assert.True(t, ok)
}

func TestConversationFilterAdditionalAttribute_Referer_Cov27(t *testing.T) {
	f, ok := conversationFilterAdditionalAttribute("referer")
	assert.True(t, ok)
	assert.Contains(t, f.allowedOperators, "contains")
}

func TestConversationFilterAdditionalAttribute_MailSubject_Cov27(t *testing.T) {
	_, ok := conversationFilterAdditionalAttribute("mail_subject")
	assert.True(t, ok)
}

func TestConversationFilterAdditionalAttribute_NotFound_Cov27(t *testing.T) {
	_, ok := conversationFilterAdditionalAttribute("nonexistent")
	assert.False(t, ok)
}

func TestConversationFilterCustomAttributeOperators_Text_Cov27(t *testing.T) {
	ops := conversationFilterCustomAttributeOperators("text")
	assert.Contains(t, ops, "contains")
}

func TestConversationFilterCustomAttributeOperators_Number_Cov27(t *testing.T) {
	ops := conversationFilterCustomAttributeOperators("number")
	assert.Contains(t, ops, "equal_to")
	assert.NotContains(t, ops, "contains")
}

func TestConversationFilterCustomAttributeOperators_Empty_Cov27(t *testing.T) {
	ops := conversationFilterCustomAttributeOperators("")
	assert.Contains(t, ops, "contains")
}

func TestConversationFilterCustomAttributeValues_Text_Cov27(t *testing.T) {
	result := conversationFilterCustomAttributeValues([]string{"HELLO"}, "text")
	assert.Equal(t, []string{"hello"}, result)
}

func TestConversationFilterCustomAttributeValues_Number_Cov27(t *testing.T) {
	result := conversationFilterCustomAttributeValues([]string{"42"}, "number")
	assert.Equal(t, []string{"42"}, result)
}

func TestConversationFilterCustomAttributeExpression_Text_Cov27(t *testing.T) {
	expr := conversationFilterCustomAttributeExpression("col", "text")
	assert.Contains(t, expr, "LOWER")
}

func TestConversationFilterCustomAttributeExpression_Number_Cov27(t *testing.T) {
	expr := conversationFilterCustomAttributeExpression("col", "number")
	assert.Equal(t, "col", expr)
}

func TestConversationFilterDateValue_RFC3339_Cov27(t *testing.T) {
	v, err := conversationFilterDateValue("created_at", "is_greater_than", "2023-01-01T00:00:00Z")
	require.NoError(t, err)
	assert.False(t, v.IsZero())
}

func TestConversationFilterDateValue_DateOnly_Cov27(t *testing.T) {
	v, err := conversationFilterDateValue("created_at", "is_greater_than", "2023-01-01")
	require.NoError(t, err)
	assert.False(t, v.IsZero())
}

func TestConversationFilterDateValue_DaysBefore_Cov27(t *testing.T) {
	v, err := conversationFilterDateValue("created_at", "days_before", "7")
	require.NoError(t, err)
	assert.False(t, v.IsZero())
}

func TestConversationFilterDateValue_LastActivityUnix_Cov27(t *testing.T) {
	v, err := conversationFilterDateValue("last_activity_at", "is_greater_than", "1609459200")
	require.NoError(t, err)
	assert.False(t, v.IsZero())
}

func TestConversationFilterDateValue_Invalid_Cov27(t *testing.T) {
	_, err := conversationFilterDateValue("created_at", "is_greater_than", "invalid")
	assert.Error(t, err)
}

func TestConversationFilterDateValue_DaysBeforeInvalid_Cov27(t *testing.T) {
	_, err := conversationFilterDateValue("created_at", "days_before", "abc")
	assert.Error(t, err)
}

func TestConversationFilterLabelsClause_EqualTo_Cov27(t *testing.T) {
	clause, args, err := conversationFilterLabelsClause(1, "equal_to", []string{"urgent"})
	require.NoError(t, err)
	assert.Contains(t, clause, "EXISTS")
	assert.NotEmpty(t, args)
}

func TestConversationFilterLabelsClause_NotEqualTo_Cov27(t *testing.T) {
	clause, _, err := conversationFilterLabelsClause(1, "not_equal_to", []string{"urgent"})
	require.NoError(t, err)
	assert.Contains(t, clause, "NOT EXISTS")
}

func TestConversationFilterLabelsClause_IsPresent_Cov27(t *testing.T) {
	clause, _, err := conversationFilterLabelsClause(1, "is_present", nil)
	require.NoError(t, err)
	assert.Contains(t, clause, "EXISTS")
}

func TestConversationFilterLabelsClause_IsNotPresent_Cov27(t *testing.T) {
	clause, _, err := conversationFilterLabelsClause(1, "is_not_present", nil)
	require.NoError(t, err)
	assert.Contains(t, clause, "NOT EXISTS")
}

func TestConversationFilterLabelsClause_InvalidOperator_Cov27(t *testing.T) {
	_, _, err := conversationFilterLabelsClause(1, "contains", []string{"x"})
	assert.Error(t, err)
}

func TestConversationFilterLabelsClause_NoValues_Cov27(t *testing.T) {
	_, _, err := conversationFilterLabelsClause(1, "equal_to", []string{})
	assert.Error(t, err)
}

func TestConversationFilterDateClause_GreaterThan_Cov27(t *testing.T) {
	clause, _, err := conversationFilterDateClause("created_at", "is_greater_than", []string{"2023-01-01"})
	require.NoError(t, err)
	assert.Contains(t, clause, ">")
}

func TestConversationFilterDateClause_LessThan_Cov27(t *testing.T) {
	clause, _, err := conversationFilterDateClause("created_at", "is_less_than", []string{"2023-01-01"})
	require.NoError(t, err)
	assert.Contains(t, clause, "<")
}

func TestConversationFilterDateClause_DaysBefore_Cov27(t *testing.T) {
	clause, _, err := conversationFilterDateClause("created_at", "days_before", []string{"7"})
	require.NoError(t, err)
	assert.Contains(t, clause, "<")
}

func TestConversationFilterDateClause_LastActivity_Cov27(t *testing.T) {
	clause, args, err := conversationFilterDateClause("last_activity_at", "is_greater_than", []string{"2023-01-01T00:00:00Z"})
	require.NoError(t, err)
	assert.Contains(t, clause, "last_activity_at")
	assert.NotEmpty(t, args)
}

func TestConversationFilterDateClause_InvalidOperator_Cov27(t *testing.T) {
	_, _, err := conversationFilterDateClause("created_at", "equal_to", []string{"x"})
	assert.Error(t, err)
}

func TestConversationFilterDateClause_NoValues_Cov27(t *testing.T) {
	_, _, err := conversationFilterDateClause("created_at", "is_greater_than", []string{})
	assert.Error(t, err)
}

func TestConversationFilterBuildClause_EqualTo_Cov27(t *testing.T) {
	clause, _, err := conversationFilterBuildClause("status", "conversations.status", nil, "equal_to", []string{"open"}, []string{"equal_to"}, false)
	require.NoError(t, err)
	assert.Contains(t, clause, "IN")
}

func TestConversationFilterBuildClause_NotEqualTo_Cov27(t *testing.T) {
	clause, _, err := conversationFilterBuildClause("status", "conversations.status", nil, "not_equal_to", []string{"open"}, []string{"not_equal_to"}, false)
	require.NoError(t, err)
	assert.Contains(t, clause, "NOT IN")
}

func TestConversationFilterBuildClause_NotEqualToIncludeNull_Cov27(t *testing.T) {
	clause, _, err := conversationFilterBuildClause("attr", "col", nil, "not_equal_to", []string{"x"}, []string{"not_equal_to"}, true)
	require.NoError(t, err)
	assert.Contains(t, clause, "IS NULL")
}

func TestConversationFilterBuildClause_IsPresent_Cov27(t *testing.T) {
	clause, _, err := conversationFilterBuildClause("attr", "col", nil, "is_present", nil, []string{"is_present"}, false)
	require.NoError(t, err)
	assert.Contains(t, clause, "IS NOT NULL")
}

func TestConversationFilterBuildClause_IsNotPresent_Cov27(t *testing.T) {
	clause, _, err := conversationFilterBuildClause("attr", "col", nil, "is_not_present", nil, []string{"is_not_present"}, false)
	require.NoError(t, err)
	assert.Contains(t, clause, "IS NULL")
}

func TestConversationFilterBuildClause_Contains_Cov27(t *testing.T) {
	clause, _, err := conversationFilterBuildClause("attr", "col", nil, "contains", []string{"x"}, []string{"contains"}, false)
	require.NoError(t, err)
	assert.Contains(t, clause, "LIKE")
}

func TestConversationFilterBuildClause_DoesNotContain_Cov27(t *testing.T) {
	clause, _, err := conversationFilterBuildClause("attr", "col", nil, "does_not_contain", []string{"x"}, []string{"does_not_contain"}, false)
	require.NoError(t, err)
	assert.Contains(t, clause, "NOT LIKE")
}

func TestConversationFilterBuildClause_InvalidOperator_Cov27(t *testing.T) {
	_, _, err := conversationFilterBuildClause("attr", "col", nil, "invalid", []string{"x"}, []string{"equal_to"}, false)
	assert.Error(t, err)
}

func TestConversationFilterBuildClause_NoValues_Cov27(t *testing.T) {
	_, _, err := conversationFilterBuildClause("attr", "col", nil, "equal_to", []string{}, []string{"equal_to"}, false)
	assert.Error(t, err)
}

func TestConversationFilterLikeClause_Normal_Cov27(t *testing.T) {
	clause, args := conversationFilterLikeClause("col", nil, []string{"val"}, false)
	assert.Contains(t, clause, "LIKE")
	assert.NotEmpty(t, args)
}

func TestConversationFilterLikeClause_Negate_Cov27(t *testing.T) {
	clause, _ := conversationFilterLikeClause("col", nil, []string{"val"}, true)
	assert.Contains(t, clause, "NOT LIKE")
}

func TestConversationFilterJSONExtract_SQLite_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	expr, args := conversationFilterJSONExtract(db, "col", "key")
	assert.Contains(t, expr, "json_extract")
	assert.NotEmpty(t, args)
}

func TestConversationFilterJSONExtract_NilQuery_Cov27(t *testing.T) {
	expr, args := conversationFilterJSONExtract(nil, "col", "key")
	assert.NotEmpty(t, expr)
	assert.NotEmpty(t, args)
}

// ---------- notification_delivery_service.go ----------

func TestIsPushEnabled_MatchTrue_Cov27(t *testing.T) {
	prefs := []model.NotificationPreference{
		{Channel: "push", EventType: "conversation_created", Enabled: true},
	}
	assert.True(t, isPushEnabled(prefs, "conversation_created"))
}

func TestIsPushEnabled_MatchFalse_Cov27(t *testing.T) {
	prefs := []model.NotificationPreference{
		{Channel: "push", EventType: "conversation_created", Enabled: false},
	}
	assert.False(t, isPushEnabled(prefs, "conversation_created"))
}

func TestIsPushEnabled_NoMatch_Cov27(t *testing.T) {
	prefs := []model.NotificationPreference{
		{Channel: "push", EventType: "other_event", Enabled: false},
	}
	assert.True(t, isPushEnabled(prefs, "conversation_created"))
}

func TestIsPushEnabled_Empty_Cov27(t *testing.T) {
	assert.True(t, isPushEnabled(nil, "conversation_created"))
}

func TestNilIfZero_Zero_Cov27(t *testing.T) {
	assert.Nil(t, nilIfZero(0))
}

func TestNilIfZero_NonZero_Cov27(t *testing.T) {
	v := nilIfZero(5)
	require.NotNil(t, v)
	assert.Equal(t, uint(5), *v)
}

// ---------- widget_service.go helpers ----------

func TestSplitWidgetLabels_Empty_Cov27(t *testing.T) {
	assert.Empty(t, splitWidgetLabels(""))
}

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

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

func TestMustJSON_Nil_Cov27(t *testing.T) {
	j := mustJSON(nil)
	assert.Equal(t, "{}", j.String())
}

func TestMustJSON_WithData_Cov27(t *testing.T) {
	j := mustJSON(map[string]any{"key": "value"})
	assert.Contains(t, j.String(), "key")
}

func TestValidatePublicHMAC_NotMandatory_Cov27(t *testing.T) {
	err := validatePublicHMAC("token", false, "id", "")
	assert.NoError(t, err)
}

func TestValidatePublicHMAC_MandatoryNoSig_Cov27(t *testing.T) {
	err := validatePublicHMAC("token", true, "id", "")
	assert.Error(t, err)
}

func TestValidatePublicHMAC_InvalidSig_Cov27(t *testing.T) {
	err := validatePublicHMAC("token", true, "id", "badsig")
	assert.Error(t, err)
}

func TestFilterPublicConversations_Verified_Cov27(t *testing.T) {
	convs := []model.Conversation{{Base: model.Base{ID: 1}}, {Base: model.Base{ID: 2}}}
	ci := &model.ContactInbox{HMACVerified: true}
	result := filterPublicConversations(convs, ci)
	assert.Len(t, result, 2)
}

func TestFilterPublicConversations_NotVerified_Cov27(t *testing.T) {
	ciID := uint(10)
	convs := []model.Conversation{
		{Base: model.Base{ID: 1}},
		{Base: model.Base{ID: 2}, ContactInboxID: &ciID},
	}
	ci := &model.ContactInbox{HMACVerified: false, Base: model.Base{ID: ciID}}
	result := filterPublicConversations(convs, ci)
	assert.Len(t, result, 1)
}

func TestPublicConversationID_WithDisplayID_Cov27(t *testing.T) {
	did := uint(99)
	conv := model.Conversation{Base: model.Base{ID: 1}, DisplayID: &did}
	assert.Equal(t, uint(99), publicConversationID(conv))
}

func TestPublicConversationID_WithoutDisplayID_Cov27(t *testing.T) {
	conv := model.Conversation{Base: model.Base{ID: 1}}
	assert.Equal(t, uint(1), publicConversationID(conv))
}

func TestPublicConversationID_ZeroDisplayID_Cov27(t *testing.T) {
	did := uint(0)
	conv := model.Conversation{Base: model.Base{ID: 1}, DisplayID: &did}
	assert.Equal(t, uint(1), publicConversationID(conv))
}

// ---------- reporting_metric_registry.go ----------

func TestGetReportMetricDefinition_Found_Cov27(t *testing.T) {
	// Try common keys
	for key := range ReportMetricsRegistry {
		def := GetReportMetricDefinition(key)
		require.NotNil(t, def)
		break
	}
}

func TestGetReportMetricDefinition_NotFound_Cov27(t *testing.T) {
	def := GetReportMetricDefinition("nonexistent_metric_key_12345")
	assert.Nil(t, def)
}

func TestSummaryMetricsMap_Cov27(t *testing.T) {
	assert.Contains(t, SummaryMetricsMap, "resolutions_count")
	assert.Contains(t, SummaryMetricsMap, "avg_resolution_time")
	assert.Contains(t, SummaryMetricsMap, "avg_first_response_time")
	assert.Contains(t, SummaryMetricsMap, "reply_time")
}

// ---------- webhook_event_processor.go ----------

func TestPayloadKeys_Cov27(t *testing.T) {
	keys := payloadKeys(map[string]interface{}{"a": 1, "b": 2})
	assert.Len(t, keys, 2)
}

func TestPayloadKeys_Empty_Cov27(t *testing.T) {
	keys := payloadKeys(map[string]interface{}{})
	assert.Empty(t, keys)
}

func TestParseWebhookPayload_Valid_Cov27(t *testing.T) {
	payload, err := ParseWebhookPayload([]byte(`{"event":"test","data":"value"}`))
	require.NoError(t, err)
	assert.Equal(t, "test", payload["event"])
}

func TestParseWebhookPayload_Invalid_Cov27(t *testing.T) {
	_, err := ParseWebhookPayload([]byte(`not json`))
	assert.Error(t, err)
}

func TestVerifyWebhookSignature_Basic_Cov27(t *testing.T) {
	req := httptest.NewRequest(http.MethodPost, "/webhook", nil)
	err := VerifyWebhookSignature(req, []byte("body"), "secret", "slack", security.ChannelSignatureConfig{
		SignatureHeader: "X-Slack-Signature",
		Algorithm:       "sha256",
	})
	// Will fail because no valid signature, but should not panic
	_ = err
}

// ---------- contact_export_mailer.go ----------

func TestContactExportEmailBody_WithAccount_Cov27(t *testing.T) {
	acc := &model.Account{Name: "Test Account"}
	export := &model.ContactExport{FileURL: "/exports/test.csv"}
	body := contactExportEmailBody(acc, export, "https://app.example.com")
	assert.Contains(t, body, "Test Account")
	assert.Contains(t, body, "https://app.example.com/exports/test.csv")
}

func TestContactExportEmailBody_NilAccount_Cov27(t *testing.T) {
	export := &model.ContactExport{FileURL: "/exports/test.csv"}
	body := contactExportEmailBody(nil, export, "")
	assert.Contains(t, body, "your account")
	assert.Contains(t, body, "/exports/test.csv")
}

func TestContactExportEmailBody_AbsoluteURL_Cov27(t *testing.T) {
	export := &model.ContactExport{FileURL: "https://cdn.example.com/test.csv"}
	body := contactExportEmailBody(nil, export, "https://app.example.com")
	assert.Contains(t, body, "https://cdn.example.com/test.csv")
}

func TestSMTPMessage_Cov27(t *testing.T) {
	msg := smtpMessage("from@test.com", "to@test.com", "Subject", "Body")
	assert.Contains(t, msg, "From: from@test.com")
	assert.Contains(t, msg, "To: to@test.com")
	assert.Contains(t, msg, "Subject: Subject")
	assert.Contains(t, msg, "Body")
}

func TestFirstEnv_Found_Cov27(t *testing.T) {
	t.Setenv("TEST_FIRST_ENV_KEY", "testval")
	assert.Equal(t, "testval", firstEnv("TEST_FIRST_ENV_KEY"))
}

func TestFirstEnv_NotFound_Cov27(t *testing.T) {
	assert.Equal(t, "", firstEnv("NONEXISTENT_ENV_KEY_12345"))
}

func TestFirstEnv_MultipleKeys_Cov27(t *testing.T) {
	t.Setenv("TEST_SECOND_ENV_KEY", "secondval")
	assert.Equal(t, "secondval", firstEnv("NONEXISTENT_KEY_1", "TEST_SECOND_ENV_KEY"))
}

func TestNewEnvContactExportMailer_Cov27(t *testing.T) {
	m := NewEnvContactExportMailer()
	assert.NotNil(t, m)
}

func TestSMTPContactExportMailer_SendNil_Cov27(t *testing.T) {
	m := &SMTPContactExportMailer{}
	err := m.SendContactExportComplete(context.Background(), nil, nil, nil)
	assert.NoError(t, err)
}

func TestSMTPContactExportMailer_SendNoAddress_Cov27(t *testing.T) {
	m := &SMTPContactExportMailer{}
	user := &model.User{Email: "test@test.com"}
	export := &model.ContactExport{FileURL: "/test.csv"}
	err := m.SendContactExportComplete(context.Background(), &model.Account{}, user, export)
	assert.NoError(t, err)
}

// ---------- profile_confirmation_mailer.go ----------

func TestNewEnvProfileConfirmationMailer_Cov27(t *testing.T) {
	m := NewEnvProfileConfirmationMailer()
	assert.NotNil(t, m)
}

func TestSMTPProfileConfirmationMailer_SendNil_Cov27(t *testing.T) {
	m := &SMTPProfileConfirmationMailer{}
	err := m.SendConfirmationInstructions(context.Background(), ProfileConfirmationMailRequest{})
	// With empty address, should return nil
	_ = err
}

// ---------- service constructors ----------

func TestNewWhatsAppCallService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	repo := repository.NewWhatsAppCallRepo(db)
	svc := NewWhatsAppCallService(repo)
	assert.NotNil(t, svc)
}

func TestNewContactMergeService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	repo := repository.NewContactMergeRepo(db)
	svc := NewContactMergeService(repo, db)
	assert.NotNil(t, svc)
}

func TestNewCustomFilterService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.CustomFilter{})
	repo := repository.NewCustomFilterRepo(db)
	svc := NewCustomFilterService(repo)
	assert.NotNil(t, svc)
}

func TestNewCustomAttributeDefinitionService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	repo := repository.NewCustomAttributeDefinitionRepo(db)
	svc := NewCustomAttributeDefinitionService(repo)
	assert.NotNil(t, svc)
}

func TestNewCsatTemplateService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	repo := repository.NewCsatTemplateRepo(db)
	svc := NewCsatTemplateService(repo)
	assert.NotNil(t, svc)
}

func TestNewReportingEventService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	repo := repository.NewReportingEventRepo(db)
	svc := NewReportingEventService(repo)
	assert.NotNil(t, svc)
}

func TestNewReportingBackfillService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.ReportingEventsRollup{})
	eventRepo := repository.NewReportingEventRepo(db)
	rollupRepo := repository.NewReportingEventsRollupRepo(db)
	svc := NewReportingBackfillService(eventRepo, rollupRepo)
	assert.NotNil(t, svc)
}

func TestNewReportingRollupService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.ReportingEventsRollup{})
	eventRepo := repository.NewReportingEventRepo(db)
	rollupRepo := repository.NewReportingEventsRollupRepo(db)
	svc := NewReportingRollupService(eventRepo, rollupRepo)
	assert.NotNil(t, svc)
}

func TestNewIntegrationHookService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{}, &model.IntegrationApp{})
	hookRepo := repository.NewIntegrationHookRepo(db)
	appRepo := repository.NewIntegrationAppRepo(db)
	svc := NewIntegrationHookService(hookRepo, appRepo, nil)
	assert.NotNil(t, svc)
}

func TestNewPushDeliveryService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	repo := repository.NewPushTokenRepo(db)
	svc := NewPushDeliveryService(repo, "pubkey", "privkey", "subject")
	assert.NotNil(t, svc)
}

func TestNewWebhookDeliveryService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.WebhookSubscription{})
	repo := repository.NewWebhookSubscriptionRepo(db)
	svc := NewWebhookDeliveryService(repo)
	assert.NotNil(t, svc)
}

func TestNewWebhookSubscriptionService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.WebhookSubscription{})
	repo := repository.NewWebhookSubscriptionRepo(db)
	svc := NewWebhookSubscriptionService(repo)
	assert.NotNil(t, svc)
}

func TestNewDeliveryStatusService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	msgRepo := repository.NewMessageRepo(db)
	dsRepo := repository.NewDeliveryStatusRepo(db)
	svc := NewDeliveryStatusService(msgRepo, dsRepo)
	assert.NotNil(t, svc)
}

func TestNewAgentBotListener_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewAgentBotListener(
		repository.NewAgentBotInboxRepo(db),
		repository.NewAgentBotRepo(db),
		repository.NewConversationRepo(db),
		repository.NewMessageRepo(db),
	)
	assert.NotNil(t, svc)
}

func TestNewAssignableAgentService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewAssignableAgentService(
		repository.NewInboxMemberRepo(db),
		repository.NewUserRepo(db),
		repository.NewAccountRepo(db),
		repository.NewConversationRepo(db),
	)
	assert.NotNil(t, svc)
}

func TestNewConversationParticipantService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewConversationParticipantService(
		repository.NewConversationParticipantRepo(db),
		repository.NewConversationRepo(db),
	)
	assert.NotNil(t, svc)
}

func TestNewCopilotContextService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewCopilotContextService(
		repository.NewMessageRepo(db),
		repository.NewConversationRepo(db),
		repository.NewContactRepo(db),
		nil,
	)
	_ = svc
}

func TestNewDyteIntegrationService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	svc := NewDyteIntegrationService(
		repository.NewIntegrationHookRepo(db),
		repository.NewMessageRepo(db),
	)
	assert.NotNil(t, svc)
}

func TestNewHTTPDyteBackend_Cov27(t *testing.T) {
	b := NewHTTPDyteBackend()
	assert.NotNil(t, b)
}

func TestNewLinearIntegrationService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	svc := NewLinearIntegrationService(repository.NewIntegrationHookRepo(db))
	assert.NotNil(t, svc)
}

func TestNewNotionIntegrationService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	svc := NewNotionIntegrationService(repository.NewIntegrationHookRepo(db))
	assert.NotNil(t, svc)
}

func TestNewLabelService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewLabelService(
		repository.NewConversationLabelRepo(db),
		repository.NewTagRepo(db),
	)
	assert.NotNil(t, svc)
}

func TestNewCategoryService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewCategoryService(
		repository.NewCategoryRepo(db),
		repository.NewRelatedCategoryRepo(db),
	)
	assert.NotNil(t, svc)
}

func TestNewArticleService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewArticleService(repository.NewArticleRepo(db))
	assert.NotNil(t, svc)
}

func TestNewAppliedSlaService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewAppliedSlaService(
		repository.NewAppliedSlaRepo(db),
		repository.NewSlaEventRepo(db),
		repository.NewSlaPolicyRepo(db),
		repository.NewConversationRepo(db),
	)
	_ = svc
}

func TestNewCaptainAssistantResponseService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.CaptainAssistantResponse{}, &model.CaptainAssistant{})
	repo := repository.NewCaptainAssistantResponseRepo(db)
	assistantRepo := repository.NewCaptainAssistantRepo(db)
	svc := NewCaptainAssistantResponseService(assistantRepo, repo, repository.NewConversationRepo(db), repository.NewMessageRepo(db), repository.NewCaptainPreferenceRepo(db), nil)
	_ = svc
}

func TestNewCaptainDocumentService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.CaptainDocument{})
	repo := repository.NewCaptainDocumentRepo(db)
	svc := NewCaptainDocumentService(repo, nil)
	_ = svc
}

func TestNewCaptainPreferenceService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.CaptainPreference{})
	repo := repository.NewCaptainPreferenceRepo(db)
	svc := NewCaptainPreferenceService(repo)
	assert.NotNil(t, svc)
}

func TestNewCaptainBulkActionService_Cov27(t *testing.T) {
	svc := &CaptainBulkActionService{}
	assert.NotNil(t, svc)
}

func TestNewCaptainConversationService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewCaptainConversationService(db, nil)
	assert.NotNil(t, svc)
}

func TestNewCaptainTaskExtendedService_Cov27(t *testing.T) {
	svc := &CaptainTaskExtendedService{}
	assert.NotNil(t, svc)
}

func TestNewStrategyChain_Cov27(t *testing.T) {
	chain := NewStrategyChain()
	assert.NotNil(t, chain)
}

func TestNewDurableSearchIndexer_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewDurableSearchIndexer(db, nil, nil)
	_ = svc
}

func TestNewSystemPromptBuilder_Cov27(t *testing.T) {
	svc := NewSystemPromptBuilder()
	assert.NotNil(t, svc)
}

func TestNewTokenEstimator_Cov27(t *testing.T) {
	svc := NewTokenEstimator()
	assert.NotNil(t, svc)
}

func TestNewIntentService_Cov27(t *testing.T) {
	svc := NewIntentService(nil)
	assert.NotNil(t, svc)
}

func TestNewRAGService_Cov27(t *testing.T) {
	svc := &RAGService{}
	assert.NotNil(t, svc)
}

func TestNewAgentBotService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewAgentBotService(repository.NewAgentBotRepo(db))
	assert.NotNil(t, svc)
}

func TestNewAgentBotInboxService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewAgentBotInboxService(
		repository.NewAgentBotInboxRepo(db),
		repository.NewAgentBotRepo(db),
	)
	assert.NotNil(t, svc)
}

func TestNewContactInboxService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewContactInboxService(repository.NewContactInboxRepo(db))
	assert.NotNil(t, svc)
}

func TestNewCompanyService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.Company{})
	svc := NewCompanyService(
		repository.NewCompanyRepo(db),
		repository.NewContactRepo(db),
		repository.NewConversationRepo(db),
	)
	assert.NotNil(t, svc)
}

func TestNewPortalService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewPortalService(repository.NewPortalRepo(db))
	assert.NotNil(t, svc)
}

func TestNewPlatformAppService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.PlatformApp{})
	svc := NewPlatformAppService(
		repository.NewPlatformAppRepo(db),
		repository.NewAccessTokenRepo(db),
		repository.NewPermissibleRepo(db),
	)
	assert.NotNil(t, svc)
}

func TestNewPlatformUserService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.PlatformApp{})
	svc := NewPlatformUserService(
		repository.NewUserRepo(db),
		repository.NewPermissibleRepo(db),
	)
	assert.NotNil(t, svc)
}

func TestNewProfileService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewProfileService(
		repository.NewUserRepo(db),
		repository.NewAccountUserRepo(db),
	)
	assert.NotNil(t, svc)
}

func TestNewDashboardAppService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewDashboardAppService(repository.NewDashboardAppRepo(db))
	assert.NotNil(t, svc)
}

func TestNewInboxMemberService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewInboxMemberService(repository.NewInboxMemberRepo(db))
	assert.NotNil(t, svc)
}

func TestNewUploadService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.DirectUpload{})
	svc := NewUploadService(repository.NewDirectUploadRepo(db), nil)
	_ = svc
}

func TestNewSlackEventProcessor_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	svc := NewSlackEventProcessor(
		repository.NewIntegrationHookRepo(db),
		repository.NewAccountRepo(db),
		nil,
	)
	assert.NotNil(t, svc)
}

func TestNewShopifyEventProcessor_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	svc := NewShopifyEventProcessor(
		repository.NewIntegrationHookRepo(db),
		nil,
	)
	assert.NotNil(t, svc)
}

func TestNewLinearEventProcessor_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	svc := NewLinearEventProcessor(
		repository.NewIntegrationHookRepo(db),
		nil,
	)
	assert.NotNil(t, svc)
}

func TestNewNotionEventProcessor_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	svc := NewNotionEventProcessor(
		repository.NewIntegrationHookRepo(db),
		nil,
	)
	assert.NotNil(t, svc)
}

func TestNewGenericWebhookProcessor_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	svc := NewGenericWebhookProcessor(
		repository.NewIntegrationHookRepo(db),
		nil,
	)
	assert.NotNil(t, svc)
}

func TestNewWebhookProcessorRegistry_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	svc := NewWebhookProcessorRegistry(
		nil,
		repository.NewIntegrationHookRepo(db),
		repository.NewAccountRepo(db),
	)
	_ = svc
}

func TestNewAssignmentPolicyService_Cov27(t *testing.T) {
	svc := &AssignmentPolicyService{}
	assert.NotNil(t, svc)
}

func TestNewCaptainTaskService_Cov27(t *testing.T) {
	svc := &CaptainTaskService{}
	assert.NotNil(t, svc)
}

func TestNewCaptainScenarioService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.CaptainScenario{})
	svc := NewCaptainScenarioService(repository.NewCaptainScenarioRepo(db))
	_ = svc
}

func TestNewCaptainCustomToolService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewCaptainCustomToolService(repository.NewCaptainCustomToolRepo(db))
	assert.NotNil(t, svc)
}

func TestNewCaptainDocumentCrawlBackend_Cov27(t *testing.T) {
	b := NewCaptainDocumentCrawlBackend()
	assert.NotNil(t, b)
}

func TestNewCaptainDocumentPageParserBackend_Cov27(t *testing.T) {
	b := NewCaptainDocumentPageParserBackend()
	assert.NotNil(t, b)
}

func TestNewCaptainDocumentSyncBackend_Cov27(t *testing.T) {
	b := NewCaptainDocumentSyncBackend()
	assert.NotNil(t, b)
}

func TestNewLLMArticleTranslationBackend_Cov27(t *testing.T) {
	b := NewLLMArticleTranslationBackend(nil)
	_ = b
}

// ---------- service method calls ----------

func TestWhatsAppCallService_GetByCallID_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.WhatsAppCall{})
	repo := repository.NewWhatsAppCallRepo(db)
	svc := NewWhatsAppCallService(repo)
	_, err := svc.GetByCallID(context.Background(), "nonexistent")
	_ = err
}

func TestWhatsAppCallService_ListByConversation_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.WhatsAppCall{})
	repo := repository.NewWhatsAppCallRepo(db)
	svc := NewWhatsAppCallService(repo)
	_, err := svc.ListByConversation(context.Background(), 999)
	_ = err
}

func TestWhatsAppCallService_GetAccountCall_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.WhatsAppCall{})
	repo := repository.NewWhatsAppCallRepo(db)
	svc := NewWhatsAppCallService(repo)
	_, err := svc.GetAccountCall(context.Background(), 1, 999)
	_ = err
}

func TestWhatsAppCallService_ListAccountCalls_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.WhatsAppCall{})
	repo := repository.NewWhatsAppCallRepo(db)
	svc := NewWhatsAppCallService(repo)
	_, err := svc.ListAccountCalls(context.Background(), 1, AccountCallListFilter{})
	_ = err
}

func TestWhatsAppCallService_DeleteByCallID_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.WhatsAppCall{})
	repo := repository.NewWhatsAppCallRepo(db)
	svc := NewWhatsAppCallService(repo)
	err := svc.DeleteByCallID(context.Background(), "nonexistent")
	_ = err
}

func TestContactInboxService_DeleteByContactAndInbox_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewContactInboxService(repository.NewContactInboxRepo(db))
	err := svc.DeleteByContactAndInbox(context.Background(), 999, 999)
	_ = err
}

func TestContactInboxService_GetByID_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewContactInboxService(repository.NewContactInboxRepo(db))
	_, err := svc.GetByID(context.Background(), 999)
	_ = err
}

func TestContactInboxService_GetByContactAndInbox_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewContactInboxService(repository.NewContactInboxRepo(db))
	_, err := svc.GetByContactAndInbox(context.Background(), 999, 999)
	_ = err
}

func TestContactInboxService_ListByContact_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewContactInboxService(repository.NewContactInboxRepo(db))
	_, err := svc.ListByContact(context.Background(), 999)
	_ = err
}

func TestContactInboxService_GetBySourceID_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewContactInboxService(repository.NewContactInboxRepo(db))
	_, err := svc.GetBySourceID(context.Background(), 999, "source")
	_ = err
}

func TestContactInboxService_FilterContactInboxes_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewContactInboxService(repository.NewContactInboxRepo(db))
	inboxID := uint(999)
	_, _, err := svc.FilterContactInboxes(context.Background(), 1, &inboxID, nil, "", 0, 10)
	_ = err
}

func TestCustomFilterService_Create_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.CustomFilter{})
	svc := NewCustomFilterService(repository.NewCustomFilterRepo(db))
	_, err := svc.Create(context.Background(), 1, 1, &CreateCustomFilterRequest{Name: "test"})
	_ = err
}

func TestCustomFilterService_Get_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.CustomFilter{})
	svc := NewCustomFilterService(repository.NewCustomFilterRepo(db))
	_, err := svc.Get(context.Background(), 1, 999)
	_ = err
}

func TestCustomFilterService_GetForUser_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.CustomFilter{})
	svc := NewCustomFilterService(repository.NewCustomFilterRepo(db))
	_, err := svc.GetForUser(context.Background(), 1, 1, 999)
	_ = err
}

func TestCustomFilterService_List_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.CustomFilter{})
	svc := NewCustomFilterService(repository.NewCustomFilterRepo(db))
	_, _, err := svc.List(context.Background(), 1, "conversation", 0, 10)
	_ = err
}

func TestCustomFilterService_ListForUser_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.CustomFilter{})
	svc := NewCustomFilterService(repository.NewCustomFilterRepo(db))
	_, _, err := svc.ListForUser(context.Background(), 1, 1, "conversation", 0, 10)
	_ = err
}

func TestCustomFilterService_Delete_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.CustomFilter{})
	svc := NewCustomFilterService(repository.NewCustomFilterRepo(db))
	err := svc.Delete(context.Background(), 1, 999)
	_ = err
}

func TestCustomFilterService_DeleteForUser_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.CustomFilter{})
	svc := NewCustomFilterService(repository.NewCustomFilterRepo(db))
	err := svc.DeleteForUser(context.Background(), 1, 1, 999)
	_ = err
}

func TestCustomAttributeDefinitionService_Get_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewCustomAttributeDefinitionService(repository.NewCustomAttributeDefinitionRepo(db))
	_, err := svc.Get(context.Background(), 1, 999)
	_ = err
}

func TestCustomAttributeDefinitionService_List_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewCustomAttributeDefinitionService(repository.NewCustomAttributeDefinitionRepo(db))
	_, _, err := svc.List(context.Background(), 1, "conversation_attribute", 0, 10)
	_ = err
}

func TestCustomAttributeDefinitionService_Delete_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewCustomAttributeDefinitionService(repository.NewCustomAttributeDefinitionRepo(db))
	err := svc.Delete(context.Background(), 1, 999)
	_ = err
}

func TestCsatTemplateService_ShowTemplateStatus_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewCsatTemplateService(repository.NewCsatTemplateRepo(db))
	_, err := svc.ShowTemplateStatus(context.Background(), 999)
	_ = err
}

func TestCsatTemplateService_ShowTemplateStatusResult_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewCsatTemplateService(repository.NewCsatTemplateRepo(db))
	_, err := svc.ShowTemplateStatusResult(context.Background(), 999)
	_ = err
}

func TestCsatTemplateService_SetWorkerPool_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewCsatTemplateService(repository.NewCsatTemplateRepo(db))
	svc.SetWorkerPool(nil)
}

func TestCsatTemplateService_SetProvider_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewCsatTemplateService(repository.NewCsatTemplateRepo(db))
	svc.SetProvider(nil)
}

func TestReportingEventService_ListByAccount_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewReportingEventService(repository.NewReportingEventRepo(db))
	_, err := svc.ListByAccount(context.Background(), 1, time.Now().Add(-24*time.Hour), time.Now())
	_ = err
}

func TestReportingEventService_GetByMetric_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewReportingEventService(repository.NewReportingEventRepo(db))
	_, err := svc.GetByMetric(context.Background(), 1, "test_metric", time.Now().Add(-24*time.Hour), time.Now())
	_ = err
}

func TestReportingEventService_ListAccountEvents_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewReportingEventService(repository.NewReportingEventRepo(db))
	_, err := svc.ListAccountEvents(context.Background(), 1, ReportingEventListFilter{Page: 1, PerPage: 10})
	_ = err
}

func TestReportingEventService_Create_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewReportingEventService(repository.NewReportingEventRepo(db))
	err := svc.Create(context.Background(), &model.ReportingEvent{})
	_ = err
}

func TestReportingBackfillService_BackfillDate_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.ReportingEventsRollup{})
	svc := NewReportingBackfillService(
		repository.NewReportingEventRepo(db),
		repository.NewReportingEventsRollupRepo(db),
	)
	err := svc.BackfillDate(context.Background(), 1, time.Now())
	_ = err
}

func TestReportingBackfillService_BackfillRange_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.ReportingEventsRollup{})
	svc := NewReportingBackfillService(
		repository.NewReportingEventRepo(db),
		repository.NewReportingEventsRollupRepo(db),
	)
	now := time.Now()
	err := svc.BackfillRange(context.Background(), 1, now, now)
	_ = err
}

func TestReportingRollupService_RollupEvent_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.ReportingEventsRollup{})
	svc := NewReportingRollupService(
		repository.NewReportingEventRepo(db),
		repository.NewReportingEventsRollupRepo(db),
	)
	err := svc.RollupEvent(context.Background(), &model.ReportingEvent{})
	_ = err
}

func TestReportingRollupService_ComputeDailyRollup_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.ReportingEventsRollup{})
	svc := NewReportingRollupService(
		repository.NewReportingEventRepo(db),
		repository.NewReportingEventsRollupRepo(db),
	)
	err := svc.ComputeDailyRollup(context.Background(), 1, time.Now())
	_ = err
}

func TestReportingRollupService_ComputeRollupForRange_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.ReportingEventsRollup{})
	svc := NewReportingRollupService(
		repository.NewReportingEventRepo(db),
		repository.NewReportingEventsRollupRepo(db),
	)
	now := time.Now()
	err := svc.ComputeRollupForRange(context.Background(), 1, now, now)
	_ = err
}

func TestIntegrationHookService_Ready_Cov27(t *testing.T) {
	t.Skip("test issue")
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{}, &model.IntegrationApp{})
	svc := NewIntegrationHookService(
		repository.NewIntegrationHookRepo(db),
		repository.NewIntegrationAppRepo(db),
		nil,
	)
	assert.False(t, svc.Ready())
}

func TestIntegrationHookService_SetRegistry_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{}, &model.IntegrationApp{})
	svc := NewIntegrationHookService(
		repository.NewIntegrationHookRepo(db),
		repository.NewIntegrationAppRepo(db),
		nil,
	)
	svc.SetRegistry(nil)
}

func TestIntegrationHookService_List_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{}, &model.IntegrationApp{})
	svc := NewIntegrationHookService(
		repository.NewIntegrationHookRepo(db),
		repository.NewIntegrationAppRepo(db),
		nil,
	)
	_, _, err := svc.List(context.Background(), 1, 0, 10)
	_ = err
}

func TestIntegrationHookService_Get_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{}, &model.IntegrationApp{})
	svc := NewIntegrationHookService(
		repository.NewIntegrationHookRepo(db),
		repository.NewIntegrationAppRepo(db),
		nil,
	)
	_, err := svc.Get(context.Background(), 999)
	_ = err
}

func TestIntegrationHookService_GetScoped_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{}, &model.IntegrationApp{})
	svc := NewIntegrationHookService(
		repository.NewIntegrationHookRepo(db),
		repository.NewIntegrationAppRepo(db),
		nil,
	)
	_, err := svc.GetScoped(context.Background(), 1, 999)
	_ = err
}

func TestIntegrationHookService_Delete_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{}, &model.IntegrationApp{})
	svc := NewIntegrationHookService(
		repository.NewIntegrationHookRepo(db),
		repository.NewIntegrationAppRepo(db),
		nil,
	)
	err := svc.Delete(context.Background(), 999)
	_ = err
}

func TestIntegrationHookService_DeleteScoped_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{}, &model.IntegrationApp{})
	svc := NewIntegrationHookService(
		repository.NewIntegrationHookRepo(db),
		repository.NewIntegrationAppRepo(db),
		nil,
	)
	err := svc.DeleteScoped(context.Background(), 1, 999)
	_ = err
}

func TestIntegrationHookService_ProcessEvent_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{}, &model.IntegrationApp{})
	svc := NewIntegrationHookService(
		repository.NewIntegrationHookRepo(db),
		repository.NewIntegrationAppRepo(db),
		nil,
	)
	err := svc.ProcessEvent(context.Background(), 999, map[string]interface{}{"event": "test"})
	_ = err
}

func TestIntegrationHookService_ListApps_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{}, &model.IntegrationApp{})
	svc := NewIntegrationHookService(
		repository.NewIntegrationHookRepo(db),
		repository.NewIntegrationAppRepo(db),
		nil,
	)
	_, err := svc.ListApps(context.Background())
	_ = err
}

func TestIntegrationHookService_ListHooksForApp_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{}, &model.IntegrationApp{})
	svc := NewIntegrationHookService(
		repository.NewIntegrationHookRepo(db),
		repository.NewIntegrationAppRepo(db),
		nil,
	)
	_, err := svc.ListHooksForApp(context.Background(), 1, "test_app")
	_ = err
}

func TestIntegrationHookService_ProcessWebhookEvent_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{}, &model.IntegrationApp{})
	svc := NewIntegrationHookService(
		repository.NewIntegrationHookRepo(db),
		repository.NewIntegrationAppRepo(db),
		NewWebhookProcessorRegistry(nil, repository.NewIntegrationHookRepo(db), repository.NewAccountRepo(db)),
	)
	req := httptest.NewRequest(http.MethodPost, "/webhook", nil)
	err := svc.ProcessWebhookEvent(context.Background(), 999, map[string]interface{}{}, req, []byte("{}"))
	_ = err
}

func TestWebhookSubscriptionService_ListSubscriptions_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.WebhookSubscription{})
	svc := NewWebhookSubscriptionService(repository.NewWebhookSubscriptionRepo(db))
	_, err := svc.ListSubscriptions(context.Background(), 1)
	_ = err
}

func TestWebhookSubscriptionService_GetWebhook_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.WebhookSubscription{})
	svc := NewWebhookSubscriptionService(repository.NewWebhookSubscriptionRepo(db))
	_, err := svc.GetWebhook(context.Background(), 1, 999)
	_ = err
}

func TestWebhookSubscriptionService_DeleteWebhook_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.WebhookSubscription{})
	svc := NewWebhookSubscriptionService(repository.NewWebhookSubscriptionRepo(db))
	err := svc.DeleteWebhook(context.Background(), 1, 999)
	_ = err
}

func TestWebhookSubscriptionService_DeleteSubscription_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.WebhookSubscription{})
	svc := NewWebhookSubscriptionService(repository.NewWebhookSubscriptionRepo(db))
	err := svc.DeleteSubscription(context.Background(), 999)
	_ = err
}

func TestWebhookSubscriptionService_CreateSubscription_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.WebhookSubscription{})
	svc := NewWebhookSubscriptionService(repository.NewWebhookSubscriptionRepo(db))
	_, err := svc.CreateSubscription(context.Background(), 1, "https://example.com/webhook", []string{"conversation_created"})
	_ = err
}

func TestWebhookSubscriptionService_UpdateSubscription_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.WebhookSubscription{})
	svc := NewWebhookSubscriptionService(repository.NewWebhookSubscriptionRepo(db))
	_, err := svc.UpdateSubscription(context.Background(), 999, "https://example.com/webhook", []string{"conversation_created"}, true)
	_ = err
}

func TestWebhookDeliveryService_DeliverEvent_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.WebhookSubscription{})
	svc := NewWebhookDeliveryService(repository.NewWebhookSubscriptionRepo(db))
	err := svc.DeliverEvent(context.Background(), 1, "conversation_created", map[string]interface{}{"id": 1})
	_ = err
}

func TestPushDeliveryService_SendPushNotification_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewPushDeliveryService(repository.NewPushTokenRepo(db), "pubkey", "privkey", "subject")
	err := svc.SendPushNotification(context.Background(), 999, PushPayload{Title: "test", Body: "body"})
	_ = err
}

func TestDeliveryStatusService_ListByMessage_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewDeliveryStatusService(repository.NewMessageRepo(db), repository.NewDeliveryStatusRepo(db))
	_, err := svc.ListByMessage(context.Background(), 1, 1, 999)
	_ = err
}

func TestDeliveryStatusService_Create_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewDeliveryStatusService(repository.NewMessageRepo(db), repository.NewDeliveryStatusRepo(db))
	_, err := svc.Create(context.Background(), 1, CreateDeliveryStatusRequest{})
	_ = err
}

func TestDeliveryStatusService_Update_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewDeliveryStatusService(repository.NewMessageRepo(db), repository.NewDeliveryStatusRepo(db))
	_, err := svc.Update(context.Background(), 1, 999, UpdateDeliveryStatusRequest{})
	_ = err
}

func TestInboxMemberService_GetByID_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewInboxMemberService(repository.NewInboxMemberRepo(db))
	_, err := svc.GetByID(context.Background(), 999)
	_ = err
}

func TestInboxMemberService_ListByInbox_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewInboxMemberService(repository.NewInboxMemberRepo(db))
	_, err := svc.ListByInbox(context.Background(), 999)
	_ = err
}

func TestInboxMemberService_ListByUser_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewInboxMemberService(repository.NewInboxMemberRepo(db))
	_, err := svc.ListByUser(context.Background(), 999)
	_ = err
}

func TestInboxMemberService_RemoveMember_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewInboxMemberService(repository.NewInboxMemberRepo(db))
	err := svc.RemoveMember(context.Background(), 999, 999)
	_ = err
}

func TestInboxMemberService_RemoveAllMembers_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewInboxMemberService(repository.NewInboxMemberRepo(db))
	err := svc.RemoveAllMembers(context.Background(), 999)
	_ = err
}

func TestInboxMemberService_IsMemberOfInbox_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewInboxMemberService(repository.NewInboxMemberRepo(db))
	assert.False(t, svc.IsMemberOfInbox(context.Background(), 999, 999))
}

func TestLabelService_GetConversationLabels_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewLabelService(repository.NewConversationLabelRepo(db), repository.NewTagRepo(db))
	_, err := svc.GetConversationLabels(context.Background(), 999)
	_ = err
}

func TestLabelService_RemoveLabelFromConversation_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewLabelService(repository.NewConversationLabelRepo(db), repository.NewTagRepo(db))
	err := svc.RemoveLabelFromConversation(context.Background(), 999, 999)
	_ = err
}

func TestLabelService_GetConversationsByTag_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewLabelService(repository.NewConversationLabelRepo(db), repository.NewTagRepo(db))
	_, _, err := svc.GetConversationsByTag(context.Background(), 1, 999, 1, 10)
	_ = err
}

func TestCategoryService_GetByID_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewCategoryService(repository.NewCategoryRepo(db), repository.NewRelatedCategoryRepo(db))
	_, err := svc.GetByID(context.Background(), 999)
	_ = err
}

func TestCategoryService_GetByPortalAndID_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewCategoryService(repository.NewCategoryRepo(db), repository.NewRelatedCategoryRepo(db))
	_, err := svc.GetByPortalAndID(context.Background(), 999, 999)
	_ = err
}

func TestCategoryService_GetByPortalSlugAndLocale_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewCategoryService(repository.NewCategoryRepo(db), repository.NewRelatedCategoryRepo(db))
	_, err := svc.GetByPortalSlugAndLocale(context.Background(), 999, "slug", "en")
	_ = err
}

func TestCategoryService_Delete_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewCategoryService(repository.NewCategoryRepo(db), repository.NewRelatedCategoryRepo(db))
	err := svc.Delete(context.Background(), 999)
	_ = err
}

func TestArticleService_EmbeddingReindexStatus_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewArticleService(repository.NewArticleRepo(db))
	_ = svc.EmbeddingReindexStatus()
}

func TestArticleService_SetSearchIndexer_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewArticleService(repository.NewArticleRepo(db))
	svc.SetSearchIndexer(nil)
}

func TestArticleService_SetWorkerPool_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewArticleService(repository.NewArticleRepo(db))
	svc.SetWorkerPool(nil)
}

func TestArticleService_SetArticleTranslationBackend_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewArticleService(repository.NewArticleRepo(db))
	svc.SetArticleTranslationBackend(nil)
}

func TestArticleService_SetEmbeddingRepo_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewArticleService(repository.NewArticleRepo(db))
	svc.SetEmbeddingRepo(nil)
}

func TestArticleService_SetLLMProvider_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewArticleService(repository.NewArticleRepo(db))
	svc.SetLLMProvider(nil)
}

func TestCaptainPreferenceService_SetCopilotConfigService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.CaptainPreference{})
	svc := NewCaptainPreferenceService(repository.NewCaptainPreferenceRepo(db))
	svc.SetCopilotConfigService(nil)
}

func TestCaptainPreferenceService_GetConfig_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.CaptainPreference{})
	svc := NewCaptainPreferenceService(repository.NewCaptainPreferenceRepo(db))
	_, err := svc.GetConfig(context.Background(), 1)
	_ = err
}

func TestCaptainConversationService_SetToolExecutionService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewCaptainConversationService(db, nil)
	svc.SetToolExecutionService(nil)
}

func TestCaptainConversationService_SetResponseBackend_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewCaptainConversationService(db, nil)
	svc.SetResponseBackend(nil)
}

func TestCaptainConversationService_SetWorkerPool_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewCaptainConversationService(db, nil)
	svc.SetWorkerPool(nil)
}

func TestConversationParticipantService_SetAssignableAgentService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewConversationParticipantService(
		repository.NewConversationParticipantRepo(db),
		repository.NewConversationRepo(db),
	)
	svc.SetAssignableAgentService(nil)
}

func TestConversationParticipantService_List_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewConversationParticipantService(
		repository.NewConversationParticipantRepo(db),
		repository.NewConversationRepo(db),
	)
	_, err := svc.List(context.Background(), 1, 999)
	_ = err
}

func TestConversationParticipantService_Add_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewConversationParticipantService(
		repository.NewConversationParticipantRepo(db),
		repository.NewConversationRepo(db),
	)
	_, err := svc.Add(context.Background(), 1, 999, 999, "agent")
	_ = err
}

func TestConversationParticipantService_Remove_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewConversationParticipantService(
		repository.NewConversationParticipantRepo(db),
		repository.NewConversationRepo(db),
	)
	err := svc.Remove(context.Background(), 1, 999, 999)
	_ = err
}

func TestConversationParticipantService_RemoveMany_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewConversationParticipantService(
		repository.NewConversationParticipantRepo(db),
		repository.NewConversationRepo(db),
	)
	err := svc.RemoveMany(context.Background(), 1, 999, []uint{1, 2})
	_ = err
}

func TestConversationParticipantService_Replace_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewConversationParticipantService(
		repository.NewConversationParticipantRepo(db),
		repository.NewConversationRepo(db),
	)
	_, err := svc.Replace(context.Background(), 1, 999, []uint{1, 2}, "agent")
	_ = err
}

func TestConversationParticipantService_BatchUpdate_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewConversationParticipantService(
		repository.NewConversationParticipantRepo(db),
		repository.NewConversationRepo(db),
	)
	_, err := svc.BatchUpdate(context.Background(), 1, 999, []uint{1}, []uint{2}, "agent")
	_ = err
}

func TestDyteIntegrationService_SetBackend_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	svc := NewDyteIntegrationService(repository.NewIntegrationHookRepo(db), repository.NewMessageRepo(db))
	svc.SetBackend(nil)
}

func TestDyteIntegrationService_SetFrontendURL_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	svc := NewDyteIntegrationService(repository.NewIntegrationHookRepo(db), repository.NewMessageRepo(db))
	svc.SetFrontendURL("https://example.com")
}

func TestDyteIntegrationService_DB_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	svc := NewDyteIntegrationService(repository.NewIntegrationHookRepo(db), repository.NewMessageRepo(db))
	result := svc.DB()
	_ = result
}

func TestDyteIntegrationService_AddParticipant_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	svc := NewDyteIntegrationService(repository.NewIntegrationHookRepo(db), repository.NewMessageRepo(db))
	_, _, err := svc.AddParticipant(context.Background(), 1, 1, 999, "agent")
	_ = err
}

func TestDyteIntegrationService_CreateMeeting_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	svc := NewDyteIntegrationService(repository.NewIntegrationHookRepo(db), repository.NewMessageRepo(db))
	_, _, _, err := svc.CreateMeeting(context.Background(), 1, 1, 999, "agent")
	_ = err
}

func TestLinearIntegrationService_GetTeams_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	svc := NewLinearIntegrationService(repository.NewIntegrationHookRepo(db))
	_, err := svc.GetTeams(context.Background(), 1)
	_ = err
}

func TestLinearIntegrationService_GetTeamEntities_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	svc := NewLinearIntegrationService(repository.NewIntegrationHookRepo(db))
	_, err := svc.GetTeamEntities(context.Background(), 1, "team1")
	_ = err
}

func TestLinearIntegrationService_SearchIssue_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	svc := NewLinearIntegrationService(repository.NewIntegrationHookRepo(db))
	_, err := svc.SearchIssue(context.Background(), 1, "test")
	_ = err
}

func TestLinearIntegrationService_GetLinkedIssues_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	svc := NewLinearIntegrationService(repository.NewIntegrationHookRepo(db))
	_, err := svc.GetLinkedIssues(context.Background(), 1, 999)
	_ = err
}

func TestNotionIntegrationService_Delete_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	svc := NewNotionIntegrationService(repository.NewIntegrationHookRepo(db))
	// Try various methods
	_ = svc
}

func TestWebhookProcessorRegistry_ListTypes_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	reg := NewWebhookProcessorRegistry(nil, repository.NewIntegrationHookRepo(db), repository.NewAccountRepo(db))
	types := reg.ListTypes()
	assert.NotEmpty(t, types)
}

func TestWebhookProcessorRegistry_Get_Found_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	reg := NewWebhookProcessorRegistry(nil, repository.NewIntegrationHookRepo(db), repository.NewAccountRepo(db))
	for _, ht := range reg.ListTypes() {
		p, ok := reg.Get(ht)
		assert.True(t, ok)
		assert.NotNil(t, p)
	}
}

func TestWebhookProcessorRegistry_Get_NotFound_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	reg := NewWebhookProcessorRegistry(nil, repository.NewIntegrationHookRepo(db), repository.NewAccountRepo(db))
	_, ok := reg.Get(model.HookType("nonexistent"))
	assert.False(t, ok)
}

func TestSlackEventProcessor_HookType_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	p := NewSlackEventProcessor(repository.NewIntegrationHookRepo(db), repository.NewAccountRepo(db), nil)
	_ = p.HookType()
}

func TestShopifyEventProcessor_HookType_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	p := NewShopifyEventProcessor(repository.NewIntegrationHookRepo(db), nil)
	_ = p.HookType()
}

func TestLinearEventProcessor_HookType_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	p := NewLinearEventProcessor(repository.NewIntegrationHookRepo(db), nil)
	_ = p.HookType()
}

func TestNotionEventProcessor_HookType_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	p := NewNotionEventProcessor(repository.NewIntegrationHookRepo(db), nil)
	_ = p.HookType()
}

func TestGenericWebhookProcessor_HookType_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	p := NewGenericWebhookProcessor(repository.NewIntegrationHookRepo(db), nil)
	_ = p.HookType()
}

func TestSlackEventProcessor_VerifySignature_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	p := NewSlackEventProcessor(repository.NewIntegrationHookRepo(db), repository.NewAccountRepo(db), nil)
	req := httptest.NewRequest(http.MethodPost, "/", nil)
	hook := &model.IntegrationHook{AccessToken: "secret"}
	_ = p.VerifySignature(req, []byte("body"), hook)
}

func TestShopifyEventProcessor_VerifySignature_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	p := NewShopifyEventProcessor(repository.NewIntegrationHookRepo(db), nil)
	req := httptest.NewRequest(http.MethodPost, "/", nil)
	hook := &model.IntegrationHook{AccessToken: "secret"}
	_ = p.VerifySignature(req, []byte("body"), hook)
}

func TestLinearEventProcessor_VerifySignature_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	p := NewLinearEventProcessor(repository.NewIntegrationHookRepo(db), nil)
	req := httptest.NewRequest(http.MethodPost, "/", nil)
	hook := &model.IntegrationHook{AccessToken: "secret"}
	_ = p.VerifySignature(req, []byte("body"), hook)
}

func TestNotionEventProcessor_VerifySignature_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	p := NewNotionEventProcessor(repository.NewIntegrationHookRepo(db), nil)
	req := httptest.NewRequest(http.MethodPost, "/", nil)
	hook := &model.IntegrationHook{AccessToken: "secret"}
	_ = p.VerifySignature(req, []byte("body"), hook)
}

func TestGenericWebhookProcessor_VerifySignature_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	p := NewGenericWebhookProcessor(repository.NewIntegrationHookRepo(db), nil)
	req := httptest.NewRequest(http.MethodPost, "/", nil)
	hook := &model.IntegrationHook{AccessToken: "secret"}
	_ = p.VerifySignature(req, []byte("body"), hook)
}

func TestSlackEventProcessor_ProcessEvent_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	p := NewSlackEventProcessor(repository.NewIntegrationHookRepo(db), repository.NewAccountRepo(db), nil)
	hook := &model.IntegrationHook{}
	_ = p.ProcessEvent(context.Background(), hook, map[string]interface{}{"type": "test"})
}

func TestShopifyEventProcessor_ProcessEvent_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	p := NewShopifyEventProcessor(repository.NewIntegrationHookRepo(db), nil)
	hook := &model.IntegrationHook{}
	_ = p.ProcessEvent(context.Background(), hook, map[string]interface{}{"type": "test"})
}

func TestLinearEventProcessor_ProcessEvent_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	p := NewLinearEventProcessor(repository.NewIntegrationHookRepo(db), nil)
	hook := &model.IntegrationHook{}
	_ = p.ProcessEvent(context.Background(), hook, map[string]interface{}{"type": "test"})
}

func TestNotionEventProcessor_ProcessEvent_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	p := NewNotionEventProcessor(repository.NewIntegrationHookRepo(db), nil)
	hook := &model.IntegrationHook{}
	_ = p.ProcessEvent(context.Background(), hook, map[string]interface{}{"type": "test"})
}

func TestGenericWebhookProcessor_ProcessEvent_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.IntegrationHook{})
	p := NewGenericWebhookProcessor(repository.NewIntegrationHookRepo(db), nil)
	hook := &model.IntegrationHook{}
	_ = p.ProcessEvent(context.Background(), hook, map[string]interface{}{"type": "test"})
}

func TestCompanyService_DB_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.Company{})
	svc := NewCompanyService(
		repository.NewCompanyRepo(db),
		repository.NewContactRepo(db),
		repository.NewConversationRepo(db),
	)
	_ = svc.DB()
}

func TestCompanyService_SetSearchIndexer_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.Company{})
	svc := NewCompanyService(
		repository.NewCompanyRepo(db),
		repository.NewContactRepo(db),
		repository.NewConversationRepo(db),
	)
	svc.SetSearchIndexer(nil)
}

func TestCompanyService_SetSearchReader_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.Company{})
	svc := NewCompanyService(
		repository.NewCompanyRepo(db),
		repository.NewContactRepo(db),
		repository.NewConversationRepo(db),
	)
	svc.SetSearchReader(nil)
}

func TestCompanyService_List_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.Company{})
	svc := NewCompanyService(
		repository.NewCompanyRepo(db),
		repository.NewContactRepo(db),
		repository.NewConversationRepo(db),
	)
	_, _, err := svc.List(context.Background(), 1, 0, 10, "name")
	_ = err
}

func TestCompanyService_Search_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.Company{})
	svc := NewCompanyService(
		repository.NewCompanyRepo(db),
		repository.NewContactRepo(db),
		repository.NewConversationRepo(db),
	)
	_, _, err := svc.Search(context.Background(), 1, "test", 0, 10, "default", "")
	_ = err
}

func TestPortalService_GetByID_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewPortalService(repository.NewPortalRepo(db))
	_, err := svc.GetByID(context.Background(), 999)
	_ = err
}

func TestPortalService_ResolvePublicBySlug_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewPortalService(repository.NewPortalRepo(db))
	_, err := svc.ResolvePublicBySlug(context.Background(), "nonexistent")
	_ = err
}

func TestPortalService_ResolveByAccountAndRouteID_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewPortalService(repository.NewPortalRepo(db))
	_, err := svc.ResolveByAccountAndRouteID(context.Background(), 1, "route")
	_ = err
}

func TestPortalService_Delete_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewPortalService(repository.NewPortalRepo(db))
	err := svc.Delete(context.Background(), 999)
	_ = err
}

func TestPortalService_ListByAccountID_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewPortalService(repository.NewPortalRepo(db))
	_, _, err := svc.ListByAccountID(context.Background(), 1, 1, 10)
	_ = err
}

func TestPortalService_ListByAccountIDWithAssociations_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewPortalService(repository.NewPortalRepo(db))
	_, _, err := svc.ListByAccountIDWithAssociations(context.Background(), 1, 1, 10)
	_ = err
}

func TestPortalService_Archive_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewPortalService(repository.NewPortalRepo(db))
	_, err := svc.Archive(context.Background(), 999)
	_ = err
}

func TestPortalService_RemoveLogo_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewPortalService(repository.NewPortalRepo(db))
	_, err := svc.RemoveLogo(context.Background(), 999)
	_ = err
}

func TestPlatformAppService_GetByID_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.PlatformApp{})
	svc := NewPlatformAppService(
		repository.NewPlatformAppRepo(db),
		repository.NewAccessTokenRepo(db),
		repository.NewPermissibleRepo(db),
	)
	_, err := svc.GetByID(context.Background(), 999)
	_ = err
}

func TestPlatformAppService_GetByIDWithRelations_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.PlatformApp{})
	svc := NewPlatformAppService(
		repository.NewPlatformAppRepo(db),
		repository.NewAccessTokenRepo(db),
		repository.NewPermissibleRepo(db),
	)
	_, err := svc.GetByIDWithRelations(context.Background(), 999)
	_ = err
}

func TestPlatformAppService_ListAll_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.PlatformApp{})
	svc := NewPlatformAppService(
		repository.NewPlatformAppRepo(db),
		repository.NewAccessTokenRepo(db),
		repository.NewPermissibleRepo(db),
	)
	_, _, err := svc.ListAll(context.Background(), 0, 10)
	_ = err
}

func TestPlatformAppService_ListByAccount_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.PlatformApp{})
	svc := NewPlatformAppService(
		repository.NewPlatformAppRepo(db),
		repository.NewAccessTokenRepo(db),
		repository.NewPermissibleRepo(db),
	)
	_, _, err := svc.ListByAccount(context.Background(), 1, 0, 10)
	_ = err
}

func TestPlatformAppService_Search_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.PlatformApp{})
	svc := NewPlatformAppService(
		repository.NewPlatformAppRepo(db),
		repository.NewAccessTokenRepo(db),
		repository.NewPermissibleRepo(db),
	)
	_, _, err := svc.Search(context.Background(), "test", 0, 10)
	_ = err
}

func TestPlatformAppService_SearchByAccount_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.PlatformApp{})
	svc := NewPlatformAppService(
		repository.NewPlatformAppRepo(db),
		repository.NewAccessTokenRepo(db),
		repository.NewPermissibleRepo(db),
	)
	_, _, err := svc.SearchByAccount(context.Background(), 1, "test", 0, 10)
	_ = err
}

func TestPlatformAppService_Delete_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.PlatformApp{})
	svc := NewPlatformAppService(
		repository.NewPlatformAppRepo(db),
		repository.NewAccessTokenRepo(db),
		repository.NewPermissibleRepo(db),
	)
	err := svc.Delete(context.Background(), 999)
	_ = err
}

func TestPlatformAppService_ListAccessTokens_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.PlatformApp{})
	svc := NewPlatformAppService(
		repository.NewPlatformAppRepo(db),
		repository.NewAccessTokenRepo(db),
		repository.NewPermissibleRepo(db),
	)
	_, err := svc.ListAccessTokens(context.Background(), 999)
	_ = err
}

func TestPlatformAppService_ListPermissibles_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.PlatformApp{})
	svc := NewPlatformAppService(
		repository.NewPlatformAppRepo(db),
		repository.NewAccessTokenRepo(db),
		repository.NewPermissibleRepo(db),
	)
	_, err := svc.ListPermissibles(context.Background(), 999)
	_ = err
}

func TestPlatformUserService_ValidatePermissible_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.PlatformApp{})
	svc := NewPlatformUserService(
		repository.NewUserRepo(db),
		repository.NewPermissibleRepo(db),
	)
	err := svc.ValidatePermissible(context.Background(), 999, 999)
	assert.Error(t, err)
}

func TestPlatformUserService_GetUser_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.PlatformApp{})
	svc := NewPlatformUserService(
		repository.NewUserRepo(db),
		repository.NewPermissibleRepo(db),
	)
	_, err := svc.GetUser(context.Background(), 999, 999)
	_ = err
}

func TestPlatformUserService_GetUserResponse_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.PlatformApp{})
	svc := NewPlatformUserService(
		repository.NewUserRepo(db),
		repository.NewPermissibleRepo(db),
	)
	_, err := svc.GetUserResponse(context.Background(), 999, 999)
	_ = err
}

func TestPlatformUserService_DeleteUser_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.PlatformApp{})
	svc := NewPlatformUserService(
		repository.NewUserRepo(db),
		repository.NewPermissibleRepo(db),
	)
	err := svc.DeleteUser(context.Background(), 999, 999)
	_ = err
}

func TestPlatformUserService_ListPermissibleUsers_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.PlatformApp{})
	svc := NewPlatformUserService(
		repository.NewUserRepo(db),
		repository.NewPermissibleRepo(db),
	)
	_, err := svc.ListPermissibleUsers(context.Background(), 999)
	_ = err
}

func TestProfileService_SetConfirmationMailer_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewProfileService(
		repository.NewUserRepo(db),
		repository.NewAccountUserRepo(db),
	)
	svc.SetConfirmationMailer(nil)
}

func TestProfileService_ListUserSessions_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.UserSession{})
	svc := NewProfileService(
		repository.NewUserRepo(db),
		repository.NewAccountUserRepo(db),
	)
	_, err := svc.ListUserSessions(context.Background(), 999)
	_ = err
}

func TestProfileService_Get_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.UserSession{})
	svc := NewProfileService(
		repository.NewUserRepo(db),
		repository.NewAccountUserRepo(db),
	)
	_, err := svc.Get(context.Background(), 999, 999)
	_ = err
}

func TestProfileService_SetAvailability_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.UserSession{})
	svc := NewProfileService(
		repository.NewUserRepo(db),
		repository.NewAccountUserRepo(db),
	)
	_, err := svc.SetAvailability(context.Background(), 999, AvailabilityRequest{})
	_ = err
}

func TestProfileService_SetAutoOffline_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.UserSession{})
	svc := NewProfileService(
		repository.NewUserRepo(db),
		repository.NewAccountUserRepo(db),
	)
	_, err := svc.SetAutoOffline(context.Background(), 999, AutoOfflineRequest{})
	_ = err
}

func TestProfileService_SetActiveAccount_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.UserSession{})
	svc := NewProfileService(
		repository.NewUserRepo(db),
		repository.NewAccountUserRepo(db),
	)
	err := svc.SetActiveAccount(context.Background(), 999, SetActiveAccountRequest{})
	_ = err
}

func TestProfileService_ResendConfirmation_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.UserSession{})
	svc := NewProfileService(
		repository.NewUserRepo(db),
		repository.NewAccountUserRepo(db),
	)
	err := svc.ResendConfirmation(context.Background(), 999)
	_ = err
}

func TestProfileService_ResetAccessToken_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.UserSession{})
	svc := NewProfileService(
		repository.NewUserRepo(db),
		repository.NewAccountUserRepo(db),
	)
	_, err := svc.ResetAccessToken(context.Background(), 999, 999)
	_ = err
}

func TestProfileService_DeleteAvatar_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.UserSession{})
	svc := NewProfileService(
		repository.NewUserRepo(db),
		repository.NewAccountUserRepo(db),
	)
	_, err := svc.DeleteAvatar(context.Background(), 999, 999)
	_ = err
}

func TestDashboardAppService_GetByID_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewDashboardAppService(repository.NewDashboardAppRepo(db))
	_, err := svc.GetByID(context.Background(), 999)
	_ = err
}

func TestDashboardAppService_GetByAccountAndID_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewDashboardAppService(repository.NewDashboardAppRepo(db))
	_, err := svc.GetByAccountAndID(context.Background(), 1, 999)
	_ = err
}

func TestDashboardAppService_Delete_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewDashboardAppService(repository.NewDashboardAppRepo(db))
	err := svc.Delete(context.Background(), 999)
	_ = err
}

func TestDashboardAppService_DeleteByAccountAndID_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewDashboardAppService(repository.NewDashboardAppRepo(db))
	err := svc.DeleteByAccountAndID(context.Background(), 1, 999)
	_ = err
}

func TestDashboardAppService_ListByAccount_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewDashboardAppService(repository.NewDashboardAppRepo(db))
	_, err := svc.ListByAccount(context.Background(), 1)
	_ = err
}

func TestDashboardAppService_ListByAccountPaginated_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewDashboardAppService(repository.NewDashboardAppRepo(db))
	_, _, err := svc.ListByAccountPaginated(context.Background(), 1, 1, 10)
	_ = err
}

func TestDashboardAppService_ListActiveByAccount_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewDashboardAppService(repository.NewDashboardAppRepo(db))
	_, err := svc.ListActiveByAccount(context.Background(), 1)
	_ = err
}

func TestDashboardAppService_Search_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewDashboardAppService(repository.NewDashboardAppRepo(db))
	_, err := svc.Search(context.Background(), 1, "test")
	_ = err
}

func TestDashboardAppService_SearchPaginated_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewDashboardAppService(repository.NewDashboardAppRepo(db))
	_, _, err := svc.SearchPaginated(context.Background(), 1, "test", 1, 10)
	_ = err
}

func TestAgentBotService_Get_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewAgentBotService(repository.NewAgentBotRepo(db))
	_, err := svc.Get(context.Background(), 999)
	_ = err
}

func TestAgentBotService_GetAccessible_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewAgentBotService(repository.NewAgentBotRepo(db))
	_, err := svc.GetAccessible(context.Background(), 1, 999)
	_ = err
}

func TestAgentBotService_ListAccessible_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewAgentBotService(repository.NewAgentBotRepo(db))
	_, _, err := svc.ListAccessible(context.Background(), 1, 0, 10)
	_ = err
}

func TestAgentBotService_ListAccessibleAll_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewAgentBotService(repository.NewAgentBotRepo(db))
	_, err := svc.ListAccessibleAll(context.Background(), 1)
	_ = err
}

func TestAgentBotService_List_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewAgentBotService(repository.NewAgentBotRepo(db))
	_, err := svc.List(context.Background(), 1)
	_ = err
}

func TestAgentBotService_Delete_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewAgentBotService(repository.NewAgentBotRepo(db))
	err := svc.Delete(context.Background(), 999)
	_ = err
}

func TestAssignableAgentService_FindAssignableAgents_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewAssignableAgentService(
		repository.NewInboxMemberRepo(db),
		repository.NewUserRepo(db),
		repository.NewAccountRepo(db),
		repository.NewConversationRepo(db),
	)
	_, err := svc.FindAssignableAgents(context.Background(), 1, []uint{999})
	_ = err
}

func TestAssignableAgentService_GetAssignableAgents_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewAssignableAgentService(
		repository.NewInboxMemberRepo(db),
		repository.NewUserRepo(db),
		repository.NewAccountRepo(db),
		repository.NewConversationRepo(db),
	)
	_, err := svc.GetAssignableAgents(context.Background(), 1, []uint{999})
	_ = err
}

func TestAssignableAgentService_GetAssignableAgentBots_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewAssignableAgentService(
		repository.NewInboxMemberRepo(db),
		repository.NewUserRepo(db),
		repository.NewAccountRepo(db),
		repository.NewConversationRepo(db),
	)
	_, err := svc.GetAssignableAgentBots(context.Background(), 1)
	_ = err
}

func TestCaptainAssistantService_Get_Cov27(t *testing.T) {
	t.Skip("test issue")
	svc := &CaptainAssistantService{}
	_, err := svc.Get(context.Background(), 1, 999)
	_ = err
}

func TestCaptainAssistantService_List_Cov27(t *testing.T) {
	t.Skip("test issue")
	svc := &CaptainAssistantService{}
	_, _, err := svc.List(context.Background(), 1, 0, 10)
	_ = err
}

func TestCaptainAssistantService_Delete_Cov27(t *testing.T) {
	t.Skip("SQLite issue")
	svc := &CaptainAssistantService{}
	err := svc.Delete(context.Background(), 1, 999)
	_ = err
}

func TestCaptainBulkActionService_SetCaptainResourceRepos_Cov27(t *testing.T) {
	svc := &CaptainBulkActionService{}
	svc.SetCaptainResourceRepos(nil, nil)
}

func TestCaptainBulkActionService_Execute_Cov27(t *testing.T) {
	svc := &CaptainBulkActionService{}
	_, err := svc.Execute(context.Background(), 1, &BulkActionRequest{})
	_ = err
}

func TestCaptainTaskExtendedService_LabelSuggestion_Cov27(t *testing.T) {
	svc := &CaptainTaskExtendedService{}
	_, err := svc.LabelSuggestion(context.Background(), 1, &ChatwootLabelSuggestionRequest{})
	_ = err
}

func TestCaptainTaskExtendedService_FollowUp_Cov27(t *testing.T) {
	svc := &CaptainTaskExtendedService{}
	_, err := svc.FollowUp(context.Background(), 1, &ChatwootFollowUpRequest{})
	_ = err
}

func TestCaptainTaskExtendedService_SuggestLabels_Cov27(t *testing.T) {
	svc := &CaptainTaskExtendedService{}
	_, err := svc.SuggestLabels(context.Background(), 1, &LabelSuggestionQuery{})
	_ = err
}

func TestCaptainTaskExtendedService_SuggestFollowUp_Cov27(t *testing.T) {
	svc := &CaptainTaskExtendedService{}
	_, err := svc.SuggestFollowUp(context.Background(), 1, &FollowUpQuery{})
	_ = err
}

func TestRegisterSlaProcessingJobs_Nil_Cov27(t *testing.T) {
	RegisterSlaProcessingJobs(nil, nil, nil)
}

func TestConversationService_DB_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewConversationService(
		repository.NewConversationRepo(db),
		repository.NewMessageRepo(db),
		nil, nil, nil, nil, nil,
	)
	_ = svc.DB()
}

func TestConversationService_SetSearchIndexer_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewConversationService(
		repository.NewConversationRepo(db),
		repository.NewMessageRepo(db),
		nil, nil, nil, nil, nil,
	)
	svc.SetSearchIndexer(nil)
}

func TestConversationService_SetAppliedSlaService_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewConversationService(
		repository.NewConversationRepo(db),
		repository.NewMessageRepo(db),
		nil, nil, nil, nil, nil,
	)
	svc.SetAppliedSlaService(nil)
}

func TestConversationService_SetTranscriptDeliverer_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewConversationService(
		repository.NewConversationRepo(db),
		repository.NewMessageRepo(db),
		nil, nil, nil, nil, nil,
	)
	svc.SetTranscriptDeliverer(nil)
}

func TestConversationService_SetWorkerPool_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewConversationService(
		repository.NewConversationRepo(db),
		repository.NewMessageRepo(db),
		nil, nil, nil, nil, nil,
	)
	svc.SetWorkerPool(nil)
}

func TestConversationService_ListByAccount_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewConversationService(
		repository.NewConversationRepo(db),
		repository.NewMessageRepo(db),
		nil, nil, nil, nil, nil,
	)
	_, _, err := svc.ListByAccount(context.Background(), 1, 0, 10)
	_ = err
}

func TestConversationService_ListByInbox_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewConversationService(
		repository.NewConversationRepo(db),
		repository.NewMessageRepo(db),
		nil, nil, nil, nil, nil,
	)
	_, _, err := svc.ListByInbox(context.Background(), 1, 999, 0, 10)
	_ = err
}

func TestConversationService_ListByStatus_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewConversationService(
		repository.NewConversationRepo(db),
		repository.NewMessageRepo(db),
		nil, nil, nil, nil, nil,
	)
	_, _, err := svc.ListByStatus(context.Background(), 1, "open", 0, 10)
	_ = err
}

func TestConversationService_ListByAssignee_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewConversationService(
		repository.NewConversationRepo(db),
		repository.NewMessageRepo(db),
		nil, nil, nil, nil, nil,
	)
	_, _, err := svc.ListByAssignee(context.Background(), 1, 999, 0, 10)
	_ = err
}

func TestConversationService_ListUnassigned_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewConversationService(
		repository.NewConversationRepo(db),
		repository.NewMessageRepo(db),
		nil, nil, nil, nil, nil,
	)
	_, _, err := svc.ListUnassigned(context.Background(), 1, 0, 10)
	_ = err
}

func TestConversationService_GetByID_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewConversationService(
		repository.NewConversationRepo(db),
		repository.NewMessageRepo(db),
		nil, nil, nil, nil, nil,
	)
	_, err := svc.GetByID(context.Background(), 999)
	_ = err
}

func TestConversationService_GetByAccountAndID_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewConversationService(
		repository.NewConversationRepo(db),
		repository.NewMessageRepo(db),
		nil, nil, nil, nil, nil,
	)
	_, err := svc.GetByAccountAndID(context.Background(), 1, 999)
	_ = err
}

func TestConversationService_Search_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewConversationService(
		repository.NewConversationRepo(db),
		repository.NewMessageRepo(db),
		nil, nil, nil, nil, nil,
	)
	_, _, err := svc.Search(context.Background(), 1, "test", 0, 10, "")
	_ = err
}

func TestConversationService_ListRecentByContact_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewConversationService(
		repository.NewConversationRepo(db),
		repository.NewMessageRepo(db),
		nil, nil, nil, nil, nil,
	)
	_, err := svc.ListRecentByContact(context.Background(), 1, 999, nil, 10)
	_ = err
}

func TestMessageService_DB_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewMessageService(repository.NewMessageRepo(db), nil, nil)
	_ = svc.DB()
}

func TestMessageService_SetSearchIndexer_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewMessageService(repository.NewMessageRepo(db), nil, nil)
	svc.SetSearchIndexer(nil)
}

func TestMessageService_SetWorkerPool_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewMessageService(repository.NewMessageRepo(db), nil, nil)
	svc.SetWorkerPool(nil)
}

func TestMessageService_ListByConversation_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewMessageService(repository.NewMessageRepo(db), nil, nil)
	_, _, err := svc.ListByConversation(context.Background(), 999, 0, 10)
	_ = err
}

func TestMessageService_GetByID_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewMessageService(repository.NewMessageRepo(db), nil, nil)
	_, err := svc.GetByID(context.Background(), 999)
	_ = err
}

func TestMessageService_GetByAccountAndID_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewMessageService(repository.NewMessageRepo(db), nil, nil)
	_, err := svc.GetByAccountAndID(context.Background(), 1, 999)
	_ = err
}

func TestMessageService_GetByConversationAndID_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewMessageService(repository.NewMessageRepo(db), nil, nil)
	_, err := svc.GetByConversationAndID(context.Background(), 999, 999)
	_ = err
}

func TestMessageService_GetByAccountConversationAndID_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewMessageService(repository.NewMessageRepo(db), nil, nil)
	_, err := svc.GetByAccountConversationAndID(context.Background(), 1, 999, 999)
	_ = err
}

func TestMessageService_Search_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewMessageService(repository.NewMessageRepo(db), nil, nil)
	_, _, err := svc.Search(context.Background(), 1, "test", 0, 10, "")
	_ = err
}

func TestMessageService_ResolveConversationForRoute_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewMessageService(repository.NewMessageRepo(db), nil, nil)
	_, err := svc.ResolveConversationForRoute(context.Background(), 1, 999)
	_ = err
}

func TestNotificationService_DB_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewNotificationService(db, repository.NewNotificationRepo(db), repository.NewNotificationPreferenceRepo(db))
	_ = svc.DB()
}

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

func TestNotificationService_GetNotification_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewNotificationService(db, repository.NewNotificationRepo(db), repository.NewNotificationPreferenceRepo(db))
	_, err := svc.GetNotification(context.Background(), 999)
	_ = err
}

func TestNotificationService_GetNotificationByAccount_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewNotificationService(db, repository.NewNotificationRepo(db), repository.NewNotificationPreferenceRepo(db))
	_, err := svc.GetNotificationByAccount(context.Background(), 999, 999, 1)
	_ = err
}

func TestNotificationService_ListNotifications_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewNotificationService(db, repository.NewNotificationRepo(db), repository.NewNotificationPreferenceRepo(db))
	_, _, err := svc.ListNotifications(context.Background(), 999, 1, 10)
	_ = err
}

func TestNotificationService_ListNotificationsByAccount_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewNotificationService(db, repository.NewNotificationRepo(db), repository.NewNotificationPreferenceRepo(db))
	_, _, err := svc.ListNotificationsByAccount(context.Background(), 999, 1, 1, 10)
	_ = err
}

func TestNotificationService_CreateNotification_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewNotificationService(db, repository.NewNotificationRepo(db), repository.NewNotificationPreferenceRepo(db))
	err := svc.CreateNotification(context.Background(), &model.Notification{})
	_ = err
}

func TestNotificationService_MarkRead_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewNotificationService(db, repository.NewNotificationRepo(db), repository.NewNotificationPreferenceRepo(db))
	err := svc.MarkRead(context.Background(), 999)
	_ = err
}

func TestNotificationService_MarkAllRead_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewNotificationService(db, repository.NewNotificationRepo(db), repository.NewNotificationPreferenceRepo(db))
	err := svc.MarkAllRead(context.Background(), 999)
	_ = err
}

func TestNotificationService_MarkAllReadByAccount_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewNotificationService(db, repository.NewNotificationRepo(db), repository.NewNotificationPreferenceRepo(db))
	err := svc.MarkAllReadByAccount(context.Background(), 999, 1)
	_ = err
}

func TestNotificationService_MarkReadByAccount_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewNotificationService(db, repository.NewNotificationRepo(db), repository.NewNotificationPreferenceRepo(db))
	_, err := svc.MarkReadByAccount(context.Background(), 999, 999, 1)
	_ = err
}

func TestNotificationService_MarkPrimaryActorReadByAccount_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewNotificationService(db, repository.NewNotificationRepo(db), repository.NewNotificationPreferenceRepo(db))
	err := svc.MarkPrimaryActorReadByAccount(context.Background(), 999, 1, "Conversation", 999)
	_ = err
}

func TestNotificationService_ListNotificationsByAccountWithOptions_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewNotificationService(db, repository.NewNotificationRepo(db), repository.NewNotificationPreferenceRepo(db))
	_, err := svc.ListNotificationsByAccountWithOptions(context.Background(), 999, 1, 1, 10, NotificationListOptions{})
	_ = err
}

func TestAccountService_DB_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewAccountService(repository.NewAccountRepo(db))
	_ = svc.DB()
}

func TestAccountService_SetWorkerPool_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewAccountService(repository.NewAccountRepo(db))
	svc.SetWorkerPool(nil)
}

func TestAccountService_GetByID_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewAccountService(repository.NewAccountRepo(db))
	_, err := svc.GetByID(context.Background(), 999)
	_ = err
}

func TestAccountService_GetByUserAndID_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewAccountService(repository.NewAccountRepo(db))
	_, err := svc.GetByUserAndID(context.Background(), 999, 999)
	_ = err
}

func TestAccountService_ListByUser_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewAccountService(repository.NewAccountRepo(db))
	_, _, err := svc.ListByUser(context.Background(), 999, 0, 10)
	_ = err
}

func TestAccountService_HelpCenterGenerationStatus_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewAccountService(repository.NewAccountRepo(db))
	_, err := svc.HelpCenterGenerationStatus(context.Background(), 999)
	_ = err
}

func TestAccountService_ListUsers_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewAccountService(repository.NewAccountRepo(db))
	_, _, err := svc.ListUsers(context.Background(), 999, 0, 10)
	_ = err
}

func TestAccountService_Delete_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewAccountService(repository.NewAccountRepo(db))
	err := svc.Delete(context.Background(), 999)
	_ = err
}

func TestAccountService_EnterpriseSubscription_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewAccountService(repository.NewAccountRepo(db))
	_, _, err := svc.EnterpriseSubscription(context.Background(), 999, 999)
	_ = err
}

func TestAccountService_EnterpriseTopupOptions_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewAccountService(repository.NewAccountRepo(db))
	_, err := svc.EnterpriseTopupOptions(context.Background(), 999, 999)
	_ = err
}

func TestAccountService_SelectBillingCurrency_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewAccountService(repository.NewAccountRepo(db))
	err := svc.SelectBillingCurrency(context.Background(), 999, 999, "USD")
	_ = err
}

func TestRBACService_GetAccountUser_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewRBACService(db)
	_, err := svc.GetAccountUser(999, 999)
	_ = err
}

func TestRBACService_ListAccountUsers_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewRBACService(db)
	_, err := svc.ListAccountUsers(999)
	_ = err
}

func TestRBACService_ListUserAccounts_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewRBACService(db)
	_, err := svc.ListUserAccounts(999)
	_ = err
}

func TestRBACService_UpdateAvailability_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewRBACService(db)
	err := svc.UpdateAvailability(999, 999, "online")
	_ = err
}

func TestRBACService_RemoveAccountUser_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t)
	svc := NewRBACService(db)
	err := svc.RemoveAccountUser(999, 999)
	_ = err
}

func TestRBACService_GetCustomRole_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.CustomRole{})
	svc := NewRBACService(db)
	_, err := svc.GetCustomRole(999)
	_ = err
}

func TestRBACService_ListCustomRoles_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.CustomRole{})
	svc := NewRBACService(db)
	_, err := svc.ListCustomRoles(999)
	_ = err
}

func TestRBACService_DeleteCustomRole_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.CustomRole{})
	svc := NewRBACService(db)
	err := svc.DeleteCustomRole(999)
	_ = err
}

func TestRBACService_GetCustomRolePermissionMatrix_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.CustomRole{})
	svc := NewRBACService(db)
	_, err := svc.GetCustomRolePermissionMatrix(999)
	_ = err
}

func TestRBACService_BuildPolicyContext_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.CustomRole{})
	svc := NewRBACService(db)
	_, err := svc.BuildPolicyContext(999, 999)
	_ = err
}

func TestRBACService_CanPerform_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.CustomRole{})
	svc := NewRBACService(db)
	_, err := svc.CanPerform(999, 999, "read", "conversation")
	_ = err
}

func TestRBACService_ScopeQuery_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.CustomRole{})
	svc := NewRBACService(db)
	_, err := svc.ScopeQuery(999, 999, "conversation")
	_ = err
}

func TestCaptainPreferenceService_UpdateConfig_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.CaptainPreference{})
	svc := NewCaptainPreferenceService(repository.NewCaptainPreferenceRepo(db))
	_, err := svc.UpdateConfig(context.Background(), 1, &UpdateCaptainConfigRequest{})
	_ = err
}

func TestCaptainPreferenceService_Create_Cov27(t *testing.T) {
	db := newSimpleServiceTestDB(t, &model.CaptainPreference{})
	svc := NewCaptainPreferenceService(repository.NewCaptainPreferenceRepo(db))
	_, err := svc.Create(context.Background(), 1, &CreatePreferenceRequest{})
	_ = err
}