repl.go

package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"

	"github.com/opsmonkey/pokedexcli/internal/pokeapi"
)

type config struct {
	pokeapiClient *pokeapi.Client
	Previous      *string
	Next          *string
	pokedex       map[string]pokeapi.Pokemon
}

func (c *config) SetNext(url string) {
	c.Next = &url
}

func (c *config) SetPrevious(url string) {
	c.Previous = &url
}

// struct to map commands to callback functions
type cliCommand struct {
	name        string
	description string
	callback    func(*config, ...string) error
}

func getCommandsRegister() map[string]cliCommand {

	return map[string]cliCommand{
		"exit": {
			name:        "exit",
			description: "Exit the Pokedex",
			callback:    commandExit,
		},
		"help": {
			name:        "help",
			description: "Displays a help message",
			callback:    commandHelp,
		},
		"map": {
			name:        "map",
			description: "Displays location areas from the PokeAPI",
			callback:    commandMap,
		},
		"mapb": {
			name:        "mapb",
			description: "Displays previous location areas from the PokeAPI",
			callback:    commandMapBack,
		},
		"explore": {
			name:        "explore",
			description: "provides a list of all pokemon found in a given area",
			callback:    commandExploreLocation,
		},
		"catch": {
			name:        "catch",
			description: "catch a pokemon!",
			callback:    commandCatch,
		},
		"inspect": {
			name:        "inspect",
			description: "inspect a caught pokemon",
			callback:    commandInspect,
		},
		"pokedex": {
			name:        "pokedex",
			description: "check out all of your caught pokemon",
			callback:    commandPokedex,
		},
	}
}

// Starts the REPL loop for the main program
func startRepl(cfg *config) {
	scanner := bufio.NewScanner(os.Stdin)

	commands := getCommandsRegister()
	for {

		fmt.Print("Pokedex > ")

		if !scanner.Scan() {
			break
		}

		input := scanner.Text()

		cleaned := cleanInput(input)

		// if an empty array is returned, continue to next iteration of the loop
		if len(cleaned) == 0 {
			continue
		}

		// if clean input returns more than one value, there's potentially a sub command/arg to process
		var commandArgs []string
		if len(cleaned) > 1 {
			commandArgs = cleaned[1:]
		}

		command, exists := commands[cleaned[0]]

		if !exists {
			fmt.Println("Unknown command")
			continue
		}

		if err := command.callback(cfg, commandArgs...); err != nil {
			fmt.Println(err)
		}

	}

	// check for any errors encountered while reading from stdin
	if err := scanner.Err(); err != nil {
		errorOut := fmt.Errorf("error reading input from std in: %v", err)
		fmt.Print(errorOut)
	}
}

// cleanInput splits the user's input into "words" based on whitespace. Output is lowercase, trimming any leading or trailing whitespace.
func cleanInput(text string) []string {

	// Fields splits the string s around each instance of one or more consecutive white space characters
	split := strings.Fields(strings.ToLower(text))
	return split
}