pokedex/main.go

package main

import (
	"bufio"
	"errors"
	"fmt"
	"maps"
	"os"
	"slices"
	"strings"
	"time"

	"codeflow.dananglin.me.uk/apollo/pokedex/internal/pokeclient"
)

type State struct {
	Previous *string
	Next     *string
}

var state State

type command struct {
	name        string
	description string
	callback    callbackFunc
}

type callbackFunc func(args []string) error

func main() {
	run()
}

func run() {
	client := pokeclient.NewClient(
		5*time.Minute,
		10*time.Second,
	)

	commandMap := map[string]command{
		"exit": {
			name:        "exit",
			description: "Exit the Pokedex",
			callback:    exitFunc,
		},
		"help": {
			name:        "help",
			description: "Displays a help message",
			callback:    nil,
		},
		"map": {
			name:        "map",
			description: "Displays the next 20 locations in the Pokemon world",
			callback:    mapFunc(client),
		},
		"mapb": {
			name:        "map back",
			description: "Displays the previous 20 locations in the Pokemon world",
			callback:    mapBFunc(client),
		},
		"explore": {
			name:        "explore",
			description: "Lists all the pokemon in a given area",
			callback:    exploreFunc(client),
		},
	}

	summaries := summaryMap(commandMap)

	commandMap["help"] = command{
		name:        "help",
		description: "Displays a help message",
		callback:    helpFunc(summaries),
	}

	fmt.Printf("\nWelcome to the Pokedex!\n")
	fmt.Print("\npokedex > ")

	scanner := bufio.NewScanner(os.Stdin)

	for scanner.Scan() {
		input := scanner.Text()

		command, args := parseArgs(input)

		cmd, ok := commandMap[command]
		if !ok {
			fmt.Println("ERROR: Unrecognised command.")

			fmt.Print("\npokedex > ")

			continue
		}

		if cmd.callback == nil {
			fmt.Println("ERROR: This command is defined but does not have a callback function.")

			fmt.Print("\npokedex > ")

			continue
		}

		if err := commandMap[command].callback(args); err != nil {
			fmt.Printf("ERROR: %v.\n", err)
		}

		fmt.Print("pokedex > ")
	}
}

func helpFunc(summaries map[string]string) callbackFunc {
	return func(_ []string) error {
		keys := []string{}

		for key := range maps.All(summaries) {
			keys = append(keys, key)
		}

		slices.Sort(keys)

		fmt.Printf("\nCommands:\n")

		for _, key := range slices.All(keys) {
			fmt.Printf("\n%s: %s", key, summaries[key])
		}

		fmt.Printf("\n\n")

		return nil
	}
}

func exitFunc(_ []string) error {
	os.Exit(0)

	return nil
}

func mapFunc(client *pokeclient.Client) callbackFunc {
	return func(_ []string) error {
		url := state.Next
		if url == nil {
			url = new(string)
			*url = pokeclient.LocationAreaEndpoint
		}

		return printResourceList(client, *url)
	}
}

func mapBFunc(client *pokeclient.Client) callbackFunc {
	return func(_ []string) error {
		url := state.Previous
		if url == nil {
			return fmt.Errorf("no previous locations available")
		}

		return printResourceList(client, *url)
	}
}

func exploreFunc(client *pokeclient.Client) callbackFunc {
	return func(args []string) error {
		if args == nil {
			return errors.New("the location has not been specified")
		}

		if len(args) != 1 {
			return fmt.Errorf(
				"unexpected number of locations: want 1; got %d",
				len(args),
			)
		}

		location := args[0]

		fmt.Println("Exploring", location)

		locationArea, err := client.GetLocationArea(location)
		if err != nil {
			return fmt.Errorf(
				"unable to get the location area: %w",
				err,
			)
		}

		fmt.Println("Found Pokemon:")

		for _, encounter := range slices.All(locationArea.PokemonEncounters) {
			fmt.Printf("- %s\n", encounter.Pokemon.Name)
		}

		return nil
	}
}

func printResourceList(client *pokeclient.Client, url string) error {
	list, err := client.GetNamedAPIResourceList(url)
	if err != nil {
		return fmt.Errorf("unable to get the list of resources: %w", err)
	}

	state.Next = list.Next
	state.Previous = list.Previous

	for _, location := range slices.All(list.Results) {
		fmt.Println(location.Name)
	}

	return nil
}

func summaryMap(commandMap map[string]command) map[string]string {
	summaries := make(map[string]string)

	for key, value := range maps.All(commandMap) {
		summaries[key] = value.description
	}

	return summaries
}

func parseArgs(input string) (string, []string) {
	split := strings.Split(input, " ")

	if len(split) == 0 {
		return "", nil
	}

	if len(split) == 1 {
		return split[0], nil
	}

	return split[0], split[1:]
}