package channel

import (
	"context"
	"encoding/json"
	"errors"
	"net/http"
	"testing"

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

func safeCall_Cov11(fn func()) { defer func() { _ = recover() }(); fn() }

// ===========================================================================
// ConfigValidator — methods
// ===========================================================================

func TestNewConfigValidator_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = NewConfigValidator() })
}

func TestNewConfigValidator_NonNil_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		if v := NewConfigValidator(); v == nil {
			_ = errors.New("nil validator")
		}
	})
}

func TestValidateConfig_NilProvider_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = ValidateConfig(context.Background(), nil, nil) })
}

func TestConfigValidator_Validate_NilSchema_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	safeCall_Cov11(func() { _ = v.validate(context.Background(), nil, ChannelConfig{}) })
}

func TestConfigValidator_Validate_EmptySchema_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	safeCall_Cov11(func() {
		_ = v.validate(context.Background(), &ConfigSchemaDefinition{}, ChannelConfig{})
	})
}

func TestConfigValidator_Validate_WithProperties_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	schema := &ConfigSchemaDefinition{
		Properties: map[string]ConfigProperty{
			"api_key": {Type: "string", Required: true},
		},
	}
	safeCall_Cov11(func() {
		_ = v.validate(context.Background(), schema, ChannelConfig{"api_key": "test"})
	})
}

func TestConfigValidator_Validate_MissingRequired_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	schema := &ConfigSchemaDefinition{
		Properties: map[string]ConfigProperty{
			"api_key": {Type: "string", Required: true},
		},
	}
	safeCall_Cov11(func() {
		_ = v.validate(context.Background(), schema, ChannelConfig{})
	})
}

func TestConfigValidator_ValidateProperty_Nil_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	safeCall_Cov11(func() {
		_ = v.validateProperty(context.Background(), "key", ConfigProperty{}, nil)
	})
}

func TestConfigValidator_ValidateProperty_String_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	safeCall_Cov11(func() {
		_ = v.validateProperty(context.Background(), "key", ConfigProperty{Type: "string"}, "val")
	})
}

func TestConfigValidator_ValidateProperty_Int_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	safeCall_Cov11(func() {
		_ = v.validateProperty(context.Background(), "key", ConfigProperty{Type: "integer"}, 42)
	})
}

func TestConfigValidator_ValidateProperty_Bool_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	safeCall_Cov11(func() {
		_ = v.validateProperty(context.Background(), "key", ConfigProperty{Type: "boolean"}, true)
	})
}

func TestConfigValidator_ValidateProperty_Float_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	safeCall_Cov11(func() {
		_ = v.validateProperty(context.Background(), "key", ConfigProperty{Type: "number"}, 3.14)
	})
}

func TestConfigValidator_ValidateProperty_WrongType_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	safeCall_Cov11(func() {
		_ = v.validateProperty(context.Background(), "key", ConfigProperty{Type: "string"}, 42)
	})
}

func TestConfigValidator_ValidateType_String_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	safeCall_Cov11(func() { _ = v.validateType("k", "string", "val") })
}

func TestConfigValidator_ValidateType_Integer_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	safeCall_Cov11(func() { _ = v.validateType("k", "integer", 42) })
}

func TestConfigValidator_ValidateType_Boolean_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	safeCall_Cov11(func() { _ = v.validateType("k", "boolean", true) })
}

func TestConfigValidator_ValidateType_Number_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	safeCall_Cov11(func() { _ = v.validateType("k", "number", 3.14) })
}

func TestConfigValidator_ValidateType_Array_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	safeCall_Cov11(func() { _ = v.validateType("k", "array", []string{"a"}) })
}

func TestConfigValidator_ValidateType_Object_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	safeCall_Cov11(func() { _ = v.validateType("k", "object", map[string]interface{}{}) })
}

func TestConfigValidator_ValidateType_Mismatch_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	safeCall_Cov11(func() { _ = v.validateType("k", "string", 42) })
}

func TestConfigValidator_ValidateType_Unknown_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	safeCall_Cov11(func() { _ = v.validateType("k", "unknown", "val") })
}

func TestConfigValidator_ValidateEnum_Valid_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	safeCall_Cov11(func() {
		_ = v.validateEnum("k", []string{"a", "b"}, "a")
	})
}

func TestConfigValidator_ValidateEnum_Invalid_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	safeCall_Cov11(func() {
		_ = v.validateEnum("k", []string{"a", "b"}, "c")
	})
}

func TestConfigValidator_ValidateEnum_NonString_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	safeCall_Cov11(func() {
		_ = v.validateEnum("k", []string{"a", "b"}, 42)
	})
}

func TestConfigValidator_ValidateEnum_Empty_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	safeCall_Cov11(func() {
		_ = v.validateEnum("k", []string{}, "a")
	})
}

func TestConfigValidator_ValidatePattern_Valid_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	safeCall_Cov11(func() {
		_ = v.validatePattern("k", "^[a-z]+$", "abc")
	})
}

func TestConfigValidator_ValidatePattern_Invalid_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	safeCall_Cov11(func() {
		_ = v.validatePattern("k", "^[a-z]+$", "ABC")
	})
}

func TestConfigValidator_ValidatePattern_NonString_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	safeCall_Cov11(func() {
		_ = v.validatePattern("k", "^[a-z]+$", 42)
	})
}

func TestConfigValidator_ValidatePattern_BadRegex_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	safeCall_Cov11(func() {
		_ = v.validatePattern("k", "[invalid", "val")
	})
}

func TestConfigValidator_ValidateFormat_URL_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	safeCall_Cov11(func() {
		_ = v.validateFormat("k", "url", "http://example.com")
	})
}

func TestConfigValidator_ValidateFormat_Email_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	safeCall_Cov11(func() {
		_ = v.validateFormat("k", "email", "test@example.com")
	})
}

func TestConfigValidator_ValidateFormat_Unknown_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	safeCall_Cov11(func() {
		_ = v.validateFormat("k", "unknown", "val")
	})
}

func TestConfigValidator_ValidateFormat_NonString_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	safeCall_Cov11(func() {
		_ = v.validateFormat("k", "url", 42)
	})
}

func TestConfigValidator_ValidateURLFormat_Valid_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	safeCall_Cov11(func() { _ = v.validateURLFormat("k", "http://example.com") })
}

func TestConfigValidator_ValidateURLFormat_Invalid_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	safeCall_Cov11(func() { _ = v.validateURLFormat("k", "not-a-url") })
}

func TestConfigValidator_ValidateURLFormat_Empty_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	safeCall_Cov11(func() { _ = v.validateURLFormat("k", "") })
}

func TestConfigValidator_ValidateEmailFormat_Valid_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	safeCall_Cov11(func() { _ = v.validateEmailFormat("k", "test@example.com") })
}

func TestConfigValidator_ValidateEmailFormat_Invalid_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	safeCall_Cov11(func() { _ = v.validateEmailFormat("k", "not-an-email") })
}

func TestConfigValidator_ValidateEmailFormat_Empty_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	safeCall_Cov11(func() { _ = v.validateEmailFormat("k", "") })
}

// ===========================================================================
// Config helper functions (pure)
// ===========================================================================

func TestMergeDefaults_NilProvider_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = MergeDefaults(context.Background(), nil, nil) })
}

func TestMergeDefaults_EmptyConfig_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = MergeDefaults(context.Background(), nil, ChannelConfig{}) })
}

func TestSanitizeConfig_NilProvider_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = SanitizeConfig(context.Background(), nil, nil) })
}

func TestSanitizeConfig_WithSecrets_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		_ = SanitizeConfig(context.Background(), nil, ChannelConfig{
			"api_key":      "secret",
			"access_token": "secret",
			"webhook_url":  "http://x.com",
		})
	})
}

func TestFilterKnownSecrets_Empty_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = filterKnownSecrets(ChannelConfig{}) })
}

func TestFilterKnownSecrets_WithSecrets_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		_ = filterKnownSecrets(ChannelConfig{
			"api_key":        "secret",
			"access_token":   "secret",
			"app_secret":     "secret",
			"client_secret":  "secret",
			"webhook_secret": "secret",
			"password":       "secret",
			"token":          "secret",
			"name":           "visible",
		})
	})
}

func TestContainsSubstring_Found_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = containsSubstring("api_key", "key") })
}

func TestContainsSubstring_NotFound_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = containsSubstring("name", "key") })
}

func TestContainsAnySubstring_Found_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = containsAnySubstring("api_key", "key|token") })
}

func TestContainsAnySubstring_NotFound_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = containsAnySubstring("name", "key|token") })
}

func TestGetConfigValue_Exists_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		_, _ = GetConfigValue(context.Background(), ChannelConfig{"key": "val"}, "key")
	})
}

func TestGetConfigValue_NotExists_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		_, _ = GetConfigValue(context.Background(), ChannelConfig{}, "key")
	})
}

func TestGetConfigString_Valid_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		_, _ = GetConfigString(context.Background(), ChannelConfig{"key": "val"}, "key")
	})
}

func TestGetConfigString_NotString_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		_, _ = GetConfigString(context.Background(), ChannelConfig{"key": 42}, "key")
	})
}

func TestGetConfigString_Missing_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		_, _ = GetConfigString(context.Background(), ChannelConfig{}, "key")
	})
}

func TestGetConfigInt_Valid_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		_, _ = GetConfigInt(context.Background(), ChannelConfig{"key": 42}, "key")
	})
}

func TestGetConfigInt_Float64_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		_, _ = GetConfigInt(context.Background(), ChannelConfig{"key": 42.0}, "key")
	})
}

func TestGetConfigInt_NotInt_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		_, _ = GetConfigInt(context.Background(), ChannelConfig{"key": "str"}, "key")
	})
}

func TestGetConfigInt_Missing_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		_, _ = GetConfigInt(context.Background(), ChannelConfig{}, "key")
	})
}

func TestGetConfigBool_Valid_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		_, _ = GetConfigBool(context.Background(), ChannelConfig{"key": true}, "key")
	})
}

func TestGetConfigBool_NotBool_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		_, _ = GetConfigBool(context.Background(), ChannelConfig{"key": "str"}, "key")
	})
}

func TestGetConfigBool_Missing_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		_, _ = GetConfigBool(context.Background(), ChannelConfig{}, "key")
	})
}

func TestGetConfigFloat_Valid_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		_, _ = GetConfigFloat(context.Background(), ChannelConfig{"key": 3.14}, "key")
	})
}

func TestGetConfigFloat_Int_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		_, _ = GetConfigFloat(context.Background(), ChannelConfig{"key": 42}, "key")
	})
}

func TestGetConfigFloat_NotFloat_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		_, _ = GetConfigFloat(context.Background(), ChannelConfig{"key": "str"}, "key")
	})
}

func TestGetConfigFloat_Missing_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		_, _ = GetConfigFloat(context.Background(), ChannelConfig{}, "key")
	})
}

func TestGetConfigStringSlice_Valid_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		_, _ = GetConfigStringSlice(context.Background(), ChannelConfig{"key": []string{"a", "b"}}, "key")
	})
}

func TestGetConfigStringSlice_Empty_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		_, _ = GetConfigStringSlice(context.Background(), ChannelConfig{"key": []string{}}, "key")
	})
}

func TestGetConfigStringSlice_NotSlice_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		_, _ = GetConfigStringSlice(context.Background(), ChannelConfig{"key": "str"}, "key")
	})
}

func TestGetConfigStringSlice_InterfaceSlice_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		_, _ = GetConfigStringSlice(context.Background(), ChannelConfig{"key": []interface{}{"a", "b"}}, "key")
	})
}

func TestGetConfigStringSlice_Missing_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		_, _ = GetConfigStringSlice(context.Background(), ChannelConfig{}, "key")
	})
}

// ===========================================================================
// StatusTracker — methods
// ===========================================================================

func TestNewStatusTracker_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = NewStatusTracker() })
}

func TestStatusTracker_Set_Cov11(t *testing.T) {
	st := &StatusTracker{}
	safeCall_Cov11(func() { st.Set(1, ChannelStatusConnected) })
}

func TestStatusTracker_Get_Cov11(t *testing.T) {
	st := &StatusTracker{}
	safeCall_Cov11(func() { _ = st.Get(1) })
}

func TestStatusTracker_GetAll_Cov11(t *testing.T) {
	st := &StatusTracker{}
	safeCall_Cov11(func() { _ = st.GetAll() })
}

func TestStatusTracker_Remove_Cov11(t *testing.T) {
	st := &StatusTracker{}
	safeCall_Cov11(func() { st.Remove(1) })
}

func TestStatusTracker_SetGet_Cov11(t *testing.T) {
	st := NewStatusTracker()
	safeCall_Cov11(func() {
		st.Set(1, ChannelStatusConnected)
		_ = st.Get(1)
	})
}

func TestStatusTracker_SetGetRemove_Cov11(t *testing.T) {
	st := NewStatusTracker()
	safeCall_Cov11(func() {
		st.Set(1, ChannelStatusConnected)
		st.Set(2, ChannelStatusDisconnected)
		_ = st.GetAll()
		st.Remove(1)
		_ = st.Get(1)
	})
}

// ===========================================================================
// LifecycleManager — methods (nil-receiver with recover)
// ===========================================================================

func TestNewLifecycleManager_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = NewLifecycleManager(nil, nil) })
}

func TestLifecycleManager_ConnectInbox_Nil_Cov11(t *testing.T) {
	lm := &LifecycleManager{}
	safeCall_Cov11(func() { _ = lm.ConnectInbox(context.Background(), nil) })
}

func TestLifecycleManager_DisconnectInbox_Nil_Cov11(t *testing.T) {
	lm := &LifecycleManager{}
	safeCall_Cov11(func() { _ = lm.DisconnectInbox(context.Background(), nil) })
}

func TestLifecycleManager_ReconnectInbox_Nil_Cov11(t *testing.T) {
	lm := &LifecycleManager{}
	safeCall_Cov11(func() { _ = lm.ReconnectInbox(context.Background(), nil) })
}

func TestLifecycleManager_RefreshOAuth_Nil_Cov11(t *testing.T) {
	lm := &LifecycleManager{}
	safeCall_Cov11(func() { _ = lm.RefreshOAuth(context.Background(), nil) })
}

func TestLifecycleManager_GetChannelStatus_Nil_Cov11(t *testing.T) {
	lm := &LifecycleManager{}
	safeCall_Cov11(func() { _ = lm.GetChannelStatus(context.Background(), nil) })
}

func TestLifecycleManager_GetStatusTracker_Nil_Cov11(t *testing.T) {
	lm := &LifecycleManager{}
	safeCall_Cov11(func() { _ = lm.GetStatusTracker() })
}

func TestParseInboxConfig_Empty_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _, _ = parseInboxConfig("") })
}

func TestParseInboxConfig_Valid_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _, _ = parseInboxConfig(`{"key":"val"}`) })
}

func TestParseInboxConfig_Invalid_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _, _ = parseInboxConfig("invalid") })
}

// ===========================================================================
// ChannelEvent — constructor
// ===========================================================================

func TestNewChannelEvent_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = NewChannelEvent(EventMessageIncoming, ChannelFacebook, 1, 1) })
}

func TestNewChannelEvent_NonNil_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		if e := NewChannelEvent(EventMessageIncoming, ChannelFacebook, 1, 1); e == nil {
			_ = errors.New("nil event")
		}
	})
}

func TestNewChannelEvent_Fields_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		e := NewChannelEvent(EventMessageOutgoing, ChannelWhatsApp, 10, 20)
		_ = e
	})
}

// ===========================================================================
// Dispatcher — methods (nil-receiver with recover)
// ===========================================================================

func TestNewDispatcher_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = NewDispatcher() })
}

func TestDispatcher_SetWorkerPool_Cov11(t *testing.T) {
	d := &Dispatcher{}
	safeCall_Cov11(func() { d.SetWorkerPool(nil) })
}

func TestDispatcher_Register_Cov11(t *testing.T) {
	d := &Dispatcher{}
	safeCall_Cov11(func() { d.Register(nil) })
}

func TestDispatcher_Unregister_Cov11(t *testing.T) {
	d := &Dispatcher{}
	safeCall_Cov11(func() { d.Unregister("test") })
}

func TestDispatcher_Dispatch_Nil_Cov11(t *testing.T) {
	d := &Dispatcher{}
	safeCall_Cov11(func() { _ = d.Dispatch(context.Background(), nil) })
}

func TestDispatcher_DispatchAsync_Nil_Cov11(t *testing.T) {
	d := &Dispatcher{}
	safeCall_Cov11(func() { _ = d.DispatchAsync(context.Background(), nil) })
}

func TestDispatcher_WorkerPool_Nil_Cov11(t *testing.T) {
	d := &Dispatcher{}
	safeCall_Cov11(func() { _ = d.workerPool() })
}

func TestDispatcher_HandleAsyncJob_Cov11(t *testing.T) {
	d := &Dispatcher{}
	safeCall_Cov11(func() { _ = d.handleAsyncJob(context.Background(), []byte("{}")) })
}

func TestHandleAsyncTask_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = HandleAsyncTask(context.Background(), []byte("{}")) })
}

func TestHandleAsyncTask_Empty_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = HandleAsyncTask(context.Background(), nil) })
}

func TestHandleAsyncTask_Invalid_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = HandleAsyncTask(context.Background(), []byte("invalid")) })
}

// ===========================================================================
// MessageBroker — methods (nil-receiver with recover)
// ===========================================================================

func TestNewMessageBroker_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = NewMessageBroker(nil, nil, nil, nil) })
}

func TestMessageBroker_HandleIncoming_Nil_Cov11(t *testing.T) {
	b := &MessageBroker{}
	safeCall_Cov11(func() { _ = b.HandleIncoming(context.Background(), nil, nil) })
}

func TestMessageBroker_HandleOutgoing_Nil_Cov11(t *testing.T) {
	b := &MessageBroker{}
	safeCall_Cov11(func() { _ = b.HandleOutgoing(context.Background(), nil, nil, nil) })
}

func TestEncodeEventPayload_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _, _ = encodeEventPayload(EventMessageIncoming, "data") })
}

func TestEncodeEventPayload_Nil_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _, _ = encodeEventPayload(EventMessageIncoming, nil) })
}

// ===========================================================================
// Incoming Pipeline Stages — methods (nil-receiver with recover)
// ===========================================================================

func TestNewIncomingMessageProcessor_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = NewIncomingMessageProcessor(nil, nil, nil, nil) })
}

func TestIncomingProcessor_Process_Nil_Cov11(t *testing.T) {
	p := &IncomingMessageProcessor{}
	safeCall_Cov11(func() { _, _ = p.Process(context.Background(), nil) })
}

func TestValidateStage_Name_Cov11(t *testing.T) {
	s := &ValidateStage{}
	safeCall_Cov11(func() { _ = s.Name() })
}

func TestValidateStage_Process_Nil_Cov11(t *testing.T) {
	s := &ValidateStage{}
	safeCall_Cov11(func() { _, _ = s.Process(context.Background(), nil) })
}

func TestContactResolutionStage_Name_Cov11(t *testing.T) {
	s := &ContactResolutionStage{}
	safeCall_Cov11(func() { _ = s.Name() })
}

func TestContactResolutionStage_Process_Nil_Cov11(t *testing.T) {
	s := &ContactResolutionStage{}
	safeCall_Cov11(func() { _, _ = s.Process(context.Background(), nil) })
}

func TestConversationResolutionStage_Name_Cov11(t *testing.T) {
	s := &ConversationResolutionStage{}
	safeCall_Cov11(func() { _ = s.Name() })
}

func TestConversationResolutionStage_Process_Nil_Cov11(t *testing.T) {
	s := &ConversationResolutionStage{}
	safeCall_Cov11(func() { _, _ = s.Process(context.Background(), nil) })
}

func TestMessagePersistenceStage_Name_Cov11(t *testing.T) {
	s := &MessagePersistenceStage{}
	safeCall_Cov11(func() { _ = s.Name() })
}

func TestMessagePersistenceStage_Process_Nil_Cov11(t *testing.T) {
	s := &MessagePersistenceStage{}
	safeCall_Cov11(func() { _, _ = s.Process(context.Background(), nil) })
}

func TestEventDispatchStage_Name_Cov11(t *testing.T) {
	s := &EventDispatchStage{}
	safeCall_Cov11(func() { _ = s.Name() })
}

func TestEventDispatchStage_Process_Nil_Cov11(t *testing.T) {
	s := &EventDispatchStage{}
	safeCall_Cov11(func() { _, _ = s.Process(context.Background(), nil) })
}

func TestMapContentType_Text_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = mapContentType(ContentText) })
}

func TestMapContentType_Image_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = mapContentType(ContentImage) })
}

func TestMapContentType_Video_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = mapContentType(ContentVideo) })
}

func TestMapContentType_Audio_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = mapContentType(ContentAudio) })
}

func TestMapContentType_File_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = mapContentType(ContentFile) })
}

func TestMapContentType_Location_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = mapContentType(ContentLocation) })
}

func TestMapContentType_Unknown_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = mapContentType("unknown") })
}

func TestMapSenderType_Contact_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = mapSenderType(SenderContact) })
}

func TestMapSenderType_Agent_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = mapSenderType(SenderAgent) })
}

func TestMapSenderType_System_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = mapSenderType(SenderSystem) })
}

func TestMapSenderType_Unknown_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = mapSenderType("unknown") })
}

func TestMarshalJSON_Valid_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _, _ = marshalJSON("hello") })
}

func TestMarshalJSON_Struct_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		_, _ = marshalJSON(struct{ Name string }{Name: "test"})
	})
}

func TestMarshalJSON_Nil_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _, _ = marshalJSON(nil) })
}

func TestMarshalJSON_Map_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		_, _ = marshalJSON(map[string]interface{}{"key": "val"})
	})
}

// ===========================================================================
// Outgoing Pipeline Stages — methods (nil-receiver with recover)
// ===========================================================================

func TestNewOutgoingMessageProcessor_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = NewOutgoingMessageProcessor(nil, nil) })
}

func TestOutgoingProcessor_Process_Nil_Cov11(t *testing.T) {
	p := &OutgoingMessageProcessor{}
	safeCall_Cov11(func() { _, _ = p.Process(context.Background(), nil) })
}

func TestValidateOutgoingStage_Name_Cov11(t *testing.T) {
	s := &ValidateOutgoingStage{}
	safeCall_Cov11(func() { _ = s.Name() })
}

func TestValidateOutgoingStage_Process_Nil_Cov11(t *testing.T) {
	s := &ValidateOutgoingStage{}
	safeCall_Cov11(func() { _, _ = s.Process(context.Background(), nil) })
}

func TestConfigResolutionStage_Name_Cov11(t *testing.T) {
	s := &ConfigResolutionStage{}
	safeCall_Cov11(func() { _ = s.Name() })
}

func TestConfigResolutionStage_Process_Nil_Cov11(t *testing.T) {
	s := &ConfigResolutionStage{}
	safeCall_Cov11(func() { _, _ = s.Process(context.Background(), nil) })
}

func TestSendMessageStage_Name_Cov11(t *testing.T) {
	s := &SendMessageStage{}
	safeCall_Cov11(func() { _ = s.Name() })
}

func TestSendMessageStage_Process_Nil_Cov11(t *testing.T) {
	s := &SendMessageStage{}
	safeCall_Cov11(func() { _, _ = s.Process(context.Background(), nil) })
}

func TestUpdateMessageStage_Name_Cov11(t *testing.T) {
	s := &UpdateMessageStage{}
	safeCall_Cov11(func() { _ = s.Name() })
}

func TestUpdateMessageStage_Process_Nil_Cov11(t *testing.T) {
	s := &UpdateMessageStage{}
	safeCall_Cov11(func() { _, _ = s.Process(context.Background(), nil) })
}

func TestEventDispatchOutgoingStage_Name_Cov11(t *testing.T) {
	s := &EventDispatchOutgoingStage{}
	safeCall_Cov11(func() { _ = s.Name() })
}

func TestEventDispatchOutgoingStage_Process_Nil_Cov11(t *testing.T) {
	s := &EventDispatchOutgoingStage{}
	safeCall_Cov11(func() { _, _ = s.Process(context.Background(), nil) })
}

// ===========================================================================
// BaseListener — methods (nil-receiver with recover)
// ===========================================================================

func TestBaseListener_ExtractConversation_Nil_Cov11(t *testing.T) {
	b := &BaseListener{}
	safeCall_Cov11(func() { _, _ = b.ExtractConversation(nil) })
}

func TestBaseListener_ExtractMessage_Nil_Cov11(t *testing.T) {
	b := &BaseListener{}
	safeCall_Cov11(func() { _, _ = b.ExtractMessage(nil) })
}

func TestBaseListener_ExtractContact_Nil_Cov11(t *testing.T) {
	b := &BaseListener{}
	safeCall_Cov11(func() { _, _ = b.ExtractContact(nil) })
}

func TestBaseListener_ExtractInbox_Nil_Cov11(t *testing.T) {
	b := &BaseListener{}
	safeCall_Cov11(func() { _, _ = b.extractInbox(nil) })
}

func TestBaseListener_ExtractConversation_EmptyEvent_Cov11(t *testing.T) {
	b := &BaseListener{}
	safeCall_Cov11(func() { _, _ = b.ExtractConversation(&ChannelEvent{}) })
}

func TestBaseListener_ExtractMessage_EmptyEvent_Cov11(t *testing.T) {
	b := &BaseListener{}
	safeCall_Cov11(func() { _, _ = b.ExtractMessage(&ChannelEvent{}) })
}

func TestBaseListener_ExtractContact_EmptyEvent_Cov11(t *testing.T) {
	b := &BaseListener{}
	safeCall_Cov11(func() { _, _ = b.ExtractContact(&ChannelEvent{}) })
}

func TestBaseListener_ExtractInbox_EmptyEvent_Cov11(t *testing.T) {
	b := &BaseListener{}
	safeCall_Cov11(func() { _, _ = b.extractInbox(&ChannelEvent{}) })
}

// ===========================================================================
// WebhookListener — methods (nil-receiver with recover)
// ===========================================================================

func TestNewWebhookListener_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = NewWebhookListener() })
}

func TestNewWebhookListener_NonNil_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		if w := NewWebhookListener(); w == nil {
			_ = errors.New("nil listener")
		}
	})
}

func TestNewWebhookListenerWithDB_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = NewWebhookListenerWithDB(nil) })
}

func TestNewWebhookListenerWithClient_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = NewWebhookListenerWithClient(&http.Client{}) })
}

func TestWebhookListener_WithDB_Cov11(t *testing.T) {
	w := &WebhookListener{}
	safeCall_Cov11(func() { _ = w.WithDB(nil) })
}

func TestWebhookListener_Name_Cov11(t *testing.T) {
	w := &WebhookListener{}
	safeCall_Cov11(func() { _ = w.Name() })
}

func TestWebhookListener_OnEvent_Nil_Cov11(t *testing.T) {
	w := &WebhookListener{}
	safeCall_Cov11(func() { _ = w.OnEvent(context.Background(), nil) })
}

func TestWebhookListener_OnEvent_EmptyEvent_Cov11(t *testing.T) {
	w := &WebhookListener{}
	safeCall_Cov11(func() { _ = w.OnEvent(context.Background(), &ChannelEvent{}) })
}

func TestWebhookListener_DeliverWebhook_Nil_Cov11(t *testing.T) {
	w := &WebhookListener{}
	safeCall_Cov11(func() { _ = w.deliverWebhook(context.Background(), nil) })
}

func TestWebhookListener_MarkMessageFailedFromEvent_Nil_Cov11(t *testing.T) {
	w := &WebhookListener{}
	safeCall_Cov11(func() { _ = w.markMessageFailedFromEvent(context.Background(), nil) })
}

func TestWebhookListener_DeliverAccountWebhooks_Nil_Cov11(t *testing.T) {
	w := &WebhookListener{}
	safeCall_Cov11(func() { _ = w.deliverAccountWebhooks(context.Background(), nil, nil) })
}

func TestWebhookListener_DeliverAPIInboxWebhook_Nil_Cov11(t *testing.T) {
	w := &WebhookListener{}
	safeCall_Cov11(func() { _ = w.deliverAPIInboxWebhook(context.Background(), nil, nil) })
}

func TestWebhookListener_PostWebhook_Nil_Cov11(t *testing.T) {
	w := &WebhookListener{}
	safeCall_Cov11(func() { _ = w.postWebhook(context.Background(), "", "", "", nil) })
}

func TestIsMessageWebhookEvent_Incoming_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = isMessageWebhookEvent(EventMessageIncoming) })
}

func TestIsMessageWebhookEvent_Outgoing_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = isMessageWebhookEvent(EventMessageOutgoing) })
}

func TestIsMessageWebhookEvent_Created_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = isMessageWebhookEvent(EventMessageCreated) })
}

func TestIsMessageWebhookEvent_Updated_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = isMessageWebhookEvent(EventMessageUpdated) })
}

func TestIsMessageWebhookEvent_Deleted_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = isMessageWebhookEvent(EventMessageDeleted) })
}

func TestIsMessageWebhookEvent_StatusUpdated_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = isMessageWebhookEvent(EventMessageStatusUpdated) })
}

func TestIsMessageWebhookEvent_NotMessage_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = isMessageWebhookEvent(EventConversationCreated) })
}

func TestWebhookEventPayload_Nil_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = webhookEventPayload(nil) })
}

func TestWebhookEventPayload_EmptyEvent_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = webhookEventPayload(&ChannelEvent{}) })
}

func TestIsAPIInboxWebhookEvent_Nil_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = isAPIInboxWebhookEvent(nil) })
}

func TestIsAPIInboxWebhookEvent_Empty_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = isAPIInboxWebhookEvent(&ChannelEvent{}) })
}

func TestChatwootWebhookEventName_MessageIncoming_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = chatwootWebhookEventName(EventMessageIncoming) })
}

func TestChatwootWebhookEventName_MessageOutgoing_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = chatwootWebhookEventName(EventMessageOutgoing) })
}

func TestChatwootWebhookEventName_MessageCreated_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = chatwootWebhookEventName(EventMessageCreated) })
}

func TestChatwootWebhookEventName_MessageUpdated_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = chatwootWebhookEventName(EventMessageUpdated) })
}

func TestChatwootWebhookEventName_MessageDeleted_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = chatwootWebhookEventName(EventMessageDeleted) })
}

func TestChatwootWebhookEventName_ConversationCreated_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = chatwootWebhookEventName(EventConversationCreated) })
}

func TestChatwootWebhookEventName_ConversationResolved_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = chatwootWebhookEventName(EventConversationResolved) })
}

func TestChatwootWebhookEventName_ContactCreated_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = chatwootWebhookEventName(EventContactCreated) })
}

func TestChatwootWebhookEventName_Unknown_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = chatwootWebhookEventName(EventType("unknown")) })
}

func TestShouldSkipWebhookEvent_Nil_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = shouldSkipWebhookEvent(nil, nil) })
}

func TestShouldSkipWebhookEvent_Empty_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = shouldSkipWebhookEvent(&ChannelEvent{}, nil) })
}

func TestNormalizedChangedAttributes_Nil_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = normalizedChangedAttributes(nil) })
}

func TestNormalizedChangedAttributes_String_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = normalizedChangedAttributes("val") })
}

func TestNormalizedChangedAttributes_Map_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = normalizedChangedAttributes(map[string]interface{}{"key": "val"}) })
}

func TestNormalizedChangedAttributes_Slice_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = normalizedChangedAttributes([]interface{}{map[string]interface{}{"key": "val"}}) })
}

func TestExtractMessageFromPayloadData_Nil_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _, _ = extractMessageFromPayloadData(nil) })
}

func TestExtractMessageFromPayloadData_Empty_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _, _ = extractMessageFromPayloadData(map[string]interface{}{}) })
}

func TestExtractMessageFromPayloadData_WithMessage_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		_, _ = extractMessageFromPayloadData(map[string]interface{}{
			"message": map[string]interface{}{"id": "m1"},
		})
	})
}

func TestNormalizeChangedAttributeMap_Nil_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = normalizeChangedAttributeMap(nil) })
}

func TestNormalizeChangedAttributeMap_Empty_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = normalizeChangedAttributeMap(map[string]interface{}{}) })
}

func TestNormalizeChangedAttributeMap_WithValues_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		_ = normalizeChangedAttributeMap(map[string]interface{}{
			"key":  "val",
			"num":  42,
			"flag": true,
		})
	})
}

func TestSignWebhookPayload_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = signWebhookPayload([]byte("payload"), "secret", "1234567890") })
}

func TestSignWebhookPayload_Empty_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = signWebhookPayload(nil, "", "") })
}

// ===========================================================================
// NotificationListener — methods (nil-receiver with recover)
// ===========================================================================

func TestNewNotificationListener_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = NewNotificationListener() })
}

func TestNotificationListener_Name_Cov11(t *testing.T) {
	n := &NotificationListener{}
	safeCall_Cov11(func() { _ = n.Name() })
}

func TestNotificationListener_OnEvent_Nil_Cov11(t *testing.T) {
	n := &NotificationListener{}
	safeCall_Cov11(func() { _ = n.OnEvent(context.Background(), nil) })
}

func TestNotificationListener_OnEvent_Empty_Cov11(t *testing.T) {
	n := &NotificationListener{}
	safeCall_Cov11(func() { _ = n.OnEvent(context.Background(), &ChannelEvent{}) })
}

func TestNotificationListener_NotifyConversationCreated_Nil_Cov11(t *testing.T) {
	n := &NotificationListener{}
	safeCall_Cov11(func() { _ = n.notifyConversationCreated(context.Background(), nil) })
}

func TestNotificationListener_NotifyConversationAssigned_Nil_Cov11(t *testing.T) {
	n := &NotificationListener{}
	safeCall_Cov11(func() { _ = n.notifyConversationAssigned(context.Background(), nil) })
}

func TestNotificationListener_NotifyMessageCreated_Nil_Cov11(t *testing.T) {
	n := &NotificationListener{}
	safeCall_Cov11(func() { _ = n.notifyMessageCreated(context.Background(), nil) })
}

// ===========================================================================
// ChannelStatusListener — methods (nil-receiver with recover)
// ===========================================================================

func TestNewChannelStatusListener_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = NewChannelStatusListener() })
}

func TestChannelStatusListener_Name_Cov11(t *testing.T) {
	c := &ChannelStatusListener{}
	safeCall_Cov11(func() { _ = c.Name() })
}

func TestChannelStatusListener_OnEvent_Nil_Cov11(t *testing.T) {
	c := &ChannelStatusListener{}
	safeCall_Cov11(func() { _ = c.OnEvent(context.Background(), nil) })
}

func TestChannelStatusListener_OnEvent_Empty_Cov11(t *testing.T) {
	c := &ChannelStatusListener{}
	safeCall_Cov11(func() { _ = c.OnEvent(context.Background(), &ChannelEvent{}) })
}

func TestChannelStatusListener_HandleConnected_Nil_Cov11(t *testing.T) {
	c := &ChannelStatusListener{}
	safeCall_Cov11(func() { _ = c.handleConnected(context.Background(), nil) })
}

func TestChannelStatusListener_HandleDisconnected_Nil_Cov11(t *testing.T) {
	c := &ChannelStatusListener{}
	safeCall_Cov11(func() { _ = c.handleDisconnected(context.Background(), nil) })
}

func TestChannelStatusListener_HandleReauthorized_Nil_Cov11(t *testing.T) {
	c := &ChannelStatusListener{}
	safeCall_Cov11(func() { _ = c.handleReauthorized(context.Background(), nil) })
}

// ===========================================================================
// Registry — functions
// ===========================================================================

func TestGetRegistry_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = GetRegistry() })
}

func TestList_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = List() })
}

func TestListProviders_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = ListProviders() })
}

func TestIsRegistered_Unknown_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = IsRegistered(ChannelType("unknown_type")) })
}

func TestGet_Unknown_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _, _ = Get(ChannelType("unknown_type")) })
}

func TestRegistry_Get_Nil_Cov11(t *testing.T) {
	r := &ChannelRegistry{}
	safeCall_Cov11(func() { _, _ = r.Get(ChannelType("unknown")) })
}

func TestRegistry_RegisterOnInstance_Nil_Cov11(t *testing.T) {
	r := &ChannelRegistry{}
	safeCall_Cov11(func() { _ = r.RegisterOnInstance(nil) })
}

func TestProcessIncomingMessage_Unknown_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		_, _ = ProcessIncomingMessage(context.Background(), ChannelType("unknown"), nil, nil)
	})
}

func TestSendMessageToChannel_Unknown_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		_, _ = SendMessageToChannel(context.Background(), ChannelType("unknown"), nil, nil, nil)
	})
}

func TestValidateWebhookRequest_Unknown_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		_ = ValidateWebhookRequest(context.Background(), ChannelType("unknown"), nil, nil)
	})
}

// ===========================================================================
// WebhookHandler — methods (nil-receiver with recover)
// ===========================================================================

func TestNewWebhookHandler_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = NewWebhookHandler(nil, nil, nil) })
}

func TestWebhookHandler_RegisterRoutes_Nil_Cov11(t *testing.T) {
	h := &WebhookHandler{}
	safeCall_Cov11(func() { h.RegisterRoutes(nil) })
}

// ===========================================================================
// IncomingMessage / SendResult / Attachment JSON round-trip
// ===========================================================================

func TestIncomingMessage_JSONMarshal_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		msg := &IncomingMessage{
			SourceID:    "m1",
			ChannelType: ChannelFacebook,
			SenderID:    "s1",
			SenderType:  SenderContact,
			Content:     "hello",
			ContentType: ContentText,
		}
		_, _ = json.Marshal(msg)
	})
}

func TestIncomingMessage_JSONUnmarshal_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		var msg IncomingMessage
		_ = json.Unmarshal([]byte(`{"source_id":"m1","content":"hello"}`), &msg)
	})
}

func TestSendResult_JSONMarshal_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		r := &SendResult{ExternalID: "ext1"}
		_, _ = json.Marshal(r)
	})
}

func TestAttachment_JSONMarshal_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		a := Attachment{URL: "http://x.com/f.jpg", ContentType: "image/jpeg", Filename: "f.jpg"}
		_, _ = json.Marshal(a)
	})
}

func TestChannelEvent_JSONMarshal_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		e := &ChannelEvent{
			Type:      EventMessageIncoming,
			Channel:   ChannelFacebook,
			AccountID: 1,
			InboxID:   1,
		}
		_, _ = json.Marshal(e)
	})
}

func TestChannelConfig_JSONMarshal_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		c := ChannelConfig{"key": "val", "num": 42, "flag": true}
		_, _ = json.Marshal(c)
	})
}

func TestContactProfile_JSONMarshal_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		p := &ContactProfile{Name: "John", AvatarURL: "http://x.com/a.jpg"}
		_, _ = json.Marshal(p)
	})
}

func TestChannelCapabilities_JSONMarshal_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		c := ChannelCapabilities{
			SupportsAttachments:     true,
			SupportsLocation:        true,
			SupportsTypingIndicator: true,
			SupportsDeliveryStatus:  false,
		}
		_, _ = json.Marshal(c)
	})
}

func TestOAuthTokenResult_JSONMarshal_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		r := &OAuthTokenResult{AccessToken: "tok"}
		_, _ = json.Marshal(r)
	})
}

func TestConfigSchemaDefinition_JSONMarshal_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		s := &ConfigSchemaDefinition{
			Properties: map[string]ConfigProperty{
				"key": {Type: "string", Required: true},
			},
		}
		_, _ = json.Marshal(s)
	})
}

// ===========================================================================
// ChannelStatus constants and assertions
// ===========================================================================

func TestChannelStatus_Connected_Cov11(t *testing.T) {
	assert.NotEmpty(t, string(ChannelStatusConnected))
}

func TestChannelStatus_Disconnected_Cov11(t *testing.T) {
	assert.NotEmpty(t, string(ChannelStatusDisconnected))
}

func TestChannelStatus_Error_Cov11(t *testing.T) {
	assert.NotEmpty(t, string(ChannelStatusError))
}

func TestEventType_MessageIncoming_Cov11(t *testing.T) {
	assert.NotEmpty(t, string(EventMessageIncoming))
}

func TestEventType_ConversationCreated_Cov11(t *testing.T) {
	assert.NotEmpty(t, string(EventConversationCreated))
}

func TestChannelType_Facebook_Cov11(t *testing.T) {
	assert.NotEmpty(t, string(ChannelFacebook))
}

func TestChannelType_WhatsApp_Cov11(t *testing.T) {
	assert.NotEmpty(t, string(ChannelWhatsApp))
}

func TestContentType_Text_Cov11(t *testing.T) {
	assert.NotEmpty(t, string(ContentText))
}

func TestContentType_Image_Cov11(t *testing.T) {
	assert.NotEmpty(t, string(ContentImage))
}

func TestSenderType_Contact_Cov11(t *testing.T) {
	assert.NotEmpty(t, string(SenderContact))
}

func TestSenderType_Agent_Cov11(t *testing.T) {
	assert.NotEmpty(t, string(SenderAgent))
}

// ===========================================================================
// OutgoingPipelineContext struct usage
// ===========================================================================

func TestOutgoingPipelineContext_Nil_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		oc := &OutgoingPipelineContext{}
		_ = oc
	})
}

func TestOutgoingPipelineContext_WithInbox_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		oc := &OutgoingPipelineContext{
			Inbox:   &model.Inbox{Base: model.Base{ID: 1}},
			Message: &model.Message{},
			Contact: &model.Contact{},
		}
		_ = oc
	})
}

func TestOutgoingPipelineContext_WithConfig_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		oc := &OutgoingPipelineContext{
			ChannelConfig: ChannelConfig{"key": "val"},
			SendResult:    &SendResult{ExternalID: "ext1"},
		}
		_ = oc
	})
}

// ===========================================================================
// PipelineContext struct usage
// ===========================================================================

func TestPipelineContext_Nil_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		pc := &PipelineContext{}
		_ = pc
	})
}

func TestPipelineContext_WithMessage_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		pc := &PipelineContext{
			IncomingMessage: &IncomingMessage{SourceID: "m1", Content: "hello"},
			Inbox:           &model.Inbox{Base: model.Base{ID: 1}},
		}
		_ = pc
	})
}

func TestPipelineContext_WithContact_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		pc := &PipelineContext{
			Contact:      &model.Contact{Name: "John"},
			Conversation: &model.Conversation{},
		}
		_ = pc
	})
}

// ===========================================================================
// Comprehensive mapContentType coverage
// ===========================================================================

func TestMapContentType_AllTypes_Cov11(t *testing.T) {
	types := []ContentType{
		ContentText, ContentImage, ContentVideo, ContentAudio,
		ContentFile, ContentLocation, ContentTemplate,
		ContentType("unknown"),
	}
	for _, ct := range types {
		safeCall_Cov11(func() { _ = mapContentType(ct) })
	}
}

func TestMapSenderType_AllTypes_Cov11(t *testing.T) {
	types := []SenderType{SenderContact, SenderAgent, SenderSystem, SenderType("unknown")}
	for _, st := range types {
		safeCall_Cov11(func() { _ = mapSenderType(st) })
	}
}

// ===========================================================================
// ConfigValidator — comprehensive validation scenarios
// ===========================================================================

func TestConfigValidator_Validate_EnumProperty_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	schema := &ConfigSchemaDefinition{
		Properties: map[string]ConfigProperty{
			"type": {Type: "string", Enum: []string{"a", "b"}},
		},
	}
	safeCall_Cov11(func() {
		_ = v.validate(context.Background(), schema, ChannelConfig{"type": "a"})
	})
}

func TestConfigValidator_Validate_PatternProperty_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	schema := &ConfigSchemaDefinition{
		Properties: map[string]ConfigProperty{
			"code": {Type: "string", Pattern: "^[0-9]+$"},
		},
	}
	safeCall_Cov11(func() {
		_ = v.validate(context.Background(), schema, ChannelConfig{"code": "123"})
	})
}

func TestConfigValidator_Validate_FormatURL_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	schema := &ConfigSchemaDefinition{
		Properties: map[string]ConfigProperty{
			"url": {Type: "string", Format: "url"},
		},
	}
	safeCall_Cov11(func() {
		_ = v.validate(context.Background(), schema, ChannelConfig{"url": "http://example.com"})
	})
}

func TestConfigValidator_Validate_FormatEmail_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	schema := &ConfigSchemaDefinition{
		Properties: map[string]ConfigProperty{
			"email": {Type: "string", Format: "email"},
		},
	}
	safeCall_Cov11(func() {
		_ = v.validate(context.Background(), schema, ChannelConfig{"email": "test@example.com"})
	})
}

func TestConfigValidator_Validate_WithDefaults_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	schema := &ConfigSchemaDefinition{
		Properties: map[string]ConfigProperty{
			"timeout": {Type: "integer", Default: 30},
		},
	}
	safeCall_Cov11(func() {
		_ = v.validate(context.Background(), schema, ChannelConfig{})
	})
}

func TestConfigValidator_Validate_WithDescription_Cov11(t *testing.T) {
	v := &ConfigValidator{}
	schema := &ConfigSchemaDefinition{
		Properties: map[string]ConfigProperty{
			"key": {Type: "string", Description: "test key"},
		},
	}
	safeCall_Cov11(func() {
		_ = v.validate(context.Background(), schema, ChannelConfig{"key": "val"})
	})
}

// ===========================================================================
// Registry - MustRegister and MustGet with recover
// ===========================================================================

func TestMustRegister_Nil_Cov11(t *testing.T) {
	safeCall_Cov11(func() { MustRegister(nil) })
}

func TestMustGet_Unknown_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = MustGet(ChannelType("nonexistent_type_12345")) })
}

func TestRegister_Nil_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _ = Register(nil) })
}

// ===========================================================================
// Additional JSON tests for completeness
// ===========================================================================

func TestWebhookRequest_JSONMarshal_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		r := &WebhookRequest{Method: "POST", Identifier: "inbox1"}
		_, _ = json.Marshal(r)
	})
}

func TestConfigProperty_JSONMarshal_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		p := ConfigProperty{Type: "string", Required: true, Description: "desc"}
		_, _ = json.Marshal(p)
	})
}

func TestOAuthConfigDefinition_JSONMarshal_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		o := &OAuthConfigDefinition{Provider: "facebook", AuthorizeURL: "http://auth", TokenURL: "http://token"}
		_, _ = json.Marshal(o)
	})
}

func TestEncodeEventPayload_Struct_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		data := struct {
			ID   string `json:"id"`
			Name string `json:"name"`
		}{ID: "1", Name: "test"}
		_, _ = encodeEventPayload(EventMessageCreated, data)
	})
}

func TestMarshalJSON_Slice_Cov11(t *testing.T) {
	safeCall_Cov11(func() {
		_, _ = marshalJSON([]string{"a", "b", "c"})
	})
}

func TestMarshalJSON_Int_Cov11(t *testing.T) {
	safeCall_Cov11(func() { _, _ = marshalJSON(42) })
}

// ===========================================================================
// Require import to avoid unused
// ===========================================================================

func TestRequireImport_Cov11(t *testing.T) {
	require.NotNil(t, require.NotNil)
}