package inport.ConversionUtils;

import inport.*;
import java.util.*;

public class Utils {
    static class PairComparator<T extends Comparable<T>, U extends Comparable<U>> implements Comparator<Pair<T, U>> {
        public int compare(Pair<T, U> p1, Pair<T, U> p2) {
            int res = p1.getKey().compareTo(p2.getKey());
            if (res != 0) {
                return res;
            } else {
                return p1.getValue().compareTo(p2.getValue());
            }
        }
    }

    static public ArrayList<Integer> integerArray(int size, int initVal) {
        ArrayList<Integer> res = new ArrayList<>();
        for (int i = 0; i < size; i++) {
            res.add(initVal);
        }
        return res;
    }

    static public ArrayList<ArrayList<Integer>> arrayOfIntegerArrays(int size) {
        ArrayList<ArrayList<Integer>> res = new ArrayList<>();
        for (int i = 0; i < size; i++) {
            res.add(new ArrayList<>());
        }
        return res;
    }

    static public ArrayList<Set<Integer>> arrayOfIntegerSet(int size) {
        ArrayList<Set<Integer>> res = new ArrayList<>();
        for (int i = 0; i < size; i++) {
            res.add(new TreeSet<>());
        }
        return res;
    }

    static public MovingObject getExecutor(OperationTemplate t) {
        if (t instanceof LoadingTemplate) {
            return ((LoadingTemplate) t).getLoader();
        }
        if (t instanceof MooringTemplate) {
            return ((MooringTemplate) t).getMoorer();
        }
        if (t instanceof MovingTemplate) {
            return ((MovingTemplate) t).getMover();
        }
        return null;
    }

    static public List<MovingObject> getResources(OperationTemplate t) {
        List<MovingObject> res = new ArrayList<>();
        if (t instanceof LoadingTemplate) {
            res.addAll(((LoadingTemplate) t).getResources());
        }
        if (t instanceof MooringTemplate) {
            res.addAll(((MooringTemplate) t).getResources());
        }
        if (t instanceof MovingTemplate) {
            res.addAll(((MovingTemplate) t).getResources());
        }
        return res;
    }

    static public boolean isCompatible(OperationTemplate t1, OperationTemplate t2) {
        MovingObject exec1 = getExecutor(t1);
        Berth place1 = t1.getStartLocation();
        List<MovingObject> resources1 = getResources(t1);

        MovingObject exec2 = getExecutor(t2);
        Berth place2 = t2.getStartLocation();
        List<MovingObject> resources2 = getResources(t2);
        // Пересекаемость ресурсов
        for (Object res2 : resources2)
            if (resources1.contains(res2))
                return false;
        // Выполнитель = ресурс
        if (resources1.contains(exec2))
            return false;
        // Ресурс = выполнитель
        if (resources2.contains(exec1))
            return false;

        // Выполнитель = выполнитель
        if (exec1.equals(exec2))
        {
            // Это не погрузка
            if (!(t1 instanceof LoadingTemplate) || (!(t2 instanceof LoadingTemplate)))
                return false;
            // Разные причалы
            if (!place1.equals(place2))
                return false;
            Storage s1 = ((LoadingTemplate)t1).getStorage();
            Storage s2 = ((LoadingTemplate)t2).getStorage();
            // В одно хранилище
            if (s1.equals(s2))
                return false;
        }
        else
            // На одном причале и это не перемещения
            if (place1.equals(place2) && (!(t1 instanceof MovingTemplate)) && (!(t2 instanceof MovingTemplate)))
                return false;

        return true;
    }
}