문제 // 자료구조 // 큐(Queue) // 병합큐 // toJava

/**
 * [동물보호소 - 병합큐 처리하기]
 *  먼저 들어온 동물이 먼저 나가는 동물 보호소
 *  개와 고양이만 수용
 *  개와 고양이중 선택
 *  하지만 특정 동물을 지정해서 데려갈 수 는 없음
 *  enqueue dequeueAny dequeueDog dequeueCat
 *  LinkedList 사용가능
 *
 * [풀이]
 *  => 개와 고양이가 객체여야 하는가 ?
 *  => 개와 고양이의 큐를 따로 사용해도 되는가 ?
 *  => dequeueAny는 랜덤을 말하는 건가 ?
 *      => 개와 고양이중 먼저들어온 것을 가져오는 것
 *
 * [주의]
 *  => 상속으로 Animal클래스를 사용하면 좋음
 *  => 객체에 우선순위 ( 타임스탬프 ) 를 설정해 줄 것
 */

public class Q06 {

    public static void main(String[] args) {
        AnimalQueue aq = new AnimalQueue();
        aq.enqueue(new Dog("DogA"));
        aq.enqueue(new Dog("DogB"));
        aq.enqueue(new Dog("DogC"));
        aq.enqueue(new Cat("CatA"));
        aq.enqueue(new Cat("CatB"));
        aq.enqueue(new Cat("CatC"));

        System.out.println(aq.dequeueDog().name); // DogA
        System.out.println(aq.dequeueCat().name); // CatA
        System.out.println(aq.dequeueAny().name); // DogB
        System.out.println(aq.dequeueAny().name); // DogC
        System.out.println(aq.dequeueAny().name); // CatB
        System.out.println(aq.dequeueAny().name); // CatC
    }

    /* Animal Model */
    static class Animal {
        String name;
        int order;
        public Animal(String name) {
            this.name = name;
        }
        public void setOrder(int order) {
            this.order = order;
        }
    }

    /* Dog Model */
    static class Dog extends Animal {
        public Dog(String name) {
            super(name);
        }
    }

    /* Cat Model */
    static class Cat extends Animal {
        public Cat(String name) {
            super(name);
        }
    }

    /* 동물보호소 */
    static class AnimalQueue {

        // == Field ==
        Queue<Animal> dogs;
        Queue<Animal> cats;
        int order = 0;

        // == Constructor ==
        public AnimalQueue() {
            dogs = new LinkedList<>();
            cats = new LinkedList<>();
        }

        // == enqueue - dog ==
        public void enqueue(Animal animal) {
            animal.setOrder(order++);
            if(animal instanceof Dog) dogs.add(animal);
            else cats.add(animal);
        }

        // == dequeueAny - order ==
        public Animal dequeueAny() {
            if(dogs.size() == 0 && cats.size() != 0) {
                return cats.remove();
            }
            else if(dogs.size() != 0 && cats.size() == 0) {
                return dogs.remove();
            }
            else if(dogs.size() != 0 && cats.size() != 0) {
                if(dogs.peek().order > cats.peek().order) {
                    return dogs.remove();
                } else {
                    return cats.remove();
                }
            }
            return null;
        }

        // == dequeueDog ==
        public Dog dequeueDog() {
            if(dogs.size() > 0) {
                return (Dog) dogs.remove();
            }
            return null;
        }

        // == dequeueCat ==
        public Cat dequeueCat() {
            if(cats.size() > 0) {
                return (Cat) cats.remove();
            }
            return null;
        }
    }
}