package pluginsdk

import (
	"context"
	"testing"

	"github.com/stretchr/testify/require"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
)

// dataRecordingHost is a fake Go-native Host implementation whose Host data
// API (ADR 0043) accessors are backed by in-memory fixtures, used to prove
// grpcHostServer -> grpcHostClient reachability for the read RPCs added in
// task-03. State/secrets/emit are inherited (unimplemented) from
// UnimplementedHostData since these tests only exercise the data accessors.
type dataRecordingHost struct {
	UnimplementedHostData

	tasks         map[string]Task
	taskList      []Task
	taskPageInfo  *PageInfo
	sessions      []Session
	sessionPage   *PageInfo
	codeStats     []SessionCodeStats
	codeStatsPage *PageInfo
	workspaces    []Workspace
	workflows     []Workflow
	workflowSteps []WorkflowStep
	agentProfiles []AgentProfile
	repositories  []Repository
	messages      []Message
	messagePage   *PageInfo
	utilityText   string

	lastTaskFilter     TaskFilter
	lastSessionFilter  SessionFilter
	lastMessageFilter  MessageFilter
	lastWorkspaceID    string
	lastWorkflowID     string
	lastUtilityPrompt  string
	lastUtilityOptions []UtilityAgentOptions

	createdTask     Task
	lastCreateInput CreateTaskInput
	updatedTask     Task
	lastUpdateInput UpdateTaskInput
	movedOutcome    MoveTaskOutcome
	lastMoveInput   MoveTaskInput
	messageDispatch MessageDispatch
	lastSendTask    string
	lastSendSession string
	lastSendText    string
}

func (h *dataRecordingHost) GetState(context.Context, string, string, string) (map[string]any, bool, error) {
	return nil, false, nil
}
func (h *dataRecordingHost) SetState(context.Context, string, string, string, map[string]any) error {
	return nil
}
func (h *dataRecordingHost) DeleteState(context.Context, string, string, string) error { return nil }
func (h *dataRecordingHost) ListState(context.Context, string, string) ([]StateEntry, error) {
	return nil, nil
}
func (h *dataRecordingHost) GetConfig(context.Context) (map[string]any, error) { return nil, nil }
func (h *dataRecordingHost) GetSecret(context.Context, string) (string, bool, error) {
	return "", false, nil
}
func (h *dataRecordingHost) SetSecret(context.Context, string, string) error      { return nil }
func (h *dataRecordingHost) DeleteSecret(context.Context, string) error           { return nil }
func (h *dataRecordingHost) RevealSecret(context.Context, string) (string, error) { return "", nil }
func (h *dataRecordingHost) EmitEvent(context.Context, string, map[string]any) error {
	return nil
}

func (h *dataRecordingHost) Tasks() TaskReader           { return dataRecordingTaskReader{h} }
func (h *dataRecordingHost) Sessions() SessionReader     { return dataRecordingSessionReader{h} }
func (h *dataRecordingHost) Workspaces() WorkspaceReader { return dataRecordingWorkspaceReader{h} }
func (h *dataRecordingHost) Workflows() WorkflowReader   { return dataRecordingWorkflowReader{h} }
func (h *dataRecordingHost) AgentProfiles() AgentProfileReader {
	return dataRecordingAgentProfileReader{h}
}
func (h *dataRecordingHost) Repositories() RepositoryReader {
	return dataRecordingRepositoryReader{h}
}
func (h *dataRecordingHost) Messages() MessageReader { return dataRecordingMessageReader{h} }
func (h *dataRecordingHost) InvokeUtilityAgent(_ context.Context, prompt string, options ...UtilityAgentOptions) (string, error) {
	h.lastUtilityPrompt = prompt
	h.lastUtilityOptions = append([]UtilityAgentOptions(nil), options...)
	return h.utilityText, nil
}

type dataRecordingTaskReader struct{ h *dataRecordingHost }

func (r dataRecordingTaskReader) List(_ context.Context, filter TaskFilter, _ Page) ([]Task, *PageInfo, error) {
	r.h.lastTaskFilter = filter
	return r.h.taskList, r.h.taskPageInfo, nil
}

func (r dataRecordingTaskReader) Get(_ context.Context, id string) (*Task, error) {
	task, ok := r.h.tasks[id]
	if !ok {
		return nil, status.Errorf(codes.NotFound, "task %q not found", id)
	}
	return &task, nil
}

func (r dataRecordingTaskReader) Create(_ context.Context, in CreateTaskInput) (*Task, error) {
	r.h.lastCreateInput = in
	task := r.h.createdTask
	return &task, nil
}

func (r dataRecordingTaskReader) Update(_ context.Context, in UpdateTaskInput) (*Task, error) {
	r.h.lastUpdateInput = in
	task := r.h.updatedTask
	return &task, nil
}

func (r dataRecordingTaskReader) Move(_ context.Context, in MoveTaskInput) (*MoveTaskOutcome, error) {
	r.h.lastMoveInput = in
	outcome := r.h.movedOutcome
	return &outcome, nil
}

type dataRecordingSessionReader struct{ h *dataRecordingHost }

func (r dataRecordingSessionReader) List(_ context.Context, filter SessionFilter, _ Page) ([]Session, *PageInfo, error) {
	r.h.lastSessionFilter = filter
	return r.h.sessions, r.h.sessionPage, nil
}

func (r dataRecordingSessionReader) CodeStats(_ context.Context, filter SessionFilter, _ Page) ([]SessionCodeStats, *PageInfo, error) {
	r.h.lastSessionFilter = filter
	return r.h.codeStats, r.h.codeStatsPage, nil
}

type dataRecordingWorkspaceReader struct{ h *dataRecordingHost }

func (r dataRecordingWorkspaceReader) List(context.Context, Page) ([]Workspace, *PageInfo, error) {
	return r.h.workspaces, nil, nil
}

type dataRecordingWorkflowReader struct{ h *dataRecordingHost }

func (r dataRecordingWorkflowReader) List(_ context.Context, workspaceID string, _ Page) ([]Workflow, *PageInfo, error) {
	r.h.lastWorkspaceID = workspaceID
	return r.h.workflows, nil, nil
}

func (r dataRecordingWorkflowReader) ListSteps(_ context.Context, workflowID string) ([]WorkflowStep, error) {
	r.h.lastWorkflowID = workflowID
	return r.h.workflowSteps, nil
}

type dataRecordingAgentProfileReader struct{ h *dataRecordingHost }

func (r dataRecordingAgentProfileReader) List(context.Context, Page) ([]AgentProfile, *PageInfo, error) {
	return r.h.agentProfiles, nil, nil
}

type dataRecordingRepositoryReader struct{ h *dataRecordingHost }

func (r dataRecordingRepositoryReader) List(_ context.Context, workspaceID string, _ Page) ([]Repository, *PageInfo, error) {
	r.h.lastWorkspaceID = workspaceID
	return r.h.repositories, nil, nil
}

type dataRecordingMessageReader struct{ h *dataRecordingHost }

func (r dataRecordingMessageReader) List(_ context.Context, filter MessageFilter, _ Page) ([]Message, *PageInfo, error) {
	r.h.lastMessageFilter = filter
	return r.h.messages, r.h.messagePage, nil
}

func (r dataRecordingMessageReader) Send(_ context.Context, taskID, sessionID, text string) (*MessageDispatch, error) {
	r.h.lastSendTask = taskID
	r.h.lastSendSession = sessionID
	r.h.lastSendText = text
	dispatch := r.h.messageDispatch
	return &dispatch, nil
}

func TestHostData_TasksListAndGet(t *testing.T) {
	impl := &dataRecordingHost{
		tasks: map[string]Task{
			"task-1": {ID: "task-1", Title: "Fix the bug", State: "todo", Repositories: []TaskRepository{{
				ID: "tr-1", RepositoryID: "repo-1", BaseBranch: "main", Position: 0, CheckoutBranch: "feature/fix",
			}}},
		},
		taskList: []Task{{ID: "task-1", Title: "Fix the bug", State: "todo", Repositories: []TaskRepository{{
			ID: "tr-1", RepositoryID: "repo-1", BaseBranch: "main", Position: 0, CheckoutBranch: "feature/fix",
		}}}},
		taskPageInfo: &PageInfo{NextCursor: "next-1", HasMore: true},
	}
	host := dialHostOverBufconn(t, impl)

	tasks, pageInfo, err := host.Tasks().List(context.Background(), TaskFilter{States: []string{"todo"}}, Page{Limit: 10})
	require.NoError(t, err)
	require.Equal(t, []Task{{ID: "task-1", Title: "Fix the bug", State: "todo", Repositories: []TaskRepository{{
		ID: "tr-1", RepositoryID: "repo-1", BaseBranch: "main", Position: 0, CheckoutBranch: "feature/fix",
	}}}}, tasks)
	require.Equal(t, &PageInfo{NextCursor: "next-1", HasMore: true}, pageInfo)
	require.Equal(t, TaskFilter{States: []string{"todo"}}, impl.lastTaskFilter)

	task, err := host.Tasks().Get(context.Background(), "task-1")
	require.NoError(t, err)
	require.Equal(t, "Fix the bug", task.Title)
	require.Equal(t, "feature/fix", task.Repositories[0].CheckoutBranch)

	_, err = host.Tasks().Get(context.Background(), "missing")
	require.Error(t, err)
	require.Equal(t, codes.NotFound, status.Code(err))
}

// TestHostData_TaskWritesAndMessage proves the write RPCs (CreateTask,
// UpdateTask, SendMessage) round-trip inputs and results through
// grpcHostClient -> proto -> grpcHostServer, including the optional-pointer
// fields on the update mask.
func TestHostData_TaskWritesAndMessage(t *testing.T) {
	impl := &dataRecordingHost{
		createdTask:     Task{ID: "task-new", Title: "Investigate crash", State: "TODO"},
		updatedTask:     Task{ID: "task-1", Title: "Renamed", State: "IN_PROGRESS"},
		messageDispatch: MessageDispatch{SessionID: "session-1", Status: "queued"},
	}
	host := dialHostOverBufconn(t, impl)

	stepID := "step-2"
	created, err := host.Tasks().Create(context.Background(), CreateTaskInput{
		WorkspaceID: "ws-1", WorkflowID: "wf-1", WorkflowStepID: &stepID,
		Title: "Investigate crash", Description: "stack trace attached", StartAgent: true,
	})
	require.NoError(t, err)
	require.Equal(t, "task-new", created.ID)
	require.Equal(t, "ws-1", impl.lastCreateInput.WorkspaceID)
	require.NotNil(t, impl.lastCreateInput.WorkflowStepID)
	require.Equal(t, "step-2", *impl.lastCreateInput.WorkflowStepID)
	require.True(t, impl.lastCreateInput.StartAgent)

	title := "Renamed"
	state := "IN_PROGRESS"
	updated, err := host.Tasks().Update(context.Background(), UpdateTaskInput{ID: "task-1", Title: &title, State: &state})
	require.NoError(t, err)
	require.Equal(t, "IN_PROGRESS", updated.State)
	require.Equal(t, "task-1", impl.lastUpdateInput.ID)
	require.NotNil(t, impl.lastUpdateInput.Title)
	require.Equal(t, "Renamed", *impl.lastUpdateInput.Title)
	require.Nil(t, impl.lastUpdateInput.Description, "an unset field must stay nil across the wire")

	dispatch, err := host.Messages().Send(context.Background(), "task-1", "session-1", "rerun the tests")
	require.NoError(t, err)
	require.Equal(t, "session-1", dispatch.SessionID)
	require.Equal(t, "queued", dispatch.Status)
	require.Equal(t, "task-1", impl.lastSendTask)
	require.Equal(t, "session-1", impl.lastSendSession)
	require.Equal(t, "rerun the tests", impl.lastSendText)
}

// TestHostData_TaskMove proves MoveTask round-trips through
// grpcHostClient -> proto -> grpcHostServer, including the optional
// workflow_id pointer, the position field, and the outcome's
// queued_for_step_id/transitioned/from_step_id fields.
func TestHostData_TaskMove(t *testing.T) {
	impl := &dataRecordingHost{
		movedOutcome: MoveTaskOutcome{
			Task:            &Task{ID: "task-1", State: "IN_PROGRESS"},
			Transitioned:    true,
			QueuedForStepID: nil,
			FromStepID:      "step-1",
		},
	}
	host := dialHostOverBufconn(t, impl)

	workflowID := "wf-1"
	outcome, err := host.Tasks().Move(context.Background(), MoveTaskInput{
		TaskID: "task-1", WorkflowStepID: "step-2", WorkflowID: &workflowID, Position: 3,
	})
	require.NoError(t, err)
	require.True(t, outcome.Transitioned)
	require.Nil(t, outcome.QueuedForStepID)
	require.Equal(t, "step-1", outcome.FromStepID)
	require.Equal(t, "task-1", outcome.Task.ID)

	require.Equal(t, "task-1", impl.lastMoveInput.TaskID)
	require.Equal(t, "step-2", impl.lastMoveInput.WorkflowStepID)
	require.NotNil(t, impl.lastMoveInput.WorkflowID)
	require.Equal(t, "wf-1", *impl.lastMoveInput.WorkflowID)
	require.Equal(t, int32(3), impl.lastMoveInput.Position)
}

// TestHostData_TaskMove_OmittedWorkflowIDStaysNilAcrossWire proves an
// omitted workflow_id (nil, meaning "inherit the task's current workflow",
// AC-005.4) survives the proto round-trip as nil rather than being coerced
// to an empty string, which would be indistinguishable from an explicit
// present-but-empty rejection (AC-005.5).
func TestHostData_TaskMove_OmittedWorkflowIDStaysNilAcrossWire(t *testing.T) {
	impl := &dataRecordingHost{movedOutcome: MoveTaskOutcome{Task: &Task{ID: "task-1"}}}
	host := dialHostOverBufconn(t, impl)

	_, err := host.Tasks().Move(context.Background(), MoveTaskInput{TaskID: "task-1", WorkflowStepID: "step-2"})
	require.NoError(t, err)
	require.Nil(t, impl.lastMoveInput.WorkflowID)
}

// TestHostData_TaskMove_ReportsQueuedForStepID proves a non-nil
// QueuedForStepID (AC-002.1/002.2: landing on a step at its WIP limit) also
// survives the wire round-trip.
func TestHostData_TaskMove_ReportsQueuedForStepID(t *testing.T) {
	impl := &dataRecordingHost{movedOutcome: MoveTaskOutcome{
		Task:            &Task{ID: "task-1"},
		Transitioned:    false,
		QueuedForStepID: strPtr("step-2"),
		FromStepID:      "step-2",
	}}
	host := dialHostOverBufconn(t, impl)

	outcome, err := host.Tasks().Move(context.Background(), MoveTaskInput{TaskID: "task-1", WorkflowStepID: "step-2"})
	require.NoError(t, err)
	require.False(t, outcome.Transitioned)
	require.NotNil(t, outcome.QueuedForStepID)
	require.Equal(t, "step-2", *outcome.QueuedForStepID)
}

func TestHostData_SessionsListAndCodeStats(t *testing.T) {
	impl := &dataRecordingHost{
		sessions:  []Session{{ID: "session-1", TaskID: "task-1", State: "running"}},
		codeStats: []SessionCodeStats{{SessionID: "session-1", LinesAddedCommitted: 10, CommittedLinesAvailable: true}},
	}
	host := dialHostOverBufconn(t, impl)

	sessions, _, err := host.Sessions().List(context.Background(), SessionFilter{TaskIDs: []string{"task-1"}}, Page{})
	require.NoError(t, err)
	require.Equal(t, impl.sessions, sessions)
	require.Equal(t, SessionFilter{TaskIDs: []string{"task-1"}}, impl.lastSessionFilter)

	stats, _, err := host.Sessions().CodeStats(context.Background(), SessionFilter{TaskIDs: []string{"task-1"}}, Page{})
	require.NoError(t, err)
	require.Equal(t, impl.codeStats, stats)
}

func TestHostData_Workspaces(t *testing.T) {
	impl := &dataRecordingHost{workspaces: []Workspace{{ID: "ws-1", Name: "Acme"}}}
	host := dialHostOverBufconn(t, impl)

	workspaces, _, err := host.Workspaces().List(context.Background(), Page{})
	require.NoError(t, err)
	require.Equal(t, impl.workspaces, workspaces)
}

func TestHostData_InvokeUtilityAgent(t *testing.T) {
	impl := &dataRecordingHost{utilityText: "the completion"}
	host := dialHostOverBufconn(t, impl)

	text, err := host.InvokeUtilityAgent(context.Background(), "do the thing", UtilityAgentOptions{ProfileID: "profile-1"})
	require.NoError(t, err)
	require.Equal(t, "the completion", text)
	require.Equal(t, "do the thing", impl.lastUtilityPrompt)
	require.Equal(t, []UtilityAgentOptions{{ProfileID: "profile-1"}}, impl.lastUtilityOptions)
}

func TestHostData_Messages(t *testing.T) {
	impl := &dataRecordingHost{
		messages: []Message{{
			ID: "m1", SessionID: "s1", TaskID: "t1", TurnID: "turn1",
			AuthorType: "user", Content: "hello", Type: "message", CreatedAt: "2026-07-20T09:00:00Z",
		}},
		messagePage: &PageInfo{NextCursor: "2", HasMore: true},
	}
	host := dialHostOverBufconn(t, impl)

	since := "2026-07-20T00:00:00Z"
	filter := MessageFilter{SessionIDs: []string{"s1"}, TaskIDs: []string{"t1"}, Since: &since, Types: []string{"message"}}
	messages, pageInfo, err := host.Messages().List(context.Background(), filter, Page{Limit: 10})
	require.NoError(t, err)
	require.Equal(t, impl.messages, messages)
	require.Equal(t, &PageInfo{NextCursor: "2", HasMore: true}, pageInfo)
	// Filter (including the optional Since pointer) round-trips through proto.
	require.Equal(t, filter, impl.lastMessageFilter)
	require.NotNil(t, impl.lastMessageFilter.Since)
	require.Equal(t, since, *impl.lastMessageFilter.Since)
}

func TestHostData_WorkflowsAndSteps(t *testing.T) {
	impl := &dataRecordingHost{
		workflows:     []Workflow{{ID: "wf-1", WorkspaceID: "ws-1", Name: "Default"}},
		workflowSteps: []WorkflowStep{{ID: "step-1", WorkflowID: "wf-1", Name: "Review"}},
	}
	host := dialHostOverBufconn(t, impl)

	workflows, _, err := host.Workflows().List(context.Background(), "ws-1", Page{})
	require.NoError(t, err)
	require.Equal(t, impl.workflows, workflows)
	require.Equal(t, "ws-1", impl.lastWorkspaceID)

	steps, err := host.Workflows().ListSteps(context.Background(), "wf-1")
	require.NoError(t, err)
	require.Equal(t, impl.workflowSteps, steps)
	require.Equal(t, "wf-1", impl.lastWorkflowID)
}

func TestHostData_AgentProfiles(t *testing.T) {
	impl := &dataRecordingHost{agentProfiles: []AgentProfile{{ID: "profile-1", DisplayName: "Claude"}}}
	host := dialHostOverBufconn(t, impl)

	profiles, _, err := host.AgentProfiles().List(context.Background(), Page{})
	require.NoError(t, err)
	require.Equal(t, impl.agentProfiles, profiles)
}

func TestHostData_Repositories(t *testing.T) {
	impl := &dataRecordingHost{repositories: []Repository{{
		ID: "repo-1", WorkspaceID: "ws-1", Name: "team/kandev", SourceType: "provider", ProviderID: "example-vcs",
		ProviderRepositoryID: "repo-42", ProviderHost: "code.example.test", OwnerOrProject: "team", ProviderName: "kandev",
		RemoteURL: "https://code.example.test/scm/team/kandev.git",
	}}}
	host := dialHostOverBufconn(t, impl)

	repos, _, err := host.Repositories().List(context.Background(), "ws-1", Page{})
	require.NoError(t, err)
	require.Equal(t, impl.repositories, repos)
	require.Equal(t, "ws-1", impl.lastWorkspaceID)
}

// TestHostData_UnimplementedHostData_ReturnsUnimplemented proves that a Host
// implementation embedding UnimplementedHostData (task-03's default for
// task-04 to override) compiles against the Host interface and, over the
// wire, returns a gRPC Unimplemented status for every Host data API RPC —
// so a plugin author calling an unwired accessor gets a clear error rather
// than a panic or a zero-value success.
func TestHostData_UnimplementedHostData_ReturnsUnimplemented(t *testing.T) {
	impl := &recordingHost{}
	host := dialHostOverBufconn(t, impl)

	_, _, err := host.Tasks().List(context.Background(), TaskFilter{}, Page{})
	require.Error(t, err)
	require.Equal(t, codes.Unimplemented, status.Code(err))

	_, err = host.Tasks().Get(context.Background(), "task-1")
	require.Error(t, err)
	require.Equal(t, codes.Unimplemented, status.Code(err))

	_, _, err = host.Sessions().CodeStats(context.Background(), SessionFilter{}, Page{})
	require.Error(t, err)
	require.Equal(t, codes.Unimplemented, status.Code(err))

	_, err = host.Tasks().Create(context.Background(), CreateTaskInput{Title: "x"})
	require.Error(t, err)
	require.Equal(t, codes.Unimplemented, status.Code(err))

	_, err = host.Tasks().Update(context.Background(), UpdateTaskInput{ID: "task-1"})
	require.Error(t, err)
	require.Equal(t, codes.Unimplemented, status.Code(err))

	_, err = host.Messages().Send(context.Background(), "task-1", "", "body")
	require.Error(t, err)
	require.Equal(t, codes.Unimplemented, status.Code(err))
}