import java.util.List;
import java.util.Map;
import java.util.stream.Stream;
import java.util.*;
import java.util.stream.Collectors;

class Sorter implements SorterInterface{
    Stream<? extends Box3D> strumien;

    /**
     * Metoda odczytuje nazwe klasy obiektu, ktorego referencja
     * zostala od metody dostarczona.
     * @param o referencja do obiektu, ktorego nazwa klasy jest poszukiwana
     * @return nazwa obiektu odczytana na podstawie przekazanej referencji
     */
    public static String getName(Object o) {
        return o.getClass().getSimpleName();
    }

    /**
     * Klasa prezentujaca mozliwosc pobrania nazwy klasy gdy dysponujemy referencja
     * do obiektu interesujacej nas klasy. Kod mozna uruchomic (w systemie Linux) za
     * pomoca polecenia: <br><tt>java8 SorterInterface\$Show</tt>
     */
    /*public class Show {
        public static void main(String[] args) {
            System.out.println(SorterInterface.getName(new Show()));
            System.out.println(SorterInterface.getName(new Object()));
            System.out.println(SorterInterface.getName("Ala ma kota"));
            System.out.println(SorterInterface.getName(123));
        }
    }*/

    /**
     * Metoda pozwala na przekazanie obiektowi strumienia, z ktorego obiekt bedzie
     * pobierac dane. Strumien zawiera w sobie obiekty klasy Box3D i
     * kllas pochodnych.
     *
     * @param stream
     *            strumien z danymi
     */
    public void setInputStream(Stream<? extends Box3D> stream){
        strumien = stream;
    }

    /**
     * Metoda dokonuje przegladu obiektow umieszczonych w strumieniu przekazanym za
     * pomoca setInputStream oraz znajdujacych sie na przekazanej jako argument
     * wywolania liscie. Matoda zwraca mape zawierajaca jako klucz nazwe klasy, z
     * ktorej obiekt wygenerowano, a dla danego klucza, liste obiektow znalezionych
     * w strumieniu i na przekazanej liscie
     *
     * @param additionalInput
     *            lista zawierajaca obiekty typu Box3D i klas pochodnych
     * @return mapa, w ktorej nazwa klasy wskazuje na liste wszystkich obiektow tej
     *         klasy.
     */
    public Map<String, List<Box3D>> find(List<? extends Box3D> additionalInput){

        Map<String, List<Box3D>> mapa = new HashMap<String, List<Box3D>>();
        List<Box3D> merge = Stream.concat(strumien, additionalInput.stream()).collect(Collectors.toList());
        mapa = merge.stream().collect(Collectors.groupingBy(o->getName(o)));

        return mapa;
    }

    /**
     * Metoda dokonujaca posortowania obiektow udostepnionych poprzez strumien i
     * additionalInput. Obiekty nalezy posortowac rosnaco wzgledem wartosci
     * zwracanej przez metode getValue.
     *
     * @param additionalInput
     *            lista zawierajaca obiekty typu Box3D i klas pochodnych
     * @param output
     *            wynik sortowania
     */
     @SuppressWarnings("unchecked")
    public void sizeSort(List<? extends Box3D> additionalInput, List<? super Box3D> output){
        List<? extends Box3D> list = strumien.collect(Collectors.toList()) ;
        List<? extends Box3D> temp = Stream.of(list, additionalInput).flatMap(Collection::stream).collect(Collectors.toList());
        temp.stream().sorted(Comparator.comparing(Box3D::getValue)).map(o->(Box3D)o).forEach(o->output.add(o));
        //output.sort(Comparator.comparing(o -> o.getValue()));
        //output = (List<? super Box3D>)test;
    }

    /**
     * Metoda przeszukuje przekazany za pomoca metody setInputStream strumien i
     * wyszukuje obiekty, ktorych <b>typ jest inny</b> niz ten, ktory zostal
     * przekazany jako obiekt wzorca (object).
     *
     * @param object
     *            obiekt, ktorego typ ma zostac uzyty do przeszukania strumienia
     * @param output
     *            wynikowa lista zawierajaca wszystkie obiekt ze strumienia, ktorych
     *            typ nie jest taki sam jak typ object.
     */
     @SuppressWarnings("unchecked")
    public void findObjectsDifferentThan(Box3D object, List<? super Box3D> output){
        //List<Box3D> temp = strumien.filter(o -> !(object.getClass().equals(o.getClass()))).collect(Collectors.toList());
        strumien.filter(o -> !(getName(object) == getName(o))).map(o->(Box3D)o).forEach(o->output.add(o));
        //output = (List<? super Box3D>)temp;
    }

    /**
     * Metoda przeszukuje strumien w poszukiwaniu obiektow, ktorych rozmiar mozna
     * poznac. Te umieszcza na wynikowej liscie, o ile ich rozmiar bedzie wiekszy niz
     * rozmiar przekazanego obiektu object2compare.
     *
     * @param object2compare
     *            obiekt do porownania
     * @return lista z obiektami, ktore sa wieksze od obiektu przekazanego.
     */
    public List<? extends Box3D> findObjectsLargerThan(Box3DWithSize object2compare){
        @SuppressWarnings("unchecked")
        List<Box3DWithSize> output = (List<Box3DWithSize>)strumien.filter(o->o instanceof Box3DWithSize).collect(Collectors.toList());
        output = output.stream().filter(o->o.getSize()>object2compare.getSize()).collect(Collectors.toList());
        return output;
    }
}