main.go

package main

import (
	"bufio"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"math"
	"math/rand"
	"net/http"
	"os"
	"strings"
	"time"

	"example.com/simon/pokedexcli/internal/pokecache"
)

func cleanInput(text string) []string {
	return strings.Fields(strings.ToLower(text))
}

var commands = map[string]cliCommand{}

func commandExit(cfg *config, params []string) error {
	fmt.Println("Closing the Pokedex... Goodbye!")
	os.Exit(0)
	return nil
}

func commandHelp(cfg *config, params []string) error {
	fmt.Println("Welcome to the Pokedex!")
	fmt.Println("Usage:")
	fmt.Println("")
	for _, cmd := range commands {
		fmt.Printf("%s: %s\n", cmd.name, cmd.description)
	}
	return nil
}

type responseBody struct {
	Count    int              `json:"count"`
	Next     string           `json:"next"`
	Previous string           `json:"previous"`
	Results  []responseResult `json:"results"`
}

type pokemonResponse struct {
	BaseExperience int `json:"base_experience"`
}

type responseResult struct {
	Name string `json:"name"`
	Url  string `json:"url"`
}

func getUrl(url string, cfg *config) ([]byte, error) {
	if len(url) == 0 {
		return nil, errors.New("Url empty")
	}
	cached, found := cfg.cache.Get(url)
	if found {
		fmt.Println("Found url in cache, skipping http request")
		return cached, nil
	}
	fmt.Println("Not found in cache, loading via http")
	res, err := http.Get(url)
	if err != nil {
		return nil, err
	}
	defer res.Body.Close()
	if res.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("Request not successful got %s", res.Status)
	}

	bytes, err := io.ReadAll(res.Body)
	if err != nil {
		return nil, err
	}
	cfg.cache.Add(url, bytes)

	return bytes, nil
}

func getMap(url string, cfg *config) error {
	bytes, err := getUrl(url, cfg)
	if err != nil {
		return err
	}

	var js responseBody
	err = json.Unmarshal(bytes, &js)
	if err != nil {
		return err
	}
	cfg.next = js.Next
	cfg.previous = js.Previous
	for _, area := range js.Results {
		fmt.Println(area.Name)
	}
	return nil
}

func commandMap(cfg *config, params []string) error {
	return getMap(cfg.next, cfg)
}

func commandMapb(cfg *config, params []string) error {
	if len(cfg.previous) == 0 {
		fmt.Println("you're on the first page")
		return nil
	}
	return getMap(cfg.previous, cfg)
}

func commandCatch(cfg *config, params []string) error {
	if len(params) == 0 {
		return errors.New("No name given")
	}
	bytes, err := getUrl("https://pokeapi.co/api/v2/pokemon/"+params[0], cfg)
	if err != nil {
		return err
	}

	var js pokemon
	err = json.Unmarshal(bytes, &js)
	if err != nil {
		return err
	}

	fmt.Printf("Throwing a Pokeball at %s...\n", params[0])
	num := rand.Float64()
	baseChance := 0.9
	penalty := math.Max(0.5, float64(js.BaseExperience)/1000.0)
	if num < baseChance-penalty {
		fmt.Printf("%s was caught!\n", params[0])
		fmt.Println("You may now inspect it with the inspect command.")
		cfg.pokemons[params[0]] = js
	} else {
		fmt.Printf("%s escaped!\n", params[0])
	}

	return nil
}

func commandExplore(cfg *config, params []string) error {
	if len(params) == 0 {
		return errors.New("No name given")
	}
	bytes, err := getUrl("https://pokeapi.co/api/v2/location-area/"+params[0], cfg)
	if err != nil {
		return err
	}

	var js areaResponse
	err = json.Unmarshal(bytes, &js)
	if err != nil {
		return err
	}
	fmt.Printf("Exploring %s...\n", js.Name)
	if len(js.Encounters) > 0 {
		fmt.Println("Found Pokemon:")
		for _, enc := range js.Encounters {
			fmt.Printf("- %s\n", enc.Pokemon.Name)
		}
	}
	return nil
}

func commandInspect(cfg *config, params []string) error {
	if len(params) == 0 {
		return errors.New("No name given")
	}
	poke, found := cfg.pokemons[params[0]]
	if !found {
		fmt.Println("you have not caught that pokemon")
		return nil
	}
	fmt.Printf("Name: %s\nHeight: %d\nWeight: %d\n", poke.Name, poke.Height, poke.Weight)
	if len(poke.Stats) > 0 {
		fmt.Println("Stats:")
		for _, stat := range poke.Stats {
			fmt.Printf("  -%s: %d\n", stat.Stat.Name, stat.Value)
		}
	}
	if len(poke.Types) > 0 {
		fmt.Println("Types:")
		for _, tp := range poke.Types {
			fmt.Printf("  - %s\n", tp.Type.Name)
		}
	}

	return nil
}

func commandPokedex(cfg *config, params []string) error {
	fmt.Println("Your Pokedex:")
	for _, poke := range cfg.pokemons {
		fmt.Printf(" - %s\n", poke.Name)
	}
	return nil
}

type areaResponse struct {
	Name       string      `json:"name"`
	Encounters []encounter `json:"pokemon_encounters"`
}

type encounter struct {
	Pokemon pokemonEncounter `json:"pokemon`
}

type pokemonEncounter struct {
	Name string `json:"name"`
}

type pokemon struct {
	Name           string        `json:"name"`
	Height         int           `json:"height"`
	Weight         int           `json:"weight"`
	BaseExperience int           `json:"base_experience"`
	Stats          []pokemonStat `json:"stats"`
	Types          []struct {
		Type struct {
			Name string `json:"name"`
		} `json:"type"`
	} `json:"types"`
}

type pokemonStat struct {
	Stat struct {
		Name string `json:"name"`
	} `json:"stat"`
	Value int `json:"base_stat"`
}

type cliCommand struct {
	name        string
	description string
	callback    func(*config, []string) error
}

type config struct {
	next     string
	previous string
	cache    *pokecache.Cache
	pokemons map[string]pokemon
}

func main() {
	commands["help"] = cliCommand{
		name:        "help",
		description: "Displays a help message",
		callback:    commandHelp,
	}
	commands["exit"] = cliCommand{
		name:        "exit",
		description: "Exit the Pokedex",
		callback:    commandExit,
	}
	commands["map"] = cliCommand{
		name:        "map",
		description: "Display next 20 areas",
		callback:    commandMap,
	}
	commands["mapb"] = cliCommand{
		name:        "mapb",
		description: "Display previous 20 areas",
		callback:    commandMapb,
	}
	commands["catch"] = cliCommand{
		name:        "catch [name]",
		description: "Catch a pokemon by the given name",
		callback:    commandCatch,
	}
	commands["explore"] = cliCommand{
		name:        "explore [area]",
		description: "Explore pokemons in a specific area",
		callback:    commandExplore,
	}
	commands["inspect"] = cliCommand{
		name:        "inspect [name]",
		description: "Inspect a caught pokemon by name",
		callback:    commandInspect,
	}
	commands["pokedex"] = cliCommand{
		name:        "pokedex",
		description: "List all caught pokemons",
		callback:    commandPokedex,
	}

	cfg := config{
		next:     "https://pokeapi.co/api/v2/location-area",
		previous: "",
		cache:    pokecache.NewCache(1 * time.Minute),
		pokemons: map[string]pokemon{},
	}

	scanner := bufio.NewScanner(os.Stdin)
	fmt.Print("Pokedex > ")
	for scanner.Scan() {
		input := cleanInput(scanner.Text())
		if len(input) == 0 {
			continue
		}
		cmd, exists := commands[input[0]]
		if exists {
			err := cmd.callback(&cfg, input[1:])
			if (err) != nil {
				fmt.Printf("Error: %s\n", err.Error())
			}
		} else {
			fmt.Println("Unknown command")
		}
		fmt.Print("Pokedex > ")
	}
}