package cmd

import (
	"fmt"
	"testing"

	"github.com/stretchr/testify/require"

	"github.com/tidbcloud/AgentTeam/desktop/internal/agentview"
	"github.com/tidbcloud/AgentTeam/desktop/internal/daemon"
	"github.com/tidbcloud/AgentTeam/desktop/internal/operator"
	"github.com/tidbcloud/AgentTeam/desktop/internal/profile"
)

func TestChannelCmdHiddenCompatResolves(t *testing.T) {
	t.Parallel()

	require.Equal(t, "channel", channelCmd.Name(), "primary Use must stay \"channel\"")
	require.True(t, channelCmd.Hidden, "channel remains executable but hidden from help")
	require.NotContains(t, channelCmd.Aliases, "connection", "\"connection\" alias must not be registered")

	target, remaining, err := rootCmd.Find([]string{"channel"})
	require.NoError(t, err)
	require.Same(t, channelCmd, target)
	require.Empty(t, remaining)

	listTarget, listRemaining, err := rootCmd.Find([]string{"channel", "list"})
	require.NoError(t, err)
	require.Same(t, channelListCmd, listTarget)
	require.Empty(t, listRemaining)
}

func TestRunChannelConnectAddsAgentTeamChannelAndStartsDaemon(t *testing.T) {
	originalGetOperator := getOperator
	originalDaemonStatus := daemonStatus
	originalRunDaemonForeground := runDaemonForeground
	originalOpts := daemonOpts
	t.Cleanup(func() {
		getOperator = originalGetOperator
		daemonStatus = originalDaemonStatus
		runDaemonForeground = originalRunDaemonForeground
		daemonOpts = originalOpts
	})

	fakeChannels := &fakeChannelOperator{}
	getOperator = func() (operator.Operator, error) {
		return fakeOperator{servers: fakeChannels}, nil
	}
	daemonStatus = func() *daemon.Status { return &daemon.Status{} }

	daemonStarted := false
	runDaemonForeground = func() error {
		daemonStarted = true
		return nil
	}

	daemonOpts.connectType = "agentteam"
	daemonOpts.agentteamServerURL = "https://agentteam.example.com"
	daemonOpts.agentteamAPIKey = "key123"

	err := runDaemonCommand()
	require.NoError(t, err)
	require.True(t, daemonStarted)
	require.Len(t, fakeChannels.servers, 1)

	ch := fakeChannels.servers[0]
	require.True(t, ch.Enabled)
	require.Empty(t, ch.Name)

	cfg := configToMap(ch.Config)
	require.Equal(t, "https://agentteam.example.com", cfg["server_url"])
	require.Equal(t, "key123", cfg["api_key"])
	require.Equal(t, "wsp_1", cfg["workspace_id"])
	require.Equal(t, "mac_1", cfg["machine_id"])
}

func TestConnectAgentTeamChannelPersistsWorkspaceIDWhenProvided(t *testing.T) {
	t.Parallel()

	fakeChannels := &fakeChannelOperator{}
	ch, err := connectAgentTeamChannel(fakeChannels, "https://agentteam.example.com/", " key123 ", " wsp_1 ")
	require.NoError(t, err)
	require.Len(t, fakeChannels.servers, 1)
	require.Equal(t, ch.ID, fakeChannels.servers[0].ID)

	cfg := configToMap(fakeChannels.servers[0].Config)
	require.Equal(t, "https://agentteam.example.com", cfg["server_url"])
	require.Equal(t, "key123", cfg["api_key"])
	require.Equal(t, "wsp_1", cfg["workspace_id"])
}

func TestConnectAgentTeamChannelPreservesExistingWorkspaceIDForManualReconnect(t *testing.T) {
	t.Parallel()

	fakeChannels := &fakeChannelOperator{servers: []profile.AgentTeamServer{{
		ID:      "chn_existing",
		Enabled: false,
		Config: mapToRawMessage(map[string]interface{}{
			"server_url":   "https://agentteam.example.com",
			"api_key":      "key123",
			"workspace_id": "wsp_existing",
		}),
	}}}

	ch, err := connectAgentTeamChannel(fakeChannels, "https://agentteam.example.com", "key123", "")
	require.NoError(t, err)
	require.Equal(t, "chn_existing", ch.ID)
	require.True(t, fakeChannels.servers[0].Enabled)

	cfg := configToMap(fakeChannels.servers[0].Config)
	require.Equal(t, "wsp_existing", cfg["workspace_id"])
}

func TestConnectAgentTeamChannelReusesSingleInvalidChannelForWorkspace(t *testing.T) {
	t.Parallel()

	fakeChannels := &fakeChannelOperator{servers: []profile.AgentTeamServer{{
		ID:      "chn_existing",
		Enabled: false,
		Config: mapToRawMessage(map[string]interface{}{
			"server_url":        "https://agentteam.example.com",
			"api_key":           "old-key",
			"workspace_id":      "wsp_1",
			"connection_status": "invalid_machine_api_key",
		}),
	}}}

	ch, err := connectAgentTeamChannel(fakeChannels, "https://agentteam.example.com/", " new-key ", " wsp_1 ")
	require.NoError(t, err)
	require.Equal(t, "chn_existing", ch.ID)
	require.Len(t, fakeChannels.servers, 1)
	require.True(t, fakeChannels.servers[0].Enabled)

	cfg := configToMap(fakeChannels.servers[0].Config)
	require.Equal(t, "https://agentteam.example.com", cfg["server_url"])
	require.Equal(t, "new-key", cfg["api_key"])
	require.Equal(t, "wsp_1", cfg["workspace_id"])
	require.Nil(t, cfg["connection_status"])
}

func TestConnectAgentTeamChannelReusesSingleInvalidChannelWithoutStoredWorkspace(t *testing.T) {
	t.Parallel()

	fakeChannels := &fakeChannelOperator{servers: []profile.AgentTeamServer{{
		ID:      "chn_existing",
		Enabled: true,
		Config: mapToRawMessage(map[string]interface{}{
			"server_url":        "https://agentteam.example.com",
			"api_key":           "old-key",
			"connection_status": "invalid_machine_api_key",
		}),
	}}}

	ch, err := connectAgentTeamChannel(fakeChannels, "https://agentteam.example.com", "new-key", "wsp_1")
	require.NoError(t, err)
	require.Equal(t, "chn_existing", ch.ID)
	require.Len(t, fakeChannels.servers, 1)

	cfg := configToMap(fakeChannels.servers[0].Config)
	require.Equal(t, "new-key", cfg["api_key"])
	require.Equal(t, "wsp_1", cfg["workspace_id"])
	require.Nil(t, cfg["connection_status"])
}

func TestConnectAgentTeamChannelDoesNotReuseInvalidChannelWithoutWorkspaceMatch(t *testing.T) {
	t.Parallel()

	fakeChannels := &fakeChannelOperator{servers: []profile.AgentTeamServer{{
		ID:      "chn_existing",
		Enabled: true,
		Config: mapToRawMessage(map[string]interface{}{
			"server_url":        "https://agentteam.example.com",
			"api_key":           "old-key",
			"workspace_id":      "wsp_other",
			"connection_status": "invalid_machine_api_key",
		}),
	}}}

	ch, err := connectAgentTeamChannel(fakeChannels, "https://agentteam.example.com", "new-key", "wsp_1")
	require.NoError(t, err)
	require.NotEqual(t, "chn_existing", ch.ID)
	require.Len(t, fakeChannels.servers, 2)

	existingCfg := configToMap(fakeChannels.servers[0].Config)
	require.Equal(t, "old-key", existingCfg["api_key"])
	require.Equal(t, "invalid_machine_api_key", existingCfg["connection_status"])

	addedCfg := configToMap(fakeChannels.servers[1].Config)
	require.Equal(t, "new-key", addedCfg["api_key"])
	require.Equal(t, "wsp_1", addedCfg["workspace_id"])
}

func TestConnectAgentTeamChannelDoesNotReuseInvalidChannelWithoutIncomingWorkspace(t *testing.T) {
	t.Parallel()

	fakeChannels := &fakeChannelOperator{servers: []profile.AgentTeamServer{{
		ID:      "chn_existing",
		Enabled: true,
		Config: mapToRawMessage(map[string]interface{}{
			"server_url":        "https://agentteam.example.com",
			"api_key":           "old-key",
			"connection_status": "invalid_machine_api_key",
		}),
	}}}

	ch, err := connectAgentTeamChannel(fakeChannels, "https://agentteam.example.com", "new-key", "")
	require.NoError(t, err)
	require.NotEqual(t, "chn_existing", ch.ID)
	require.Len(t, fakeChannels.servers, 2)

	require.Equal(t, "old-key", configToMap(fakeChannels.servers[0].Config)["api_key"])
	require.Equal(t, "new-key", configToMap(fakeChannels.servers[1].Config)["api_key"])
	require.Nil(t, configToMap(fakeChannels.servers[1].Config)["workspace_id"])
}

func TestConnectAgentTeamChannelDoesNotReuseAmbiguousInvalidChannels(t *testing.T) {
	t.Parallel()

	fakeChannels := &fakeChannelOperator{servers: []profile.AgentTeamServer{
		{
			ID:      "chn_one",
			Enabled: true,
			Config: mapToRawMessage(map[string]interface{}{
				"server_url":        "https://agentteam.example.com",
				"api_key":           "old-key-1",
				"workspace_id":      "wsp_1",
				"connection_status": "invalid_machine_api_key",
			}),
		},
		{
			ID:      "chn_two",
			Enabled: true,
			Config: mapToRawMessage(map[string]interface{}{
				"server_url":        "https://agentteam.example.com",
				"api_key":           "old-key-2",
				"workspace_id":      "wsp_1",
				"connection_status": "invalid_machine_api_key",
			}),
		},
	}}

	ch, err := connectAgentTeamChannel(fakeChannels, "https://agentteam.example.com", "new-key", "wsp_1")
	require.NoError(t, err)
	require.NotEqual(t, "chn_one", ch.ID)
	require.NotEqual(t, "chn_two", ch.ID)
	require.Len(t, fakeChannels.servers, 3)
	require.Equal(t, "old-key-1", configToMap(fakeChannels.servers[0].Config)["api_key"])
	require.Equal(t, "old-key-2", configToMap(fakeChannels.servers[1].Config)["api_key"])
	require.Equal(t, "new-key", configToMap(fakeChannels.servers[2].Config)["api_key"])
}

func TestRunChannelConnectReusesExactAgentTeamChannelAndStartsDaemon(t *testing.T) {
	originalGetOperator := getOperator
	originalDaemonStatus := daemonStatus
	originalRunDaemonForeground := runDaemonForeground
	originalOpts := daemonOpts
	t.Cleanup(func() {
		getOperator = originalGetOperator
		daemonStatus = originalDaemonStatus
		runDaemonForeground = originalRunDaemonForeground
		daemonOpts = originalOpts
	})

	fakeChannels := &fakeChannelOperator{
		servers: []profile.AgentTeamServer{
			{
				ID:      "chn_existing",
				Enabled: false,
				Config: mapToRawMessage(map[string]interface{}{
					"server_url": "https://agentteam.example.com",
					"api_key":    "key123",
				}),
			},
			{
				ID:      "chn_other",
				Enabled: true,
				Config: mapToRawMessage(map[string]interface{}{
					"server_url": "https://other.example.com",
					"api_key":    "other-key",
				}),
			},
		},
	}
	getOperator = func() (operator.Operator, error) {
		return fakeOperator{servers: fakeChannels}, nil
	}
	daemonStatus = func() *daemon.Status { return &daemon.Status{} }

	daemonStarted := false
	runDaemonForeground = func() error {
		daemonStarted = true
		return nil
	}

	daemonOpts.connectType = "agentteam"
	daemonOpts.agentteamServerURL = "https://agentteam.example.com"
	daemonOpts.agentteamAPIKey = "key123"

	err := runDaemonCommand()
	require.NoError(t, err)
	require.True(t, daemonStarted)
	require.Len(t, fakeChannels.servers, 2)

	ch := fakeChannels.servers[0]
	require.Equal(t, "chn_existing", ch.ID)
	require.True(t, ch.Enabled)

	cfg := configToMap(ch.Config)
	require.Equal(t, "https://agentteam.example.com", cfg["server_url"])
	require.Equal(t, "key123", cfg["api_key"])

	require.Equal(t, "chn_other", fakeChannels.servers[1].ID)
	require.True(t, fakeChannels.servers[1].Enabled)
}

func TestRunChannelConnectAddsAgentTeamChannelWhenAPIKeyDiffersOnSameServer(t *testing.T) {
	originalGetOperator := getOperator
	originalDaemonStatus := daemonStatus
	originalRunDaemonForeground := runDaemonForeground
	originalOpts := daemonOpts
	t.Cleanup(func() {
		getOperator = originalGetOperator
		daemonStatus = originalDaemonStatus
		runDaemonForeground = originalRunDaemonForeground
		daemonOpts = originalOpts
	})

	fakeChannels := &fakeChannelOperator{
		servers: []profile.AgentTeamServer{
			{
				ID:      "chn_existing",
				Enabled: true,
				Config: mapToRawMessage(map[string]interface{}{
					"server_url": "https://agentteam.example.com",
					"api_key":    "old-key",
				}),
			},
		},
	}
	getOperator = func() (operator.Operator, error) {
		return fakeOperator{servers: fakeChannels}, nil
	}
	daemonStatus = func() *daemon.Status { return &daemon.Status{} }

	daemonStarted := false
	runDaemonForeground = func() error {
		daemonStarted = true
		return nil
	}

	daemonOpts.connectType = "agentteam"
	daemonOpts.agentteamServerURL = "https://agentteam.example.com"
	daemonOpts.agentteamAPIKey = "new-key"

	err := runDaemonCommand()
	require.NoError(t, err)
	require.True(t, daemonStarted)
	require.Len(t, fakeChannels.servers, 2)

	existing := fakeChannels.servers[0]
	require.Equal(t, "chn_existing", existing.ID)
	require.True(t, existing.Enabled)

	existingCfg := configToMap(existing.Config)
	require.Equal(t, "https://agentteam.example.com", existingCfg["server_url"])
	require.Equal(t, "old-key", existingCfg["api_key"])

	added := fakeChannels.servers[1]
	require.NotEqual(t, "chn_existing", added.ID)
	require.True(t, added.Enabled)

	addedCfg := configToMap(added.Config)
	require.Equal(t, "https://agentteam.example.com", addedCfg["server_url"])
	require.Equal(t, "new-key", addedCfg["api_key"])
}

func TestRunChannelConnectAddsNewAgentTeamChannelWhenServerDoesNotMatch(t *testing.T) {
	originalGetOperator := getOperator
	originalDaemonStatus := daemonStatus
	originalRunDaemonForeground := runDaemonForeground
	originalOpts := daemonOpts
	t.Cleanup(func() {
		getOperator = originalGetOperator
		daemonStatus = originalDaemonStatus
		runDaemonForeground = originalRunDaemonForeground
		daemonOpts = originalOpts
	})

	fakeChannels := &fakeChannelOperator{
		servers: []profile.AgentTeamServer{
			{
				ID:      "chn_existing",
				Enabled: true,
				Config: mapToRawMessage(map[string]interface{}{
					"server_url": "https://other.example.com",
					"api_key":    "old-key",
				}),
			},
		},
	}
	getOperator = func() (operator.Operator, error) {
		return fakeOperator{servers: fakeChannels}, nil
	}
	daemonStatus = func() *daemon.Status { return &daemon.Status{} }

	daemonStarted := false
	runDaemonForeground = func() error {
		daemonStarted = true
		return nil
	}

	daemonOpts.connectType = "agentteam"
	daemonOpts.agentteamServerURL = "https://agentteam.example.com"
	daemonOpts.agentteamAPIKey = "new-key"

	err := runDaemonCommand()
	require.NoError(t, err)
	require.True(t, daemonStarted)
	require.Len(t, fakeChannels.servers, 2)

	existing := fakeChannels.servers[0]
	require.Equal(t, "chn_existing", existing.ID)
	require.True(t, existing.Enabled)

	added := fakeChannels.servers[1]
	require.NotEqual(t, "chn_existing", added.ID)
	require.True(t, added.Enabled)
}

func TestRunChannelConnectDisablesOnlyExactDuplicateAgentTeamChannels(t *testing.T) {
	originalGetOperator := getOperator
	originalDaemonStatus := daemonStatus
	originalRunDaemonForeground := runDaemonForeground
	originalOpts := daemonOpts
	t.Cleanup(func() {
		getOperator = originalGetOperator
		daemonStatus = originalDaemonStatus
		runDaemonForeground = originalRunDaemonForeground
		daemonOpts = originalOpts
	})

	fakeChannels := &fakeChannelOperator{
		servers: []profile.AgentTeamServer{
			{
				ID:      "chn_one",
				Enabled: true,
				Config: mapToRawMessage(map[string]interface{}{
					"server_url": "https://agentteam.example.com",
					"api_key":    "new-key",
				}),
			},
			{
				ID:      "chn_two",
				Enabled: true,
				Config: mapToRawMessage(map[string]interface{}{
					"server_url": "https://agentteam.example.com",
					"api_key":    "new-key",
				}),
			},
			{
				ID:      "chn_other_machine",
				Enabled: true,
				Config: mapToRawMessage(map[string]interface{}{
					"server_url": "https://agentteam.example.com",
					"api_key":    "other-machine-key",
				}),
			},
		},
	}
	getOperator = func() (operator.Operator, error) {
		return fakeOperator{servers: fakeChannels}, nil
	}
	daemonStatus = func() *daemon.Status { return &daemon.Status{} }

	daemonStarted := false
	runDaemonForeground = func() error {
		daemonStarted = true
		return nil
	}

	daemonOpts.connectType = "agentteam"
	daemonOpts.agentteamServerURL = "https://agentteam.example.com"
	daemonOpts.agentteamAPIKey = "new-key"

	err := runDaemonCommand()
	require.NoError(t, err)
	require.True(t, daemonStarted)
	require.Len(t, fakeChannels.servers, 3)

	firstCfg := configToMap(fakeChannels.servers[0].Config)
	require.Equal(t, "https://agentteam.example.com", firstCfg["server_url"])
	require.Equal(t, "new-key", firstCfg["api_key"])
	require.True(t, fakeChannels.servers[0].Enabled)
	require.False(t, fakeChannels.servers[1].Enabled)
	require.True(t, fakeChannels.servers[2].Enabled)

	otherMachineCfg := configToMap(fakeChannels.servers[2].Config)
	require.Equal(t, "https://agentteam.example.com", otherMachineCfg["server_url"])
	require.Equal(t, "other-machine-key", otherMachineCfg["api_key"])
}

func TestRunChannelConnectAddsChannelWhileDaemonIsRunning(t *testing.T) {
	originalGetOperator := getOperator
	originalDaemonStatus := daemonStatus
	originalRunDaemonForeground := runDaemonForeground
	originalOpts := daemonOpts
	t.Cleanup(func() {
		getOperator = originalGetOperator
		daemonStatus = originalDaemonStatus
		runDaemonForeground = originalRunDaemonForeground
		daemonOpts = originalOpts
	})

	fakeChannels := &fakeChannelOperator{
		servers: []profile.AgentTeamServer{
			{
				ID:      "chn_existing",
				Enabled: true,
				Config: mapToRawMessage(map[string]interface{}{
					"server_url": "http://localhost:3001",
					"api_key":    "existing-key",
				}),
			},
		},
	}
	getOperator = func() (operator.Operator, error) {
		return fakeOperator{servers: fakeChannels}, nil
	}
	daemonStatus = func() *daemon.Status { return &daemon.Status{Running: true, Healthy: true, PID: 29563} }

	daemonStarted := false
	runDaemonForeground = func() error {
		daemonStarted = true
		return nil
	}

	daemonOpts.connectType = "agentteam"
	daemonOpts.agentteamServerURL = "http://localhost:3001"
	daemonOpts.agentteamAPIKey = "new-key"

	err := runDaemonCommand()
	require.NoError(t, err)
	require.False(t, daemonStarted)
	require.Len(t, fakeChannels.servers, 2)

	existing := fakeChannels.servers[0]
	require.Equal(t, "chn_existing", existing.ID)
	require.True(t, existing.Enabled)
	existingCfg := configToMap(existing.Config)
	require.Equal(t, "existing-key", existingCfg["api_key"])

	added := fakeChannels.servers[1]
	require.NotEqual(t, "chn_existing", added.ID)
	require.True(t, added.Enabled)
	addedCfg := configToMap(added.Config)
	require.Equal(t, "http://localhost:3001", addedCfg["server_url"])
	require.Equal(t, "new-key", addedCfg["api_key"])
}

func TestRunDaemonConnectPreservesOtherEnabledAgentTeamChannels(t *testing.T) {
	originalGetOperator := getOperator
	originalDaemonStatus := daemonStatus
	originalRunDaemonForeground := runDaemonForeground
	originalOpts := daemonOpts
	t.Cleanup(func() {
		getOperator = originalGetOperator
		daemonStatus = originalDaemonStatus
		runDaemonForeground = originalRunDaemonForeground
		daemonOpts = originalOpts
	})

	fakeChannels := &fakeChannelOperator{
		servers: []profile.AgentTeamServer{
			{
				ID:      "chn_local_one",
				Enabled: true,
				Config: mapToRawMessage(map[string]interface{}{
					"server_url": "http://localhost:3001",
					"api_key":    "old-key-1",
				}),
			},
			{
				ID:      "chn_local_two",
				Enabled: true,
				Config: mapToRawMessage(map[string]interface{}{
					"server_url": "http://localhost:3001",
					"api_key":    "old-key-2",
				}),
			},
			{
				ID:      "chn_existing_other_url",
				Enabled: true,
				Config: mapToRawMessage(map[string]interface{}{
					"server_url": "https://other.example.com",
					"api_key":    "other-key",
				}),
			},
		},
	}
	getOperator = func() (operator.Operator, error) {
		return fakeOperator{servers: fakeChannels}, nil
	}
	daemonStatus = func() *daemon.Status { return &daemon.Status{Running: true, Healthy: true, PID: 29563} }

	daemonStarted := false
	runDaemonForeground = func() error {
		daemonStarted = true
		return nil
	}

	daemonOpts.connectType = "agentteam"
	daemonOpts.agentteamServerURL = "https://agentteam.pingcap.com"
	daemonOpts.agentteamAPIKey = "new-machine-key"

	err := runDaemonCommand()
	require.NoError(t, err)
	require.False(t, daemonStarted)
	require.Len(t, fakeChannels.servers, 4)

	var enabledServers []profile.AgentTeamServer
	for _, ch := range fakeChannels.servers {
		if ch.Enabled {
			enabledServers = append(enabledServers, ch)
		}
		if ch.ID == "chn_existing_other_url" {
			require.True(t, ch.Enabled)
		}
	}

	require.Len(t, enabledServers, 4)

	foundNewMachineConnection := false
	for _, ch := range enabledServers {
		cfg := configToMap(ch.Config)
		if cfg["server_url"] == "https://agentteam.pingcap.com" && cfg["api_key"] == "new-machine-key" {
			foundNewMachineConnection = true
			break
		}
	}
	require.True(t, foundNewMachineConnection)
}

type fakeOperator struct {
	servers operator.ServerOperator
}

func (f fakeOperator) Agents() operator.AgentOperator   { return fakeAgentOperator{} }
func (f fakeOperator) Servers() operator.ServerOperator { return f.servers }
func (f fakeOperator) Skills() operator.SkillOperator   { return fakeSkillOperator{} }

type fakeChannelOperator struct {
	servers []profile.AgentTeamServer
}

func (f *fakeChannelOperator) Get(id string) (profile.AgentTeamServer, bool, error) {
	for _, ch := range f.servers {
		if ch.ID == id {
			return ch, true, nil
		}
	}
	return profile.AgentTeamServer{}, false, nil
}

func (f *fakeChannelOperator) All() ([]profile.AgentTeamServer, error) {
	result := make([]profile.AgentTeamServer, len(f.servers))
	copy(result, f.servers)
	return result, nil
}

func (f *fakeChannelOperator) Add(ch *profile.AgentTeamServer) (profile.AgentTeamServer, error) {
	if ch.ID == "" {
		ch.ID = fmt.Sprintf("chn_%d", len(f.servers)+1)
	}
	f.servers = append(f.servers, *ch)
	return *ch, nil
}

func (f *fakeChannelOperator) Update(ch profile.AgentTeamServer) (profile.AgentTeamServer, error) {
	for i, existing := range f.servers {
		if existing.ID == ch.ID {
			f.servers[i] = ch
			return ch, nil
		}
	}
	return profile.AgentTeamServer{}, fmt.Errorf("channel %q not found", ch.ID)
}

func (f *fakeChannelOperator) Delete(id string) error {
	for i, ch := range f.servers {
		if ch.ID == id {
			f.servers = append(f.servers[:i], f.servers[i+1:]...)
			return nil
		}
	}
	return fmt.Errorf("channel %q not found", id)
}

func (f *fakeChannelOperator) SetEnabled(id string, enabled bool) error {
	for i, ch := range f.servers {
		if ch.ID == id {
			f.servers[i].Enabled = enabled
			return nil
		}
	}
	return fmt.Errorf("channel %q not found", id)
}

type fakeAgentOperator struct{}

func (fakeAgentOperator) Get(string) (agentview.Snapshot, bool, error) {
	return agentview.Snapshot{}, false, nil
}
func (fakeAgentOperator) All() ([]agentview.Snapshot, error) { return nil, nil }

type fakeSkillOperator struct{}

func (fakeSkillOperator) Get(string) (profile.Skill, bool, error)  { return profile.Skill{}, false, nil }
func (fakeSkillOperator) All() ([]profile.Skill, error)            { return nil, nil }
func (fakeSkillOperator) Add(profile.Skill) (profile.Skill, error) { return profile.Skill{}, nil }
func (fakeSkillOperator) Update(profile.Skill) (profile.Skill, error) {
	return profile.Skill{}, nil
}
func (fakeSkillOperator) Delete(string) error { return nil }
func (fakeSkillOperator) ImportFromFile(string, *profile.SkillMeta, bool) (profile.Skill, bool, error) {
	return profile.Skill{}, false, nil
}
func (fakeSkillOperator) ImportFromURL(string, *profile.SkillMeta, bool) (profile.Skill, bool, error) {
	return profile.Skill{}, false, nil
}
func (fakeSkillOperator) ImportAutoFromFile(string, *profile.SkillMeta, bool) (*profile.AutoImportResult, error) {
	return &profile.AutoImportResult{}, nil
}
func (fakeSkillOperator) ImportAutoFromURL(string, *profile.SkillMeta, bool) (*profile.AutoImportResult, error) {
	return &profile.AutoImportResult{}, nil
}