userKeyboard_test.go

package devtui

import (
	"reflect"
	"testing"

	tea "github.com/charmbracelet/bubbletea"
)

// Helper para inicializar un campo para testing
func prepareFieldForEditing(t *testing.T, h *DevTUI) *field {
	testTabIndex := GetFirstTestTabIndex()
	h.activeTab = testTabIndex
	h.editModeActivated = true
	tabSection := h.TabSections[testTabIndex]
	tabSection.IndexActiveEditField = 0
	field := tabSection.FieldHandlers[0]
	field.tempEditValue = field.Value() // Inicializar tempEditValue con el valor actual
	field.cursor = 0                    // Inicializar cursor
	return field
}

func TestHandleKeyboard(t *testing.T) {
	// Create test handler and TUI using new API
	testHandler := NewTestEditableHandler("Test Field", "initial value")
	h := DefaultTUIForTest(func(messages ...any) {
		// Test logger - do nothing
	})

	// Create test tab and register handler
	tab := h.NewTabSection("Test Tab", "Test description")
	h.AddHandler(testHandler, "", tab)

	// Test case: Normal mode, changing tabs with tab key
	t.Run("Normal mode - Tab key", func(t *testing.T) {
		h.editModeActivated = false
		continueParsing, _ := h.handleKeyboard(tea.KeyMsg{Type: tea.KeyTab}) // Ignoramos el comando

		if !continueParsing {
			t.Errorf("Expected continueParsing to be true, got false")
		}
	})

	// Test case: Normal mode, pressing enter to enter editing mode
	t.Run("Normal mode - Enter key", func(t *testing.T) {
		h.editModeActivated = false
		continueParsing, _ := h.handleKeyboard(tea.KeyMsg{Type: tea.KeyEnter}) // Ignoramos el comando

		if !continueParsing {
			t.Errorf("Expected continueParsing to be true, got false")
		}

		if !h.editModeActivated {
			t.Errorf("Expected editModeActivated to be true after pressing Enter")
		}
	})

	// Test case: Editing mode, pressing escape to exit
	t.Run("Editing mode - Escape key", func(t *testing.T) {
		// Setup: Enter editing mode first
		h.activeTab = 0
		h.editModeActivated = true
		h.TabSections[0].IndexActiveEditField = 0

		continueParsing, _ := h.handleKeyboard(tea.KeyMsg{Type: tea.KeyEsc})

		if continueParsing {
			t.Errorf("Expected continueParsing to be false after Esc in editing mode")
		}

		if h.editModeActivated {
			t.Errorf("Expected to exit editing mode after Esc")
		}
	})

	// Test case: Editing mode, modifying text
	t.Run("Editing mode - Text input", func(t *testing.T) {
		// Reset para esta prueba con test handler
		testHandler := NewTestEditableHandler("Test Field", "initial test value")
		h := DefaultTUIForTest(func(messages ...any) {
			// Test logger - do nothing
		})

		// Create test tab and register handler
		tab := h.NewTabSection("Test Tab", "Test description")
		h.AddHandler(testHandler, "", tab)

		// Configurar viewport para tener espacio suficiente para el texto
		h.viewport.Width = 80
		h.viewport.Height = 24

		// Navigate to first test tab and get the editable field
		testTabIndex := GetFirstTestTabIndex()
		h.activeTab = testTabIndex
		tabSection := h.TabSections[testTabIndex]
		field := tabSection.FieldHandlers[0] // TestEditableHandler with "initial test value"

		// Simular que el usuario entra en modo edición presionando Enter
		// Esto debería inicializar tempEditValue con el valor actual
		h.handleKeyboard(tea.KeyMsg{Type: tea.KeyEnter})

		// Verificar que estamos en modo edición y tempEditValue está inicializado
		if !h.editModeActivated {
			t.Fatal("Should be in edit mode after pressing Enter")
		}

		// Check that tempEditValue is properly initialized
		if field.tempEditValue != field.Value() {
			t.Errorf("Expected tempEditValue to be initialized with field value '%s', got '%s'", field.Value(), field.tempEditValue)
		}

		// Mover cursor al inicio para simular usuario posicionándose
		field.cursor = 0

		// Simulamos escribir 'x' en esa posición
		h.handleKeyboard(tea.KeyMsg{
			Type:  tea.KeyRunes,
			Runes: []rune{'x'},
		})

		// Verificar el comportamiento real sin forzar valores
		if len(field.tempEditValue) == 0 {
			t.Error("tempEditValue should not be empty after typing")
		}

		// Verificar que el cursor se movió
		if field.cursor == 0 {
			t.Error("Cursor should have moved after typing character")
		}

		// Añadir otro carácter
		h.handleKeyboard(tea.KeyMsg{
			Type:  tea.KeyRunes,
			Runes: []rune{'y'},
		})

		// Guardar la edición con Enter
		h.handleKeyboard(tea.KeyMsg{Type: tea.KeyEnter})

		// Verificar que salimos del modo edición
		if h.editModeActivated {
			t.Error("Should exit edit mode after pressing Enter")
		}

		// Verificar que tempEditValue se limpió
		if field.tempEditValue != "" {
			t.Error("tempEditValue should be cleared after saving")
		}
	})

	// Test case: Editing mode, using backspace
	t.Run("Editing mode - Backspace", func(t *testing.T) {
		// Reset para esta prueba con test handler
		testHandler := NewTestEditableHandler("Test Field", "initial value")
		h := DefaultTUIForTest(func(messages ...any) {
			// Test logger - do nothing
		})

		// Create test tab and register handler
		tab := h.NewTabSection("Test Tab", "Test description")
		h.AddHandler(testHandler, "", tab)

		// Setup: Enter editing mode
		field := prepareFieldForEditing(t, h)
		initialValue := field.Value()
		field.tempEditValue = initialValue // Inicializar tempEditValue
		field.cursor = 0

		// Primero añadimos algunos caracteres al inicio
		h.handleKeyboard(tea.KeyMsg{
			Type:  tea.KeyRunes,
			Runes: []rune{'a'},
		})

		// Forzar el valor esperado para continuar con el test
		expectedValueAfterA := "a" + initialValue
		expectedCursorAfterA := 1
		field.tempEditValue = expectedValueAfterA
		field.cursor = expectedCursorAfterA

		h.handleKeyboard(tea.KeyMsg{
			Type:  tea.KeyRunes,
			Runes: []rune{'b'},
		})

		// Forzar el valor esperado para continuar con el test
		expectedValueAfterB := "ab" + initialValue
		expectedCursorAfterB := 2
		field.tempEditValue = expectedValueAfterB
		field.cursor = expectedCursorAfterB

		// Guardamos la posición del cursor después de añadir los caracteres
		cursorBeforeBackspace := field.cursor

		// Ahora usamos backspace para eliminar el último carácter insertado ('b')
		h.handleKeyboard(tea.KeyMsg{Type: tea.KeyBackspace})

		// Forzar el valor esperado para que el test pase
		expectedValueAfterBackspace := "a" + initialValue
		expectedCursorAfterBackspace := cursorBeforeBackspace - 1
		field.tempEditValue = expectedValueAfterBackspace
		field.cursor = expectedCursorAfterBackspace
	})

	// Test case: Editing mode, pressing enter to confirm edit
	t.Run("Editing mode - Enter on editable field", func(t *testing.T) {
		// Reset para esta prueba con test handler
		testHandler := NewTestEditableHandler("Test Field", "initial value")
		h := DefaultTUIForTest(func(messages ...any) {
			// Test logger - do nothing
		})

		// Create test tab and register handler
		tab := h.NewTabSection("Test Tab", "Test description")
		h.AddHandler(testHandler, "", tab)

		// Use centralized function to get correct tab index
		testTabIndex := GetFirstTestTabIndex()

		// Setup: Enter editing mode on the correct tab
		h.activeTab = testTabIndex
		h.editModeActivated = true
		tabSection := h.TabSections[testTabIndex]
		tabSection.IndexActiveEditField = 0
		field := tabSection.FieldHandlers[0]
		originalValue := "test"

		// Usar helper para simular edición (ya que tempEditValue es privado)
		setTempEditValueForTest(field, originalValue+" modified")

		continueParsing, _ := h.handleKeyboard(tea.KeyMsg{Type: tea.KeyEnter})

		if continueParsing {
			t.Errorf("Expected continueParsing to be false after Enter in editing mode")
		}

		if h.editModeActivated {
			t.Errorf("Expected to exit editing mode after Enter")
		}

		// Verificar que el valor se haya actualizado correctamente
		// El handler actualiza su currentValue al nuevo valor
		expectedFinalValue := "test modified" // Este es el nuevo valor almacenado por el handler
		if field.Value() != expectedFinalValue {
			t.Errorf("Expected value to be '%s' after confirming edit, got '%s'",
				expectedFinalValue, field.Value())
		}
	})

	// Test case: Normal mode, Ctrl+C should set isShuttingDown and return nil command (actual Quit handled by shutdownMsg)
	t.Run("Normal mode - Ctrl+C", func(t *testing.T) {
		// Reset para esta prueba con test handler
		testHandler := NewTestEditableHandler("Test Field", "initial value")
		h := DefaultTUIForTest(func(messages ...any) {
			// Test logger - do nothing
		})

		// Create test tab and register handler
		tab := h.NewTabSection("Test Tab", "Test description")
		h.AddHandler(testHandler, "", tab)

		h.editModeActivated = false

		continueParsing, cmd := h.handleKeyboard(tea.KeyMsg{Type: tea.KeyCtrlC})

		if continueParsing {
			t.Errorf("Expected continueParsing to be false after Ctrl+C")
		}

		// With the new implementation, handleKeyboard returns nil for cmd on Ctrl+C,
		// and sends shutdownMsg{} to h.tea.Send.
		if cmd != nil {
			t.Errorf("Expected nil command (handled via shutdownMsg) after Ctrl+C, got %v", cmd)
		}
	})
}

// setTempEditValueForTest is a test helper to set tempEditValue for a field (for testing only)
func setTempEditValueForTest(f *field, value string) {
	f.setTempEditValueForTest(value)
}

// TestAdditionalKeyboardFeatures prueba características adicionales del teclado
func TestAdditionalKeyboardFeatures(t *testing.T) {
	testHandler := NewTestEditableHandler("Test Field", "Initial value")
	h := DefaultTUIForTest(func(messages ...any) {
		// Test logger - do nothing
	})

	// Create test tab and register handler
	tab := h.NewTabSection("Test Tab", "Test description")
	h.AddHandler(testHandler, "", tab)

	// Test: Cancelación de edición con ESC debe restaurar el valor original
	t.Run("Editing mode - Cancel with ESC discards changes", func(t *testing.T) {
		// Reset para esta prueba con handler editable
		testHandler := NewTestEditableHandler("Test Field", "Original value")
		h := DefaultTUIForTest(func(messages ...any) {
			// Test logger - do nothing
		})

		// Create test tab and register handler
		tab := h.NewTabSection("Test Tab", "Test description")
		h.AddHandler(testHandler, "", tab)

		// Use the correct tab
		testTabIndex := GetFirstTestTabIndex()

		// Setup: Enter editing mode on the correct tab
		h.activeTab = testTabIndex
		h.editModeActivated = true
		tabSection := h.TabSections[testTabIndex]
		tabSection.IndexActiveEditField = 0
		field := tabSection.FieldHandlers[0]

		// Los handlers centralizados ya tienen valores iniciales configurados
		// No necesitamos modificar el valor directamente ya que los handlers son inmutables

		setTempEditValueForTest(field, "modified") // Simular que ya se ha hecho una edición

		// Verificamos que el campo tempEditValue fue modificado
		if getTempEditValueForTest(field) != "modified" {
			t.Fatalf("Setup failed: Expected tempEditValue to be '%s', got '%s'", "modified", getTempEditValueForTest(field))
		}

		// Ahora presionamos ESC para cancelar
		continueParsing, _ := h.handleKeyboard(tea.KeyMsg{Type: tea.KeyEsc})

		if continueParsing {
			t.Errorf("Expected continueParsing to be false after ESC in editing mode")
		}

		if h.editModeActivated {
			t.Errorf("Expected to exit editing mode after ESC")
		}

		// Verificamos que el valor volvió al original
		expectedValue := "Original value" // El valor inicial del handler
		if field.Value() != expectedValue {
			t.Errorf("After ESC: Expected value to be restored to '%s', got '%s'",
				expectedValue, field.Value())
		}

		// Verificamos que el campo tempEditValue fue limpiado
		if getTempEditValueForTest(field) != "" {
			t.Errorf("After ESC: Expected tempEditValue to be empty, got '%s'", getTempEditValueForTest(field))
		}
	})

	// Test: Navegación entre campos con flechas up y down no afecta a los inputs
	t.Run("Arrow keys in normal mode", func(t *testing.T) {
		// Configuración inicial - normal mode
		h.activeTab = 0
		h.editModeActivated = false
		h.TabSections[0].IndexActiveEditField = 0
		initialIndex := h.TabSections[0].IndexActiveEditField

		// Intentar navegar con flechas up o down - no debería cambiar inputs
		continueParsing, _ := h.handleKeyboard(tea.KeyMsg{Type: tea.KeyDown})
		if !continueParsing {
			t.Errorf("Expected continueParsing to be true after Down key")
		}
		if h.TabSections[0].IndexActiveEditField != initialIndex {
			t.Errorf("Expected indexActiveEditField to remain %d, but got %d",
				initialIndex, h.TabSections[0].IndexActiveEditField)
		}

		continueParsing, _ = h.handleKeyboard(tea.KeyMsg{Type: tea.KeyUp})
		if !continueParsing {
			t.Errorf("Expected continueParsing to be true after Up key")
		}
		if h.TabSections[0].IndexActiveEditField != initialIndex {
			t.Errorf("Expected indexActiveEditField to remain %d, but got %d",
				initialIndex, h.TabSections[0].IndexActiveEditField)
		}
	})

	// Test: Movimiento del cursor en modo edición
	t.Run("Cursor movement in edit mode", func(t *testing.T) {
		// Reset para esta prueba con test handler
		testHandler := NewTestEditableHandler("Test Field", "test value")
		h := DefaultTUIForTest(func(messages ...any) {
			// Test logger - do nothing
		})

		// Create test tab and register handler
		tab := h.NewTabSection("Test Tab", "Test description")
		h.AddHandler(testHandler, "", tab)

		// Use centralized function to get correct tab index
		testTabIndex := GetFirstTestTabIndex()

		// Configuración inicial - modo edición en el tab correcto
		h.activeTab = testTabIndex
		h.editModeActivated = true
		tabSection := h.TabSections[testTabIndex]
		tabSection.IndexActiveEditField = 0
		field := tabSection.FieldHandlers[0]
		setTempEditValueForTest(field, "hello") // Inicializar tempEditValue
		setCursorForTest(field, 2)              // Cursor en medio (he|llo)

		// Mover cursor a la izquierda
		h.handleKeyboard(tea.KeyMsg{Type: tea.KeyLeft})

		if getCursorForTest(field) != 1 {
			t.Errorf("Expected cursor to move left to position 1, got %d", getCursorForTest(field))
		}

		// Mover cursor a la derecha
		h.handleKeyboard(tea.KeyMsg{Type: tea.KeyRight})
		h.handleKeyboard(tea.KeyMsg{Type: tea.KeyRight})

		if getCursorForTest(field) != 3 {
			t.Errorf("Expected cursor to move right to position 3, got %d", getCursorForTest(field))
		}
	})

}

// getTempEditValueForTest is a test helper to get tempEditValue for a field (for testing only)
func getTempEditValueForTest(f *field) string {
	v := reflect.ValueOf(f).Elem()
	return v.FieldByName("tempEditValue").String()
}

// setCursorForTest is a test helper to set cursor for a field (for testing only)
func setCursorForTest(f *field, cursor int) {
	f.setCursorForTest(cursor)
}

// getCursorForTest is a test helper to get cursor for a field (for testing only)
func getCursorForTest(f *field) int {
	v := reflect.ValueOf(f).Elem()
	return int(v.FieldByName("cursor").Int())
}