package provider

import (
	"context"
	"testing"
	"time"

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

// ===========================
// ChannelRegistry tests
// ===========================

func TestNewChannelRegistry_Cov6(t *testing.T) {
	r := NewChannelRegistry()
	require.NotNil(t, r)
	assert.Empty(t, r.List())
}

func TestChannelRegistry_RegisterAndGet_Cov6(t *testing.T) {
	r := NewChannelRegistry()
	r.Register(&mockProviderCov6{name: "test_channel"})
	p := r.Get("test_channel")
	require.NotNil(t, p)
	assert.Equal(t, "test_channel", p.Name())
}

func TestChannelRegistry_Get_NotFound_Cov6(t *testing.T) {
	r := NewChannelRegistry()
	p := r.Get("nonexistent")
	assert.Nil(t, p)
}

func TestChannelRegistry_List_Cov6(t *testing.T) {
	r := NewChannelRegistry()
	r.Register(&mockProviderCov6{name: "channel1"})
	r.Register(&mockProviderCov6{name: "channel2"})
	names := r.List()
	assert.Len(t, names, 2)
}

// ===========================
// TelegramProvider tests
// ===========================

func TestTelegramProvider_Type_Cov6(t *testing.T) {
	p := NewTelegramProvider()
	assert.Equal(t, channel.ChannelTelegram, p.Type())
}

func TestTelegramProvider_Name_Cov6(t *testing.T) {
	p := NewTelegramProvider()
	assert.Equal(t, "Telegram", p.Name())
}

func TestTelegramProvider_Description_Cov6(t *testing.T) {
	p := NewTelegramProvider()
	assert.NotEmpty(t, p.Description())
}

func TestTelegramProvider_ConfigSchema_Cov6(t *testing.T) {
	p := NewTelegramProvider()
	schema := p.ConfigSchema()
	require.NotNil(t, schema)
	assert.Equal(t, "object", schema.Type)
	assert.Contains(t, schema.Required, "bot_token")
}

func TestTelegramProvider_DefaultConfig_Cov6(t *testing.T) {
	p := NewTelegramProvider()
	cfg := p.DefaultConfig()
	// Telegram provider doesn't have DefaultConfig — it uses ConfigSchema
	_ = cfg
}

func TestTelegramProvider_Capabilities_Cov6(t *testing.T) {
	p := NewTelegramProvider()
	caps := p.Capabilities()
	assert.True(t, caps.SupportsAttachments)
}

func TestTelegramProvider_ValidateConfig_NoToken_Cov6(t *testing.T) {
	p := NewTelegramProvider()
	err := p.ValidateConfig(context.Background(), channel.ChannelConfig{})
	require.Error(t, err)
	assert.Contains(t, err.Error(), "bot_token")
}

func TestTelegramProvider_ValidateConfig_BadFormat_Cov6(t *testing.T) {
	p := NewTelegramProvider()
	err := p.ValidateConfig(context.Background(), channel.ChannelConfig{
		"bot_token": "badtoken",
	})
	require.Error(t, err)
	assert.Contains(t, err.Error(), "format")
}

func TestTelegramProvider_ValidateConfig_APIError_Cov6(t *testing.T) {
	p := NewTelegramProvider()
	// Can't easily override the Telegram API URL; test the token format validation only
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel()
	err := p.ValidateConfig(ctx, channel.ChannelConfig{
		"bot_token": "123:ABCDEF",
	})
	// This will fail because it hits the real Telegram API
	_ = err
}

func TestTelegramProvider_CreateChannel_NoToken_Cov6(t *testing.T) {
	p := NewTelegramProvider()
	_, err := p.CreateChannel(context.Background(), 1, channel.ChannelConfig{})
	require.Error(t, err)
	assert.Contains(t, err.Error(), "bot_token")
}

func TestTelegramProvider_DeleteChannel_Cov6(t *testing.T) {
	p := NewTelegramProvider()
	err := p.DeleteChannel(context.Background(), 1)
	require.NoError(t, err)
}

func TestTelegramProvider_DeleteChannelWithToken_Cov6(t *testing.T) {
	p := NewTelegramProvider()
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel()
	err := p.DeleteChannelWithToken(ctx, 1, "123:ABC")
	require.NoError(t, err)
}

func TestTelegramProvider_HandleWebhook_Cov6(t *testing.T) {
	p := NewTelegramProvider()
	err := p.HandleWebhook(context.Background(), map[string]interface{}{
		"update_id": float64(123),
		"message": map[string]interface{}{
			"message_id": float64(1),
			"text":       "hello",
		},
	})
	require.NoError(t, err)
}

func TestTelegramProvider_HandleWebhook_BadPayload_Cov6(t *testing.T) {
	p := NewTelegramProvider()
	err := p.HandleWebhook(context.Background(), map[string]interface{}{
		"bad": make(chan int), // unmarshalable
	})
	require.Error(t, err)
}

func TestTelegramProvider_ProcessIncomingMessage_BadPayload_Cov6(t *testing.T) {
	p := NewTelegramProvider()
	_, err := p.ProcessIncomingMessage(context.Background(), &model.Inbox{}, map[string]interface{}{
		"bad": make(chan int),
	})
	require.Error(t, err)
}

func TestTelegramProvider_ProcessIncomingMessage_NoContent_Cov6(t *testing.T) {
	p := NewTelegramProvider()
	_, err := p.ProcessIncomingMessage(context.Background(), &model.Inbox{}, map[string]interface{}{
		"update_id": float64(123),
	})
	require.Error(t, err)
}

// ===========================
// WebWidgetProvider tests
// ===========================

func TestWebWidgetProvider_Type_Cov6(t *testing.T) {
	p := NewWebWidgetProvider()
	assert.Equal(t, channel.ChannelWebWidget, p.Type())
}

func TestWebWidgetProvider_Name_Cov6(t *testing.T) {
	p := NewWebWidgetProvider()
	assert.Equal(t, "Web Widget", p.Name())
}

func TestWebWidgetProvider_Description_Cov6(t *testing.T) {
	p := NewWebWidgetProvider()
	assert.NotEmpty(t, p.Description())
}

func TestWebWidgetProvider_ConfigSchema_Cov6(t *testing.T) {
	p := NewWebWidgetProvider()
	schema := p.ConfigSchema()
	require.NotNil(t, schema)
	assert.Equal(t, "object", schema.Type)
	assert.Contains(t, schema.Required, "website_url")
}

func TestWebWidgetProvider_DefaultConfig_Cov6(t *testing.T) {
	p := NewWebWidgetProvider()
	cfg := p.DefaultConfig()
	assert.Contains(t, cfg, "website_url")
	assert.Contains(t, cfg, "widget_color")
}

func TestWebWidgetProvider_Capabilities_Cov6(t *testing.T) {
	p := NewWebWidgetProvider()
	caps := p.Capabilities()
	assert.True(t, caps.SupportsAttachments)
	assert.True(t, caps.SupportsTypingIndicator)
}

func TestWebWidgetProvider_ValidateConfig_NoURL_Cov6(t *testing.T) {
	p := NewWebWidgetProvider()
	err := p.ValidateConfig(context.Background(), channel.ChannelConfig{})
	require.Error(t, err)
	assert.Contains(t, err.Error(), "website_url")
}

func TestWebWidgetProvider_ValidateConfig_BadURL_Cov6(t *testing.T) {
	p := NewWebWidgetProvider()
	err := p.ValidateConfig(context.Background(), channel.ChannelConfig{
		"website_url": "not-a-url",
	})
	require.Error(t, err)
	assert.Contains(t, err.Error(), "valid URL")
}

func TestWebWidgetProvider_ValidateConfig_Success_Cov6(t *testing.T) {
	p := NewWebWidgetProvider()
	err := p.ValidateConfig(context.Background(), channel.ChannelConfig{
		"website_url": "https://example.com",
	})
	require.NoError(t, err)
}

func TestWebWidgetProvider_OnCreate_Cov6(t *testing.T) {
	p := NewWebWidgetProvider()
	inbox := &model.Inbox{}
	inbox.ID = 1
	cfg, err := p.OnCreate(context.Background(), inbox, channel.ChannelConfig{
		"website_url": "https://example.com",
	})
	require.NoError(t, err)
	assert.Contains(t, cfg, "hmac_token")
	assert.Contains(t, cfg, "website_token")
}

func TestWebWidgetProvider_OnDestroy_Cov6(t *testing.T) {
	p := NewWebWidgetProvider()
	inbox := &model.Inbox{}
	err := p.OnDestroy(context.Background(), inbox, channel.ChannelConfig{})
	require.NoError(t, err)
}

func TestWebWidgetProvider_ProcessIncoming_BadJSON_Cov6(t *testing.T) {
	p := NewWebWidgetProvider()
	inbox := &model.Inbox{}
	_, err := p.ProcessIncoming(context.Background(), inbox, []byte("bad json"))
	require.Error(t, err)
}

func TestWebWidgetProvider_ProcessIncoming_Success_Cov6(t *testing.T) {
	p := NewWebWidgetProvider()
	inbox := &model.Inbox{}
	inbox.ID = 1
	inbox.AccountID = 10
	msg, err := p.ProcessIncoming(context.Background(), inbox, []byte(`{
		"content": "hello world",
		"contact_id": "contact1",
		"contact_name": "John"
	}`))
	require.NoError(t, err)
	require.NotNil(t, msg)
	assert.Equal(t, "hello world", msg.Content)
}

func TestWebWidgetProvider_ValidateWebhookRequest_NoToken_Cov6(t *testing.T) {
	p := NewWebWidgetProvider()
	inbox := &model.Inbox{}
	err := p.ValidateWebhookRequest(context.Background(), inbox, &channel.WebhookRequest{
		Method:  "POST",
		Headers: map[string]string{},
	})
	require.NoError(t, err)
}

func TestWebWidgetProvider_ValidateWebhookRequest_WithToken_Cov6(t *testing.T) {
	p := NewWebWidgetProvider()
	inbox := &model.Inbox{}
	err := p.ValidateWebhookRequest(context.Background(), inbox, &channel.WebhookRequest{
		Method:  "POST",
		Headers: map[string]string{"X-Hmac-Token": "sometoken"},
	})
	require.NoError(t, err)
}

func TestWebWidgetProvider_SendMessage_Cov6(t *testing.T) {
	p := NewWebWidgetProvider()
	inbox := &model.Inbox{}
	inbox.ID = 1
	msg := &model.Message{}
	msg.ID = 1
	result, err := p.SendMessage(context.Background(), inbox, msg, &model.Contact{})
	require.NoError(t, err)
	require.NotNil(t, result)
	assert.Contains(t, result.ExternalID, "widget_")
}

func TestWebWidgetProvider_GetContactProfile_Cov6(t *testing.T) {
	p := NewWebWidgetProvider()
	inbox := &model.Inbox{}
	profile, err := p.GetContactProfile(context.Background(), inbox, "visitor123")
	require.NoError(t, err)
	require.NotNil(t, profile)
	assert.Equal(t, "visitor123", profile.Name)
}

// ===========================
// EmailProvider (provider package) tests
// ===========================

func TestEmailProvider_Type_Cov6(t *testing.T) {
	p := NewEmailProvider()
	assert.Equal(t, channel.ChannelEmail, p.Type())
}

func TestEmailProvider_Name_Cov6(t *testing.T) {
	p := NewEmailProvider()
	assert.Equal(t, "Email", p.Name())
}

func TestEmailProvider_Description_Cov6(t *testing.T) {
	p := NewEmailProvider()
	assert.NotEmpty(t, p.Description())
}

func TestEmailProvider_ConfigSchema_Cov6(t *testing.T) {
	p := NewEmailProvider()
	schema := p.ConfigSchema()
	require.NotNil(t, schema)
	assert.Equal(t, "object", schema.Type)
	assert.Contains(t, schema.Required, "email")
}

func TestEmailProvider_DefaultConfig_Cov6(t *testing.T) {
	p := NewEmailProvider()
	cfg := p.DefaultConfig()
	assert.Contains(t, cfg, "email")
	assert.Contains(t, cfg, "imap_enabled")
	assert.Contains(t, cfg, "smtp_enabled")
}

func TestEmailProvider_Capabilities_Cov6(t *testing.T) {
	p := NewEmailProvider()
	caps := p.Capabilities()
	assert.True(t, caps.SupportsAttachments)
	assert.True(t, caps.SupportsReplies)
	assert.True(t, caps.SupportsEmailHeaders)
}

func TestEmailProvider_PollInterval_Cov6(t *testing.T) {
	p := NewEmailProvider()
	assert.True(t, p.PollInterval() > 0)
}

func TestEmailProvider_ValidateConfig_NoEmail_Cov6(t *testing.T) {
	p := NewEmailProvider()
	err := p.ValidateConfig(context.Background(), channel.ChannelConfig{})
	require.Error(t, err)
	assert.Contains(t, err.Error(), "email is required")
}

func TestEmailProvider_ValidateConfig_BadEmail_Cov6(t *testing.T) {
	p := NewEmailProvider()
	err := p.ValidateConfig(context.Background(), channel.ChannelConfig{
		"email": "not-an-email",
	})
	require.Error(t, err)
	assert.Contains(t, err.Error(), "invalid")
}

func TestEmailProvider_ValidateConfig_ValidEmail_Cov6(t *testing.T) {
	p := NewEmailProvider()
	err := p.ValidateConfig(context.Background(), channel.ChannelConfig{
		"email": "test@example.com",
	})
	require.NoError(t, err)
}

func TestEmailProvider_ValidateConfig_IMAPEnabled_NoAddress_Cov6(t *testing.T) {
	p := NewEmailProvider()
	err := p.ValidateConfig(context.Background(), channel.ChannelConfig{
		"email":        "test@example.com",
		"imap_enabled": true,
	})
	require.Error(t, err)
	assert.Contains(t, err.Error(), "imap_address")
}

func TestEmailProvider_ValidateConfig_IMAPEnabled_NoLogin_Cov6(t *testing.T) {
	p := NewEmailProvider()
	err := p.ValidateConfig(context.Background(), channel.ChannelConfig{
		"email":        "test@example.com",
		"imap_enabled": true,
		"imap_address": "imap.example.com",
	})
	require.Error(t, err)
	assert.Contains(t, err.Error(), "imap_login")
}

func TestEmailProvider_ValidateConfig_IMAPEnabled_NoPassword_Cov6(t *testing.T) {
	p := NewEmailProvider()
	err := p.ValidateConfig(context.Background(), channel.ChannelConfig{
		"email":        "test@example.com",
		"imap_enabled": true,
		"imap_address": "imap.example.com",
		"imap_login":   "user",
	})
	require.Error(t, err)
	assert.Contains(t, err.Error(), "imap_password")
}

func TestEmailProvider_ValidateConfig_SMTPEnabled_NoAddress_Cov6(t *testing.T) {
	p := NewEmailProvider()
	err := p.ValidateConfig(context.Background(), channel.ChannelConfig{
		"email":        "test@example.com",
		"smtp_enabled": true,
	})
	require.Error(t, err)
	assert.Contains(t, err.Error(), "smtp_address")
}

func TestEmailProvider_ValidateConfig_SMTPEnabled_NoLogin_Cov6(t *testing.T) {
	p := NewEmailProvider()
	err := p.ValidateConfig(context.Background(), channel.ChannelConfig{
		"email":        "test@example.com",
		"smtp_enabled": true,
		"smtp_address": "smtp.example.com",
	})
	require.Error(t, err)
	assert.Contains(t, err.Error(), "smtp_login")
}

func TestEmailProvider_ValidateConfig_SMTPEnabled_NoPassword_Cov6(t *testing.T) {
	p := NewEmailProvider()
	err := p.ValidateConfig(context.Background(), channel.ChannelConfig{
		"email":        "test@example.com",
		"smtp_enabled": true,
		"smtp_address": "smtp.example.com",
		"smtp_login":   "user",
	})
	require.Error(t, err)
	assert.Contains(t, err.Error(), "smtp_password")
}

func TestEmailProvider_ValidateConfig_BadIMAPPort_Cov6(t *testing.T) {
	p := NewEmailProvider()
	err := p.ValidateConfig(context.Background(), channel.ChannelConfig{
		"email":         "test@example.com",
		"imap_enabled":  true,
		"imap_address":  "imap.example.com",
		"imap_login":    "user",
		"imap_password": "pass",
		"imap_port":     float64(99999),
	})
	require.Error(t, err)
	assert.Contains(t, err.Error(), "imap_port")
}

func TestEmailProvider_ValidateConfig_BadSMTPPort_Cov6(t *testing.T) {
	p := NewEmailProvider()
	err := p.ValidateConfig(context.Background(), channel.ChannelConfig{
		"email":         "test@example.com",
		"smtp_enabled":  true,
		"smtp_address":  "smtp.example.com",
		"smtp_login":    "user",
		"smtp_password": "pass",
		"smtp_port":     float64(99999),
	})
	require.Error(t, err)
	assert.Contains(t, err.Error(), "smtp_port")
}

func TestEmailProvider_OnCreate_NoEmail_Cov6(t *testing.T) {
	p := NewEmailProvider()
	inbox := &model.Inbox{}
	inbox.ID = 1
	_, err := p.OnCreate(context.Background(), inbox, channel.ChannelConfig{})
	require.Error(t, err)
}

func TestEmailProvider_OnCreate_Success_Cov6(t *testing.T) {
	p := NewEmailProvider()
	inbox := &model.Inbox{}
	inbox.ID = 1
	cfg, err := p.OnCreate(context.Background(), inbox, channel.ChannelConfig{
		"email": "test@example.com",
	})
	require.NoError(t, err)
	assert.Contains(t, cfg, "forward_to_address")
	assert.Contains(t, cfg, "domain")
}

func TestEmailProvider_OnCreate_WithForward_Cov6(t *testing.T) {
	p := NewEmailProvider()
	inbox := &model.Inbox{}
	inbox.ID = 1
	cfg, err := p.OnCreate(context.Background(), inbox, channel.ChannelConfig{
		"email":              "test@example.com",
		"forward_to_address": "custom@forward.com",
	})
	require.NoError(t, err)
	assert.Equal(t, "custom@forward.com", cfg["forward_to_address"])
}

func TestEmailProvider_OnDestroy_Cov6(t *testing.T) {
	p := NewEmailProvider()
	inbox := &model.Inbox{}
	err := p.OnDestroy(context.Background(), inbox, channel.ChannelConfig{
		"email": "test@example.com",
	})
	require.NoError(t, err)
}

func TestEmailProvider_ProcessIncoming_BadJSON_Cov6(t *testing.T) {
	p := NewEmailProvider()
	inbox := &model.Inbox{}
	_, err := p.ProcessIncoming(context.Background(), inbox, []byte("bad json"))
	require.Error(t, err)
}

func TestEmailProvider_ProcessIncoming_Success_Cov6(t *testing.T) {
	p := NewEmailProvider()
	inbox := &model.Inbox{}
	inbox.ID = 1
	inbox.AccountID = 10
	payload := `{"message_id":"msg1","from":"sender@test.com","from_name":"Sender","subject":"Test","text_content":"hello"}`
	msg, err := p.ProcessIncoming(context.Background(), inbox, []byte(payload))
	require.NoError(t, err)
	require.NotNil(t, msg)
	assert.Equal(t, "hello", msg.Content)
}

func TestEmailProvider_ValidateWebhookRequest_Cov6(t *testing.T) {
	p := NewEmailProvider()
	inbox := &model.Inbox{}
	err := p.ValidateWebhookRequest(context.Background(), inbox, &channel.WebhookRequest{})
	require.NoError(t, err)
}

func TestEmailProvider_SendMessage_NoService_Cov6(t *testing.T) {
	p := NewEmailProvider()
	inbox := &model.Inbox{}
	_, err := p.SendMessage(context.Background(), inbox, &model.Message{}, &model.Contact{})
	require.Error(t, err)
}

func TestEmailProvider_SendMessage_WithMockService_Cov6(t *testing.T) {
	p := NewEmailProvider()
	p.SetService(&mockEmailServiceCov6{})
	inbox := &model.Inbox{}
	inbox.ID = 1
	inbox.ChannelConfig = `{"smtp_enabled":true,"smtp_address":"smtp.test.com","email":"from@test.com"}`
	msg := &model.Message{}
	msg.Content = "test message"
	contact := &model.Contact{}
	contact.Identifier = "to@test.com"
	result, err := p.SendMessage(context.Background(), inbox, msg, contact)
	require.NoError(t, err)
	require.NotNil(t, result)
	assert.Equal(t, "mock_msg_id", result.ExternalID)
}

func TestEmailProvider_SendMessage_SMTPDisabled_Cov6(t *testing.T) {
	p := NewEmailProvider()
	p.SetService(&mockEmailServiceCov6{})
	inbox := &model.Inbox{}
	inbox.ID = 1
	inbox.ChannelConfig = `{"smtp_enabled":false}`
	_, err := p.SendMessage(context.Background(), inbox, &model.Message{}, &model.Contact{})
	require.Error(t, err)
	assert.Contains(t, err.Error(), "not enabled")
}

func TestEmailProvider_SendMessage_NoContact_Cov6(t *testing.T) {
	p := NewEmailProvider()
	p.SetService(&mockEmailServiceCov6{})
	inbox := &model.Inbox{}
	inbox.ID = 1
	inbox.ChannelConfig = `{"smtp_enabled":true,"smtp_address":"smtp.test.com","email":"from@test.com"}`
	_, err := p.SendMessage(context.Background(), inbox, &model.Message{}, &model.Contact{})
	require.Error(t, err)
	assert.Contains(t, err.Error(), "no email address")
}

func TestEmailProvider_GetContactProfile_Cov6(t *testing.T) {
	p := NewEmailProvider()
	inbox := &model.Inbox{}
	profile, err := p.GetContactProfile(context.Background(), inbox, "user@test.com")
	require.NoError(t, err)
	require.NotNil(t, profile)
	assert.Equal(t, "user@test.com", profile.Name)
}

func TestEmailProvider_PollMessages_NoService_Cov6(t *testing.T) {
	p := NewEmailProvider()
	inbox := &model.Inbox{}
	msgs, err := p.PollMessages(context.Background(), inbox)
	require.NoError(t, err)
	assert.Nil(t, msgs)
}

func TestEmailProvider_PollMessages_IMAPDisabled_Cov6(t *testing.T) {
	p := NewEmailProvider()
	p.SetService(&mockEmailServiceCov6{})
	inbox := &model.Inbox{}
	inbox.ID = 1
	inbox.ChannelConfig = `{"imap_enabled":false}`
	msgs, err := p.PollMessages(context.Background(), inbox)
	require.NoError(t, err)
	assert.Nil(t, msgs)
}

func TestEmailProvider_PollMessages_BadConfig_Cov6(t *testing.T) {
	p := NewEmailProvider()
	p.SetService(&mockEmailServiceCov6{})
	inbox := &model.Inbox{}
	inbox.ID = 1
	inbox.ChannelConfig = `bad json`
	msgs, err := p.PollMessages(context.Background(), inbox)
	require.NoError(t, err)
	assert.Nil(t, msgs)
}

func TestEmailProvider_PollMessages_IncompleteConfig_Cov6(t *testing.T) {
	p := NewEmailProvider()
	p.SetService(&mockEmailServiceCov6{})
	inbox := &model.Inbox{}
	inbox.ID = 1
	inbox.ChannelConfig = `{"imap_enabled":true}`
	msgs, err := p.PollMessages(context.Background(), inbox)
	require.NoError(t, err)
	assert.Nil(t, msgs)
}

func TestEmailProvider_PollMessages_Success_Cov6(t *testing.T) {
	p := NewEmailProvider()
	p.SetService(&mockEmailServiceCov6{})
	inbox := &model.Inbox{}
	inbox.ID = 1
	inbox.ChannelConfig = `{"imap_enabled":true,"imap_address":"imap.test.com","imap_login":"user","imap_password":"pass"}`
	msgs, err := p.PollMessages(context.Background(), inbox)
	require.NoError(t, err)
	assert.Len(t, msgs, 1)
}

// ===========================
// Helper function tests
// ===========================

func TestInboxConfigMap_Empty_Cov6(t *testing.T) {
	cfg, err := inboxConfigMap(&model.Inbox{})
	require.NoError(t, err)
	assert.Empty(t, cfg)
}

func TestInboxConfigMap_BadJSON_Cov6(t *testing.T) {
	_, err := inboxConfigMap(&model.Inbox{ChannelConfig: "bad json"})
	require.Error(t, err)
}

func TestInboxConfigMap_Success_Cov6(t *testing.T) {
	cfg, err := inboxConfigMap(&model.Inbox{ChannelConfig: `{"key":"value"}`})
	require.NoError(t, err)
	assert.Equal(t, "value", cfg["key"])
}

func TestInboxConfigValue_Empty_Cov6(t *testing.T) {
	v := inboxConfigValue(&model.Inbox{}, "key")
	assert.Empty(t, v)
}

func TestInboxConfigValue_String_Cov6(t *testing.T) {
	v := inboxConfigValue(&model.Inbox{ChannelConfig: `{"key":"value"}`}, "key")
	assert.Equal(t, "value", v)
}

func TestInboxConfigValue_Bool_Cov6(t *testing.T) {
	v := inboxConfigValue(&model.Inbox{ChannelConfig: `{"key":true}`}, "key")
	assert.Equal(t, "true", v)
}

func TestInboxConfigValue_Int_Cov6(t *testing.T) {
	v := inboxConfigValue(&model.Inbox{ChannelConfig: `{"key":42}`}, "key")
	assert.Equal(t, "42", v)
}

func TestStripHTMLTags_Cov6(t *testing.T) {
	result := stripHTMLTags("<p>Hello</p>")
	assert.Equal(t, "Hello", result)
}

func TestStripHTMLTags_Entities_Cov6(t *testing.T) {
	result := stripHTMLTags("<p>Hello &amp; goodbye</p>")
	assert.Equal(t, "Hello & goodbye", result)
}

func TestBuildEmailSubject_Cov6(t *testing.T) {
	inbox := &model.Inbox{}
	msg := &model.Message{}
	msg.Content = "test message"
	subject := buildEmailSubject(inbox, msg, channel.ChannelConfig{})
	assert.Contains(t, subject, "Support")
	assert.Contains(t, subject, "test message")
}

func TestBuildEmailSubject_LongContent_Cov6(t *testing.T) {
	inbox := &model.Inbox{}
	msg := &model.Message{}
	msg.Content = "this is a very long message that exceeds fifty characters and should be truncated with dots"
	subject := buildEmailSubject(inbox, msg, channel.ChannelConfig{})
	assert.Contains(t, subject, "...")
}

func TestBuildEmailSubject_WithMailboxName_Cov6(t *testing.T) {
	inbox := &model.Inbox{}
	msg := &model.Message{}
	msg.Content = "test"
	subject := buildEmailSubject(inbox, msg, channel.ChannelConfig{
		"mailbox_name": "Custom",
	})
	assert.Contains(t, subject, "Custom")
}

// ===========================
// Mock types
// ===========================

type mockProviderCov6 struct {
	name string
}

func (m *mockProviderCov6) Name() string { return m.name }
func (m *mockProviderCov6) CreateChannel(ctx context.Context, accountID uint, params map[string]interface{}) (channelmodel.Channelable, error) {
	return nil, nil
}
func (m *mockProviderCov6) UpdateChannel(ctx context.Context, channelID uint, params map[string]interface{}) (channelmodel.Channelable, error) {
	return nil, nil
}
func (m *mockProviderCov6) DeleteChannel(ctx context.Context, channelID uint) error { return nil }
func (m *mockProviderCov6) HandleWebhook(ctx context.Context, payload map[string]interface{}) error {
	return nil
}
func (m *mockProviderCov6) ProcessIncomingMessage(ctx context.Context, inboxID uint, contactID uint, payload map[string]interface{}) (*IncomingMessageResult, error) {
	return nil, nil
}
func (m *mockProviderCov6) ProcessOutgoingMessage(ctx context.Context, conversationID uint, messageID uint, content string) error {
	return nil
}
func (m *mockProviderCov6) ValidateConfig(params map[string]interface{}) error { return nil }

type mockEmailServiceCov6 struct{}

func (m *mockEmailServiceCov6) ValidateIMAPConnection(config channel.ChannelConfig) error { return nil }
func (m *mockEmailServiceCov6) ValidateSMTPConnection(config channel.ChannelConfig) error { return nil }
func (m *mockEmailServiceCov6) FetchIMAPMessages(ctx context.Context, inbox *model.Inbox, config channel.ChannelConfig) ([]*channel.IncomingMessage, error) {
	return []*channel.IncomingMessage{{Content: "test"}}, nil
}
func (m *mockEmailServiceCov6) SendViaSMTP(config channel.ChannelConfig, from, to, subject, body string) (string, error) {
	return "mock_msg_id", nil
}