/*
Kurwiu, jak jesteś z Wydziału Mądrości i Inteligencji UJ i znalazłeś ten kod przeszukując PasteBina, to masz wielkie szczęście, bo nie musisz sam opracowywać kodu z Javy, masz wszystkie komentarze podane tu na tacy. Życze smacznego i powodzenia jutro :>
*/

interface Email{                                      //(1) Interfejs Email z deklaracja dwoch metod
    public String getFrom();                          //(2) getterów dla pola From i pola Message
    public String getMessage();                       //(3)
}                                                     //(4)
// ##############################################     //(5)
class TextEmail implements Email{                     //(6)  Klasa TextEmail implementująca intefejs Email(1)
    private String from, message;                     //(7)  pola typu String from, message
    public TextEmail(String from, String message){    //(8)  Konstruktor klasy z polami from i message
        this.from = from;                             //(9)  przypisanie wartości z konstruktora do pol klasy
        this.message = message;                       //(10) poprzez słowo kluczowe this mówiące o tym, ze dopisujemy
    }                                                 //(11) do pola 'tego' obiektu klasy
    public String getFrom()   { return from;    }     //(12) Implementacja getterow dla pol From i Message
    public String getMessage(){ return message; }     //(13) z interfejsu Email (1)
}                                                     //(14)
// ##############################################     //(15)
class Filter{                                         //(16) Klasa Filter, z konstrukcji będąca prawie interfejsem
    public boolean check(Email r) {return true;}      //(17) Deklaracja dwóch metod - check i process, obie metody
    public void process(Email e){}                    //(18) w argumentach mają Email, metoda check zawsze zwraca
}                                                     //(19) boolean o wartości true
// ##############################################     //(20)
class PatternFilter extends Filter{                   //(21) Klasa PatterFilter rozszerzająca klasę Filter(16)
    private String pattern;                           //(22) pole typu String - pattern, do przechowywania regexa
    public PatternFilter(String pattern){             //(23) (wyrażenie regularne do filtrowania maili)
        this.pattern = pattern;                       //(24) <- Jednoargumentowy konstruor klasy przypisujący
    }                                                 //(25)                                             regex
    public boolean check(Email e){                    //(26) Metoda check, zwracająca wartość logiczną true lub false
        return (e.getFrom() + e.getMessage()).        //(27) w zależności od tego, czy pole form + message z Emaila
                matches(pattern);                     //(28) podanego w argumencie pasuje do podanego
    }                                                 //(29) w klasie wyrażenia regularnego
}                                                     //(30)
// ##############################################     //(31)
class FolderFilter extends PatternFilter{             //(32) Klasa FolderFilter rozszerzająca klasę PatterFilter(21)
    private String folder;                            //(33) Pole typu String przechowujące nazwę folderu
    public FolderFilter(String f,String p){           //(34) Konstruktor klasy z argumentami dla folderu i patternu
        super(p);                                     //(35) (regexu przekazywanego klasie nadrzednej poprzez slowo
        this.folder = f;                              //(36)  kluczowe super - wywoluje linie 23)
    }                                                 //(37)  W powyższej linii zwykłe przypisanie wartości do pola
    public void process(Email e){                     //(38)
        System.out.println("Moved to "+folder);       //(39) Metoda process z argumentem typu Email(1), przy wywolaniu
    }                                                 //(40) wyrzuca na ekran wiadomość Moved to 'folder
}                                                     //(41) z pola klasy(33)'
// ##############################################     //(42)
class PriorityFilter extends PatternFilter{           //(43) Klasa PriorityFilter rozszerzająca klase PatternFilter(21)
    public PriorityFilter(String p){                  //(44) Konstruktor klasy z wywołaniem kostruktora klasy nadrzędnej
        super(p);                                     //(45) (23) z argumentem bedacym wyrazeniem regularnym filtru
    }                                                 //(46)
    public void process(Email e){                     //(47) Metoda process z argumentem typu Email(1), przy wywołaniu
        System.out.println("Marked as important");    //(48) wyrzuca na ekran wiadomość 'Marked as important'
    }                                                 //(49)
}                                                     //(50)
// ##############################################     //(51)
class GroupFilter extends Filter{                     //(52) Klasa GroupFilter rozszerzajaca klase Filter(16)
    class Node{                                       //(53) Klasa wewnetrzna Node przechowujaca Filter (w tym kazda
        Filter filter;                                //(54) klase rozszerzajaca Filter, co wynika z polimorfizmu)
        Node next;                                    //(55) Referencja do kolejnego Node (struktura listy)
        Node(Filter filter, Node next){               //(56) Konstruktor klasy z argumentami Filter i Node
            this.filter = filter;                     //(57) przypisującymi polom klasy wartości z argumentów.
            this.next = next;                         //(58)
        }                                             //(59)
    }                                                 //(60)
    Node node;                                        //(61) Pole klasy GroupFilter - Node(53), czyli klasy wewnetrzenej
    public boolean check(Email e){                    //(62) Metoda check zwracajaca wartośc logiczną (true, false)
        Node n = this.node;                           //(63) Deklaracja zmiennej n typu Node, przypisująca wartość
        while(n!=null){                               //(64) z pola klasy Node. (61)
            if(n.filter.check(e)) return true;        //(65) Pętla przechodząca po całej liście Node'ów, aż do samego
            n = n.next;                               //(66) końca (czyli braku następnika listy [n!=null])
        }                                             //(67) Gdy któryś z regexów będzie pasować do Emaila z argumentu
        return false;                                 //(68) zwraca wartość true, jeżeli żaden nie przypasuje cała meto-
    }                                                 //(69) da zwraca false
    public void process(Email e){                     //(70) Metoda precess z argumentem typu Email(1)
        Node n = this.node;                           //(71) Deklaracja zmiennej node, analogicznie do linii 55.
        boolean r = false;                            //(72) Deklaracja zmiennej logicznej r, przypisana wartosc false
        while(n!=null){                               //(73) Petla przebiegajaca, po calej liscie Node`ów.
            if(n.filter.check(e)){                    //(74) Jeżeli którykolwiek z filtrów zwraca wartość true
                n.filter.process(e);                  //(75) to wykonaj metodę process (linie 38, 47)
                r = true;                             //(76) i jeżeli tak jest to przypisz zmiennej r wartość true
            }                                         //(77)
            n = n.next;                               //(78) Przejscie do nastepnego elemetu listy.
        }                                             //(79)
        if(!r) throw new RuntimeException(            //(80) Jeżeli r nie jest true, tzn jest false rzuca wyjątek
                "Cannot process message");            //(81) RuntimeException z komunikatem Cannot process message
    }                                                 //(82)
    public void setNext(Filter filter){               //(83) Dodawanie kolejnego Filter do listy Node.
        this.node = new Node(filter,this.node);       //(84) Przypisanie następnika listy do pola składowego klasy
    }                                                 //(85)
}                                                     //(86)
// ##############################################     //(87)
class EmailProcessor{                                 //(88) Klasa EmailProcessor
    GroupFilter filter = new GroupFilter();           //(89) Deklaracja zmiennej GroupFilter(52), z przypisaniem nowego
    public void addFilter(Filter filter){             //(90) obiektu. Metoda addFilter z argumentem typu Filter(16).
        this.filter.setNext(filter);                  //(91) Dodawanie kolejnego filtra do listy Node z klasy
    }                                                 //(92) GroupFilter(52)
    public void process(Email mail){                  //(93) Jednoargumentowa metoda process z argumentem typu Email.
        System.out.println("%%%->\nNew message from " //(94) Wypisywanie na ekran nadawcy Email z emial oraz tresci
                + mail.getFrom() + "\nMessage: "      //(95) wiadomosci.
                + mail.getMessage());                 //(96)
        filter.process(mail);                         //(97) Przetworzenie danego maila wedlug process z danego linii 70
    }                                                 //(98)
}                                                     //(99)
// ##############################################     //(100)
class Test{                                           //(101) Klasa test zawierajaca metode uruchamiajaca main
    public static EmailProcessor init(){              //(102) Metoda inicjalizująca EmailProcessor zwracajaca ten typ
        EmailProcessor p = new EmailProcessor();      //(103) Tworzenie nowego EmailProcessor
        Filter[] filters = {                          //(104) Stworzenie tablicy filtrów
                new Filter(),                         //(105) Pustego Filter
                new FolderFilter("work","(.*)company(.*)"),   //(106) FolderFilter z regexem w argumencie
                new PriorityFilter("(.*)money(.*)") };//(107) ProrityFilter z regexem w argumencie.
        for(Filter f : filters) p.addFilter(f);       //(108) Petla wykonujaca sie dla kazdego elementu tablicy filters
        return p;                                     //(109) przy kazdym kroku, dopisanie filtru do listy filtrow.
    }                                                 //(110) Na koniec zwrocenie ProcessFilter utworzonego w linii 103
    public static void main(String[] args){           //(111) Metoda uruchamiajaca main
        try{                                          //(112) Początek bloku try - catch, służacego do łapania wyjątków
            EmailProcessor p = init();                //(113) Przypisanie EmailProcessor z metody z linii 102 do zm. p
            Email m = new TextEmail(                  //(114) Stworzenie 3 maili typu TextEmail z parametrami
                    "noone@gmail.com","You won a lot of money!"); //(115)  from i message.
            Email b = new TextEmail(                  //(116) -*-
                    "boss@company.com","You got promoted!");      //(117) -*-
            Email h = new TextEmail(                  //(118) -*-
                    "hater@facebook.com","I like you!");          //(119) -*-
            Email[] inbox = {m,b,h};                  //(120) Tablica maili z linii 114, 116, 118 w zmiennej inbox
            for(Email mail : inbox) p.process(mail);  //(121) Wykonanie metody process dla każdego elementu tablicy
            p.process(new Email(){                    //(122) Wykonanywanie metody process dla obiektu anonimowego inter
                public String getFrom(){ return "#@#"; }      //(123) -fejsu Email z nadpisaniem metod tego interfejsu
                public String getMessage(){return "?!?";}});  //(124) na zwracajace #@# i ?!? (czyli regexy)
        }catch(Exception e){                          //(125) Lapanie wyjatku Exception (czyli kazdego wyjatku w tym
            System.out.println(e.getMessage());       //(126) przedewszystkim RuntimeException z linii 80)
        }                                             //(127) Przy przechwyceniu wyjatku wyrzuca na ekran wiadomosc bledu
    }                                                 //(128) przy RuntimeException z linii 80 wypisze na ekran
}                                                     //(129) 'Cannot process message'