package handlers_test

import (
	"slices"
	"testing"

	"github.com/StevanFreeborn/term-tier/internal/core"
	"github.com/StevanFreeborn/term-tier/internal/handlers"
	"github.com/StevanFreeborn/term-tier/internal/state"
	tea "github.com/charmbracelet/bubbletea"
)

func TestNewLoadHandler(t *testing.T) {
	saver := &mockSaver{}

	h := handlers.NewLoadHandler(saver)

	if h.Description() != "Load tiers" {
		t.Errorf("Expected description 'Load tiers', got %q", h.Description())
	}

	keys := h.KeysHandled()

	if !slices.Contains(keys, "ctrl+o") {
		t.Errorf("Expected keys ['ctrl+o'], got %v", keys)
	}
}

func TestLoadHandler_Match(t *testing.T) {
	saver := &mockSaver{}

	h := handlers.NewLoadHandler(saver)

	tests := []struct {
		name     string
		mode     state.Mode
		msg      tea.KeyMsg
		expected bool
	}{
		{
			name:     "Matches ctrl+o in NavigationMode",
			mode:     state.NavigationMode,
			msg:      tea.KeyMsg{Type: tea.KeyCtrlO},
			expected: true,
		},
		{
			name:     "Ignores ctrl+o in InputMode",
			mode:     state.InputMode,
			msg:      tea.KeyMsg{Type: tea.KeyCtrlO},
			expected: false,
		},
		{
			name:     "Ignores other keys",
			mode:     state.NavigationMode,
			msg:      tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("a")},
			expected: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			s := state.New(state.WithMode(tt.mode))
			if got := h.Match(s, tt.msg); got != tt.expected {
				t.Errorf("Match() = %v, want %v", got, tt.expected)
			}
		})
	}
}

func TestLoadHandler_Handle(t *testing.T) {
	t.Run("Successfully loads data", func(t *testing.T) {
		mockData := core.SaveState{
			Tiers: []struct {
				Name  string      `json:"name"`
				Items []core.Item `json:"items"`
			}{
				{Name: "Tier 1", Items: []core.Item{"Loaded Item"}},
			},
		}

		saver := &mockSaver{dataToReturn: mockData}
		h := handlers.NewLoadHandler(saver)

		initialTiers := []core.Tier{{Name: "Tier 1", Items: []core.Item{}}}

		s := state.New(
			state.WithMode(state.NavigationMode),
			state.WithTiers(initialTiers),
		)

		msg := tea.KeyMsg{Type: tea.KeyCtrlO}
		h.Handle(s, msg)

		if s.Mode() != state.InputMode {
			t.Fatal("Expected state to switch to InputMode")
		}

		for _, r := range "savefile.json" {
			s.UpdateInput(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{r}})
		}

		s.SubmitInput()

		if s.Mode() != state.NavigationMode {
			t.Error("Expected to return to NavigationMode after loading")
		}

		expectedStatus := "Loaded savefile.json"

		if s.StatusMsg() != expectedStatus {
			t.Errorf("Expected status %q, got %q", expectedStatus, s.StatusMsg())
		}

		currentItems := s.Tiers()[0].Items

		if len(currentItems) != 1 || currentItems[0] != "Loaded Item" {
			t.Errorf("Expected loaded items ['Loaded Item'], got %v", currentItems)
		}
	})

	t.Run("Handles load errors gracefully", func(t *testing.T) {
		saver := &mockSaver{shouldError: true}

		h := handlers.NewLoadHandler(saver)
		s := state.New(state.WithMode(state.NavigationMode))

		h.Handle(s, tea.KeyMsg{Type: tea.KeyCtrlO})

		for _, r := range "missing.json" {
			s.UpdateInput(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{r}})
		}

		s.SubmitInput()

		expectedPrefix := "Error:"

		if len(s.StatusMsg()) < len(expectedPrefix) || s.StatusMsg()[:len(expectedPrefix)] != expectedPrefix {
			t.Errorf("Expected error status, got %q", s.StatusMsg())
		}
	})
}