Supermarket Queue fast and heavy

/*
In a supermarket we have a very long queue of people. Usually the people are served in the order of their coming. When someone comes, he / she is appended at the end of the queue. When someone is served, he / she is removed from the front of the queue. Sometimes and old lady comes and the waiting people make a place for her somewhere in the queue. Because the queue could become very long (e.g. few thousand people), the supermarket management organizes a lottery and draws a random name from time to time. After each lottery draw, the management wants to know how many persons having the winning name are currently waiting in the queue.

Your task is to write a program to help the supermarket to handle the supermarket queue. It should hold a queue of N items numbered from 0 to N-1, where 0 is the front of the queue and N-1 is the position of the last person (end of the queue). A sample queue is given below:

position    0   1   2   3   4   5   6
name    Peter   Mike    Penka   Doncho  Nakov   Asya    Nakov
Your program should be able to process a sequence of the following commands:

Append [name] – appends a person with the specified name at the end of the queue. As a result the command prints " OK".
Insert [position] [name] – inserts a person with the specified name at the specified position in the queue (position 0 is just before the first person of the queue and position N is just after the last). In case of success, as a result the command prints " OK". In case the position is invalid, the command does nothing and prints " Error" as a result.
Find [name] – finds how many people with the specified name are currently waiting in the queue. As a result the command prints an integer number ( 0 or more ).
Serve [count] – serves the specified count of people according to their order in the queue. The served people are removed from the front of the queue. In case of success, as a result, the command prints the names of the served people in format "[name1] [name2] …" (at a single line, separated by space, ordered as in the queue). In case the count is invalid (bigger than the number of people in the queue), the command does nothing and prints " Error" as a result.
End – indicates the end of the input commands. Prints nothing and stops the program execution. This command appears only once, at the end of the input sequence of commands.
*/



import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class SupermarketQueue {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        //Que que = new Que();
        Que2 que2 = new Que2();

        while (true) {
            String command = br.readLine();
            if (command.equals("End")) {
                break;
            }
            //call(command, que); //TODO to run simple 11/16 tests solution (much more simple!!!)
            call(command, que2);
        }
    }

    private static void call(String command, Que2 que) {
        String[] temp = command.split(" ");
        switch (temp[0]) {
            case "Append": que.append(temp[1]); return;
            case "Insert": que.insert(temp[2], Integer.parseInt(temp[1])); return;
            case "Serve" : que.serve(Integer.parseInt(temp[1])); return;
            case "Find"  : que.findName(temp[1]); return;
            default: return;
        }
    }
    private static class Que{ //TODO "simple" solution -> 11/16 TLE
        List<String> queue;
        Map<String, Integer> namesCount;

        private Que() {
            queue = new LinkedList<>(); //fast add at the end and ability to add at index (slow) -> simple
            namesCount = new HashMap<>(); //fast check for names and update
        }

        private void append(String name) {
            queue.add(name);
            namesCount.put(name,namesCount.getOrDefault(name, 0) + 1); //combined update/or add name
            System.out.println("OK");

        }

        private void insert(String name, int position) {
            if (position < 0 || position > queue.size()) { //error check
                System.out.println("Error");
                return;
            }
            queue.add(position, name);
            namesCount.put(name,namesCount.getOrDefault(name, 0) + 1);
            System.out.println("OK");
        }

        private void findName(String name) {
            System.out.println(namesCount.getOrDefault(name, 0)); //name check returns 0 if no key (name) present
        }

        private void serve(int count) {
            if (count > queue.size()) {
                System.out.println("Error");
                return;
            }
            int counter = count;
            while (counter > 1) {
                String served = queue.get(0);
                queue.remove(0);
                System.out.print(served + " ");
                namesCount.put(served, namesCount.get(served) - 1);
                --counter;
            }
            String served = queue.get(0); //this part is to leave last name without " " space behind it.
            queue.remove(0);        // not needed as it appears !
            System.out.print(served);
            System.out.println();
            namesCount.put(served, namesCount.get(served) - 1);
        }
    }

    private static class Que2 { //much more complex TODO to be simplified but 16/16
        private ArrayList<ArrayList<String>> queue;
        private Map<String, Integer> namesCount; //for names (see Queue above)
        int currentIndex; //elements are NOT removed from the long queue !!! therefore no reindexing
        // but need to save current beggining of the queue
        int size; //same as above -> we need to save and update "real" size of the queue!

        private Que2() {
            queue = new ArrayList<>();
            namesCount = new HashMap<>();
            currentIndex = 0;
        }
        private void append(String name) {
            ArrayList<String> toAdd = new ArrayList<>(); //next elements are added on the index "0" in new arraylist
            //insert call puts elements in those arraylists instead of reindexing (fast but complicated ...)
            toAdd.add(name);
            queue.add(toAdd);
            ++size;
            namesCount.put(name,namesCount.getOrDefault(name, 0) + 1);
            System.out.println("OK");

        }

        private void insert(String name, int position) {
            if (position < 0 || position > size) {
                System.out.println("Error");
                return;
            }
            if (position == size) { //if this is true directly append at the end of the queue
                append(name);
                return;
            }
            if (position == 0) { //insert on "0" position
                if (size == 0) { //if all till now were served "start" new que by appending at the end
                    append(name);
                    return;
                } else {
                    queue.get(currentIndex).add(name);//TODO insert on position "0" in non-Empty queue adds the element
                    //TODO  at the end!!! of arraylist currently on this index in queue!
                    //TODO if we have {Ana, Peter, Joro} in the list on "0" position in the que (this is product from previous insertions)
                    //TODO we are adding next name at the END of this list!
                    //TODO later we will see that last elements are served first!
                    //TODO this is all to avoid reindexing in arraylist (slow operation)
                    ++size;
                    namesCount.put(name,namesCount.getOrDefault(name, 0) + 1);
                    System.out.println("OK");
                    return;
                }
            }

            int placeToAdd = currentIndex;
            int counter = position;
//TODO we need to find where to add if position is > 0
//TODO many elements of the queue may have size more than 1 because previous insertions!
            for (int i = placeToAdd; i < queue.size(); i++) { //we start from current beginning of the que
                int size = queue.get(i).size();
                if (counter >= size) { //if current element in the queue has smaller size than the desired position
                    counter -= size; //lower position and go to next element
                    continue;
                }
                if (counter == 0) { //we should add at the top(end) of current element! (faster)
                    queue.get(i).add(name);//we should not append as there are elemnts behind current
                    ++this.size; //appending is covered upper in the method
                    namesCount.put(name,namesCount.getOrDefault(name, 0) + 1);
                    System.out.println("OK");
                    return;
                }
                queue.get(i).add(size - counter, name); //if we need to add it on position different that last
                ++this.size;                                //linear time but seems unavoidable???
                namesCount.put(name,namesCount.getOrDefault(name, 0) + 1);//TODO consider optimisations! As the code is heavy and sorta ugly? :)
                System.out.println("OK");
                return;
            }
        }

        private void findName(String name) {
            System.out.println(namesCount.getOrDefault(name, 0));//see Que 1
        }

        private void serve(int count) {
            if (count > size) {
                System.out.println("Error");
                return;
            }
            int counter = count;
            while (counter > 0) {
                ArrayList<String> served = queue.get(currentIndex); //get current element in the queue (may have more than one names in it!)
                while (!served.isEmpty() && counter > 0) { //counter may become "0" before served is empty!!!
                    int last = served.size() - 1;
                    String name = served.get(last);
                    served.remove(last);//remove from the end -> fast
                    System.out.print(name + " ");//last name will have space behind -> works
                    namesCount.put(name, namesCount.get(name) - 1);//reduce names count
                    --size;//update size, as we are lowering the queue!
                    --counter;
                    if (served.isEmpty()) { //if isEmpty -> go to next element in the queue
                        ++currentIndex;
                    }
                }
            }
            System.out.println();
        }
    }
}