repl_test.go

package main

import (
	"bytes"
	"fmt"
	"io"
	"os"
	"os/exec"
	"strings"
	"testing"
	"time"

	"github.com/remuscazacu/pokedexcli/internal/pokeapi"
	"github.com/remuscazacu/pokedexcli/internal/pokecache"
)

func TestCleanInput(t *testing.T) {
	cases := []struct {
		input    string
		expected []string
	}{
		{
			input:    " Hello World  ",
			expected: []string{"hello", "world"},
		},
		{
			input:    "hello Remus   ",
			expected: []string{"hello", "remus"},
		},
		{
			input:    "",
			expected: []string{},
		},
		{
			input:    "   ",
			expected: []string{},
		},
		{
			input:    "well hello there",
			expected: []string{"well", "hello", "there"},
		},
		{
			input:    "Hello there",
			expected: []string{"hello", "there"},
		},
		{
			input:    "POKEMON was underrated",
			expected: []string{"pokemon", "was", "underrated"},
		},
	}

	for _, c := range cases {
		actual := cleanInput(c.input)
		//check slice lengtg
		if len(actual) != len(c.expected) {
			t.Errorf("cleanInput (%q) length mismatch: expected %d, got %d",
				c.input,
				len(c.expected),
				len(actual),
			)
			continue
		}
		for i := range actual {
			if actual[i] != c.expected[i] {
				t.Errorf(
					"cleanInput(%q)[%d]: expected %q, got %q",
					c.input,
					i,
					c.expected[i],
					actual[i],
				)
			}
			//word := actual[i]
			//expectedWord := c.expected[i]
		}
	}
}

func TestGetCommands(t *testing.T) {
	commands := getCommands()

	// Check that help command exists
	helpCmd, exists := commands["help"]
	if !exists {
		t.Error("help command should be registered")
	}

	// Verify help command properties
	if helpCmd.name != "help" {
		t.Errorf("help command name: expected 'help', got %q", helpCmd.name)
	}

	if helpCmd.description != "Displays a help message" {
		t.Errorf("help command description: expected 'Displays a help message', got %q", helpCmd.description)
	}

	if helpCmd.callback == nil {
		t.Error("help command callback should not be nil")
	}

	// Check that exit command exists
	exitCmd, exists := commands["exit"]
	if !exists {
		t.Error("exit command should be registered")
	}

	// Verify exit command properties
	if exitCmd.name != "exit" {
		t.Errorf("exit command name: expected 'exit', got %q", exitCmd.name)
	}

	if exitCmd.description != "Exit the Pokedex" {
		t.Errorf("exit command description: expected 'Exit the Pokedex', got %q", exitCmd.description)
	}

	if exitCmd.callback == nil {
		t.Error("exit command callback should not be nil")
	}

	// Check that map command exists
	mapCmd, exists := commands["map"]
	if !exists {
		t.Error("map command should be registered")
	}

	// Verify map command properties
	if mapCmd.name != "map" {
		t.Errorf("map command name: expected 'map', got %q", mapCmd.name)
	}

	if mapCmd.description != "Displays the names of 20 location areas" {
		t.Errorf("map command description: expected 'Displays the names of 20 location areas', got %q", mapCmd.description)
	}

	if mapCmd.callback == nil {
		t.Error("map command callback should not be nil")
	}

	// Check that mapb command exists
	mapbCmd, exists := commands["mapb"]
	if !exists {
		t.Error("mapb command should be registered")
	}

	// Verify mapb command properties
	if mapbCmd.name != "mapb" {
		t.Errorf("mapb command name: expected 'mapb', got %q", mapbCmd.name)
	}

	if mapbCmd.description != "Displays the previous 20 location areas" {
		t.Errorf("mapb command description: expected 'Displays the previous 20 location areas', got %q", mapbCmd.description)
	}

	if mapbCmd.callback == nil {
		t.Error("mapb command callback should not be nil")
	}

	// Check that explore command exists
	exploreCmd, exists := commands["explore"]
	if !exists {
		t.Error("explore command should be registered")
	}

	// Verify explore command properties
	if exploreCmd.name != "explore" {
		t.Errorf("explore command name: expected 'explore', got %q", exploreCmd.name)
	}

	if exploreCmd.description != "Displays the Pokemon found in a location area" {
		t.Errorf("explore command description: expected 'Displays the Pokemon found in a location area', got %q", exploreCmd.description)
	}

	if exploreCmd.callback == nil {
		t.Error("explore command callback should not be nil")
	}
}

func TestCommandHelp(t *testing.T) {
	// Capture stdout
	oldStdout := os.Stdout
	r, w, _ := os.Pipe()
	os.Stdout = w

	// Call commandHelp
	cache := pokecache.NewCache(5 * time.Second)
	pokeapiClient := pokeapi.NewClient(cache)
	cfg := &config{
		pokeapiClient: pokeapiClient,
		caughtPokemon: make(map[string]pokeapi.PokemonResponse),
	}
	err := commandHelp(cfg, []string{})

	// Restore stdout
	w.Close()
	os.Stdout = oldStdout

	// Read captured output
	var buf bytes.Buffer
	io.Copy(&buf, r)
	output := buf.String()

	// Verify no error returned
	if err != nil {
		t.Errorf("commandHelp should not return error, got: %v", err)
	}

	// Verify output contains expected text
	expectedTexts := []string{
		"Welcome to the Pokedex!",
		"Usage:",
		"help: Displays a help message",
		"exit: Exit the Pokedex",
		"map: Displays the names of 20 location areas",
		"mapb: Displays the previous 20 location areas",
		"explore <location_area>: Displays the Pokemon found in a location area",
	}

	for _, expected := range expectedTexts {
		if !strings.Contains(output, expected) {
			t.Errorf("output should contain %q, got:\n%s", expected, output)
		}
	}
}

func TestCommandExit(t *testing.T) {
	// Use subprocess pattern to test os.Exit
	if os.Getenv("BE_CRASHER") == "1" {
		cache := pokecache.NewCache(5 * time.Second)
		pokeapiClient := pokeapi.NewClient(cache)
		cfg := &config{
			pokeapiClient: pokeapiClient,
			caughtPokemon: make(map[string]pokeapi.PokemonResponse),
		}
		commandExit(cfg, []string{})
		return
	}

	cmd := exec.Command(os.Args[0], "-test.run=TestCommandExit")
	cmd.Env = append(os.Environ(), "BE_CRASHER=1")
	err := cmd.Run()

	// commandExit calls os.Exit(0), so we expect no error
	if err != nil {
		t.Errorf("process exited with error: %v", err)
	}
}

func TestCommandMap(t *testing.T) {
	// Capture stdout
	oldStdout := os.Stdout
	r, w, _ := os.Pipe()
	os.Stdout = w

	// Create config with cache and API client
	cache := pokecache.NewCache(5 * time.Second)
	pokeapiClient := pokeapi.NewClient(cache)
	cfg := &config{
		pokeapiClient: pokeapiClient,
		caughtPokemon: make(map[string]pokeapi.PokemonResponse),
	}

	// Call commandMap
	err := commandMap(cfg, []string{})

	// Restore stdout
	w.Close()
	os.Stdout = oldStdout

	// Read captured output
	var buf bytes.Buffer
	io.Copy(&buf, r)
	output := buf.String()

	// Verify no error returned
	if err != nil {
		t.Errorf("commandMap should not return error, got: %v", err)
	}

	// Verify Next was set
	if cfg.Next == nil {
		t.Error("commandMap should set Next URL")
	}

	// Verify output contains location names
	if !strings.Contains(output, "canalave-city-area") {
		t.Error("output should contain location names")
	}

	// Test pagination by calling again
	oldStdout = os.Stdout
	r, w, _ = os.Pipe()
	os.Stdout = w

	err = commandMap(cfg, []string{})

	w.Close()
	os.Stdout = oldStdout

	var buf2 bytes.Buffer
	io.Copy(&buf2, r)
	output2 := buf2.String()

	if err != nil {
		t.Errorf("commandMap should not return error on second call, got: %v", err)
	}

	// Verify second page has different locations
	if strings.Contains(output2, "canalave-city-area") {
		t.Error("second page should not contain first page locations")
	}

	// Verify Previous was set after first call
	if cfg.Previous == nil {
		t.Error("commandMap should set Previous URL after first page")
	}
}

func TestCommandMapb(t *testing.T) {
	// Create config with cache and API client
	cache := pokecache.NewCache(5 * time.Second)
	pokeapiClient := pokeapi.NewClient(cache)

	// Test when on first page (Previous is nil)
	cfg := &config{
		pokeapiClient: pokeapiClient,
		caughtPokemon: make(map[string]pokeapi.PokemonResponse),
	}

	oldStdout := os.Stdout
	r, w, _ := os.Pipe()
	os.Stdout = w

	err := commandMapb(cfg, []string{})

	w.Close()
	os.Stdout = oldStdout

	var buf bytes.Buffer
	io.Copy(&buf, r)
	output := buf.String()

	if err != nil {
		t.Errorf("commandMapb should not return error, got: %v", err)
	}

	if !strings.Contains(output, "you're on the first page") {
		t.Error("output should contain 'you're on the first page' when Previous is nil")
	}

	// Test navigating forward then back
	cfg = &config{
		pokeapiClient: pokeapiClient,
		caughtPokemon: make(map[string]pokeapi.PokemonResponse),
	}

	// Go forward to page 2
	commandMap(cfg, []string{})
	commandMap(cfg, []string{})

	// Now go back to page 1
	oldStdout = os.Stdout
	r, w, _ = os.Pipe()
	os.Stdout = w

	err = commandMapb(cfg, []string{})

	w.Close()
	os.Stdout = oldStdout

	var buf2 bytes.Buffer
	io.Copy(&buf2, r)
	output2 := buf2.String()

	if err != nil {
		t.Errorf("commandMapb should not return error when going back, got: %v", err)
	}

	// Should contain first page locations
	if !strings.Contains(output2, "canalave-city-area") {
		t.Error("output should contain first page locations when going back")
	}

	// Verify Previous is now nil (we're on first page)
	if cfg.Previous != nil {
		t.Error("Previous should be nil after going back to first page")
	}
}

func TestCommandExplore(t *testing.T) {
	cache := pokecache.NewCache(5 * time.Second)
	pokeapiClient := pokeapi.NewClient(cache)
	cfg := &config{
		pokeapiClient: pokeapiClient,
		caughtPokemon: make(map[string]pokeapi.PokemonResponse),
	}

	// Test without arguments (should error)
	err := commandExplore(cfg, []string{})
	if err == nil {
		t.Error("commandExplore should return error when no arguments provided")
	}

	// Test with valid location area
	oldStdout := os.Stdout
	r, w, _ := os.Pipe()
	os.Stdout = w

	err = commandExplore(cfg, []string{"pastoria-city-area"})

	w.Close()
	os.Stdout = oldStdout

	var buf bytes.Buffer
	io.Copy(&buf, r)
	output := buf.String()

	if err != nil {
		t.Errorf("commandExplore should not return error with valid location, got: %v", err)
	}

	// Verify output
	if !strings.Contains(output, "Exploring pastoria-city-area...") {
		t.Error("output should contain exploring message")
	}

	if !strings.Contains(output, "Found Pokemon:") {
		t.Error("output should contain 'Found Pokemon:' header")
	}

	// Should contain at least some Pokemon
	if !strings.Contains(output, " - ") {
		t.Error("output should contain Pokemon names")
	}
}

func TestStartReplWithReader(t *testing.T) {
	// Test with unknown command and empty input
	input := "unknown\n\n"
	reader := strings.NewReader(input)
	commands := getCommands()

	// Capture stdout
	oldStdout := os.Stdout
	r, w, _ := os.Pipe()
	os.Stdout = w

	// Run REPL with test input
	startReplWithReader(reader, commands)

	// Restore stdout
	w.Close()
	os.Stdout = oldStdout

	// Read captured output
	var buf bytes.Buffer
	io.Copy(&buf, r)
	output := buf.String()

	// Verify output contains prompts and unknown command message
	if !strings.Contains(output, "Pokedex > ") {
		t.Error("output should contain REPL prompt")
	}

	if !strings.Contains(output, "Unknown command") {
		t.Error("output should contain 'Unknown command' for unknown command")
	}
}

func TestStartReplWithReaderWithError(t *testing.T) {
	// Create a command that returns an error for testing
	testCommands := map[string]cliCommand{
		"error": {
			name:        "error",
			description: "Test error command",
			callback: func(cfg *config, args []string) error {
				return fmt.Errorf("test error")
			},
		},
	}

	input := "error\n"
	reader := strings.NewReader(input)

	// Capture stdout
	oldStdout := os.Stdout
	r, w, _ := os.Pipe()
	os.Stdout = w

	// Run REPL with test input
	startReplWithReader(reader, testCommands)

	// Restore stdout
	w.Close()
	os.Stdout = oldStdout

	// Read captured output
	var buf bytes.Buffer
	io.Copy(&buf, r)
	output := buf.String()

	// Verify error is printed
	if !strings.Contains(output, "test error") {
		t.Error("output should contain error message")
	}
}

func TestStartRepl(t *testing.T) {
	// Use subprocess pattern to test startRepl
	if os.Getenv("BE_REPL_TEST") == "1" {
		// Redirect stdin to provide test input
		oldStdin := os.Stdin
		r, w, _ := os.Pipe()
		os.Stdin = r

		// Write exit command to stdin
		w.WriteString("exit\n")
		w.Close()

		// This will call os.Exit(0) via commandExit
		startRepl()

		// Restore stdin (won't be reached due to os.Exit)
		os.Stdin = oldStdin
		return
	}

	cmd := exec.Command(os.Args[0], "-test.run=TestStartRepl")
	cmd.Env = append(os.Environ(), "BE_REPL_TEST=1")
	err := cmd.Run()

	// startRepl should exit cleanly via the exit command
	if err != nil {
		t.Errorf("process exited with error: %v", err)
	}
}

func TestCommandCatch(t *testing.T) {
	cache := pokecache.NewCache(5 * time.Second)
	pokeapiClient := pokeapi.NewClient(cache)
	cfg := &config{
		pokeapiClient: pokeapiClient,
		caughtPokemon: make(map[string]pokeapi.PokemonResponse),
	}

	// Test without arguments (should error)
	err := commandCatch(cfg, []string{})
	if err == nil {
		t.Error("commandCatch should return error when no arguments provided")
	}

	// Test with valid Pokemon - try multiple times to ensure catch mechanics work
	oldStdout := os.Stdout
	r, w, _ := os.Pipe()
	os.Stdout = w

	pokemonName := "pikachu"
	caught := false
	maxAttempts := 20

	for i := 0; i < maxAttempts; i++ {
		err = commandCatch(cfg, []string{pokemonName})
		if err != nil {
			t.Errorf("commandCatch should not return error with valid Pokemon, got: %v", err)
			break
		}

		// Check if Pokemon was caught
		if _, ok := cfg.caughtPokemon[pokemonName]; ok {
			caught = true
			break
		}
	}

	w.Close()
	os.Stdout = oldStdout

	var buf bytes.Buffer
	io.Copy(&buf, r)

	if !caught {
		t.Errorf("should be able to catch %s within %d attempts", pokemonName, maxAttempts)
	}

	// Verify the caught Pokemon is stored correctly
	pokemon, ok := cfg.caughtPokemon[pokemonName]
	if !ok {
		t.Error("caught Pokemon should be in caughtPokemon map")
	} else {
		if pokemon.Name != pokemonName {
			t.Errorf("caught Pokemon name should be %s, got: %s", pokemonName, pokemon.Name)
		}
		if pokemon.BaseExperience == 0 {
			t.Error("caught Pokemon should have base experience > 0")
		}
	}
}

func TestCommandInspect(t *testing.T) {
	cache := pokecache.NewCache(5 * time.Second)
	pokeapiClient := pokeapi.NewClient(cache)
	cfg := &config{
		pokeapiClient: pokeapiClient,
		caughtPokemon: make(map[string]pokeapi.PokemonResponse),
	}

	// Test without arguments (should error)
	err := commandInspect(cfg, []string{})
	if err == nil {
		t.Error("commandInspect should return error when no arguments provided")
	}

	// Test with Pokemon not caught (should error)
	err = commandInspect(cfg, []string{"pikachu"})
	if err == nil {
		t.Error("commandInspect should return error when Pokemon not caught")
	}

	// Add a Pokemon to caught list
	pokemon, err := pokeapiClient.GetPokemon("pikachu")
	if err != nil {
		t.Fatalf("failed to get Pokemon for test: %v", err)
	}
	cfg.caughtPokemon["pikachu"] = *pokemon

	// Test with caught Pokemon
	oldStdout := os.Stdout
	r, w, _ := os.Pipe()
	os.Stdout = w

	err = commandInspect(cfg, []string{"pikachu"})

	w.Close()
	os.Stdout = oldStdout

	var buf bytes.Buffer
	io.Copy(&buf, r)
	output := buf.String()

	if err != nil {
		t.Errorf("commandInspect should not return error with caught Pokemon, got: %v", err)
	}

	// Verify output contains expected information
	expectedTexts := []string{
		"Name: pikachu",
		"Height:",
		"Weight:",
		"Stats:",
		"Types:",
	}

	for _, expected := range expectedTexts {
		if !strings.Contains(output, expected) {
			t.Errorf("output should contain %q, got:\n%s", expected, output)
		}
	}
}

func TestCommandPokedex(t *testing.T) {
	cache := pokecache.NewCache(5 * time.Second)
	pokeapiClient := pokeapi.NewClient(cache)
	cfg := &config{
		pokeapiClient: pokeapiClient,
		caughtPokemon: make(map[string]pokeapi.PokemonResponse),
	}

	// Test with no caught Pokemon
	oldStdout := os.Stdout
	r, w, _ := os.Pipe()
	os.Stdout = w

	err := commandPokedex(cfg, []string{})

	w.Close()
	os.Stdout = oldStdout

	var buf bytes.Buffer
	io.Copy(&buf, r)
	output := buf.String()

	if err != nil {
		t.Errorf("commandPokedex should not return error, got: %v", err)
	}

	if !strings.Contains(output, "You haven't caught any Pokemon yet!") {
		t.Error("output should contain message about no caught Pokemon")
	}

	// Add some Pokemon to caught list
	pokemon1, _ := pokeapiClient.GetPokemon("pikachu")
	pokemon2, _ := pokeapiClient.GetPokemon("charmander")
	cfg.caughtPokemon["pikachu"] = *pokemon1
	cfg.caughtPokemon["charmander"] = *pokemon2

	// Test with caught Pokemon
	oldStdout = os.Stdout
	r, w, _ = os.Pipe()
	os.Stdout = w

	err = commandPokedex(cfg, []string{})

	w.Close()
	os.Stdout = oldStdout

	var buf2 bytes.Buffer
	io.Copy(&buf2, r)
	output2 := buf2.String()

	if err != nil {
		t.Errorf("commandPokedex should not return error, got: %v", err)
	}

	// Verify output contains expected information
	if !strings.Contains(output2, "Your Pokedex:") {
		t.Error("output should contain 'Your Pokedex:' header")
	}

	if !strings.Contains(output2, "pikachu") {
		t.Error("output should contain pikachu")
	}

	if !strings.Contains(output2, "charmander") {
		t.Error("output should contain charmander")
	}
}