Pokemon

Gotta catch 'em all
You are given the task to implement a system that ranks different pokemons. Each one of them has a name, type, power and current position on the leaderboard. The system should be able to add new pokemons, find all pokemons of a given type and get the ranking in some range (start and end positions).

Here are the commands that must be implemented:

add POKEMON_NAME POKEMON_TYPE POKEMON_POWER POKEMON_POSITION - adds new pokemon to the rank list;
POKEMON_NAME can be any sequence from 1 to 20 characters;
POKEMON_TYPE can be any sequence from 1 to 10 characters;
POKEMON_POWER can be any integer between 10 and 50;
POKEMON_POSITION can be any integer between 1 and the current pokemons count plus one (e.g. if there are 2 pokemons already, POKEMON_POSITION can be 1, 2 or 3). If a pokemon is inserted to an already used position, all pokemons' positions from this position till the end are incremented by one (e.g. if the ranking system has Pokemon1 in position 1, Pokemon2 in position 2 and is inserting Pokemon3 in position 1 => Pokemon1 goes to position 2 and Pokemon2 goes to position 3).
Prints: Added pokemon POKEMON_NAME to position POKEMON_POSITION;
find POKEMON_TYPE - finds the top 5 pokemons, first ordered by name in ascending order and then by power in descending order;
Prints the results in the following format "Type POKEMON_TYPE: POKEMON; POKEMON; POKEMON" where POKEMON should be printed in the format POKEMON_NAME(POKEMON_POWER). If no pokemons are found, just print Type POKEMON_TYPE: (ending whit one space).
ranklist START END - prints the rank list from START to END positions;
START can be any integer between 1 and current pokemons count;
END can be any integer between 1 and current pokemons count (and will be greater than or equal to START);
end - marks the end of the commands and no other commands will follow afterward.



import java.util.*;
import java.util.stream.Collectors;

import static java.lang.String.format;

public class GottaCatchEmAll {

    static HashMap<String, TreeSet<Pokemon>> pokemonByType = new HashMap<>();
    static ArrayList<Pokemon> listPokemon = new ArrayList<>();
    static StringBuilder result = new StringBuilder();

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);

        String[] line = scan.nextLine().split(" ");

        while (!line[0].equals("end")) {
            switch (line[0]) {
                case ("add"):
                    createPokemon(line[1], line[2], Integer.parseInt(line[3]), Integer.parseInt(line[4]));
                    break;
                case ("find"):
                    findByType(line[1]);
                    break;
                case ("ranklist"):
                    ranklist(Integer.parseInt(line[1]), Integer.parseInt(line[2]));
            }

            line = scan.nextLine().split(" ");

        }
        result.trimToSize();
        System.out.println(result);


    }

    public static void createPokemon(String name, String type, int power, int position) {

        Pokemon pokemon = new Pokemon(name, type, power, position);
        result.append(format("Added pokemon %s to position %d%n", pokemon.getName(), pokemon.getPosition()));
        if (listPokemon.size() == 0) {
            listPokemon.add(pokemon);
        } else {
            if (position <= listPokemon.size()) {
                listPokemon.add(position - 1, pokemon);
            } else {
                listPokemon.add(pokemon);
            }
        }

//        TreeSet<Pokemon> sortedPok = new TreeSet<>();
//        pokemonByType.put(type, sortedPok);
//        sortedPok = pokemonByType.get(type);
//        sortedPok.add(pokemon);
        pokemonByType.putIfAbsent(type, new TreeSet<>());
        pokemonByType.get(type).add(pokemon);


    }

    //Type Water: Squirtle(40); Squirtle(22)
    public static void findByType(String type) {
        result.append(String.format("Type %s: ", type));
        if (pokemonByType.containsKey(type)) {
            result.append(pokemonByType.get(type).stream()
                    .limit(5)
                    .map(Pokemon::toString)
                    .collect(Collectors.joining("; ")));
        }
        result.append(System.lineSeparator());
    }

    public static void ranklist(int start, int end) {


        for (int i = start-1; i < end; i++) {

            if(i == end-1){
                result.append(i+1).append(". ").append(listPokemon.get(i));
                break;
            }

            result.append(i+1).append(". ").append(listPokemon.get(i)).append("; ");
        }
        result.append(System.lineSeparator());
    }

    static class Pokemon implements Comparable<Pokemon> {
        private String name;
        private String type;
        private int power;
        private int position;

        public Pokemon(String name, String type, int power, int position) {
            setName(name);
            setType(type);
            setPower(power);
            this.position = position;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            if (name.length() > 20 || name.length() < 1) {
                throw new InputMismatchException("Name must be between 1 and 20 chars");
            }
            this.name = name;
        }

        public String getType() {
            if (type.length() > 20 || type.length() < 1) {
                throw new InputMismatchException("Type must be between 1 and 20 chars");
            }
            return type;
        }

        public void setType(String type) {
            this.type = type;
        }

        public int getPower() {
            return power;
        }

        public void setPower(int power) {
            if (power > 50 || power < 10) {
                throw new InputMismatchException("Power must be between 10 and 50 chars");
            }
            this.power = power;
        }

        public int getPosition() {
            return position;
        }


        @Override
        public int hashCode() {
            return Objects.hash(name, type, power);
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Pokemon pokemon = (Pokemon) o;
            return Objects.equals(name, pokemon.name) && Objects.equals(type, pokemon.type);
        }

        @Override
        public int compareTo(Pokemon pokemon) {
            int compareName = this.getName().compareTo(pokemon.getName());
            if (compareName == 0) {
                return pokemon.getPower() - this.getPower();
            } else {
                return compareName;
            }

        }

        @Override
        public String toString() {
            return String.format("%s(%d)", getName(), getPower());
        }
    }
}