package aufgabe2;

import java.util.ArrayList;
import java.util.List;

public class CharCollection {
    private List<Character> chars = new ArrayList<>(); //neue Arraylist, mit Funktionen von "List"

    CharCollection(CharCollection cc){ //erstellen einer Liste mit Inhalt der Sammlung, exakte Kopie
        List<Character> chars = new ArrayList<>(); //neue Arraylist

        for(int i = 0; i < cc.size(); i++) { //if schleife arbeitet cc ab
            chars.add(cc.getChars().get(i)); //characters an der Stelle i werden der Collection hinzugefügt
        }

        setChars(chars); //Characters werden mit set in die Klassenvariable geschrieben
    }

    CharCollection(char... cs) { //erstellen einer CharCollection aus einem Array
        List<Character> chars = new ArrayList<>(); //neue Arraylist

        for(int i = 0; i < cs.length; i++) { //for schleife arbeitet cs ab
            chars.add(cs[i]); //Characters an der Stelle i im Array werden der Liste hinzugefügt
        }

        setChars(chars); //Characters werden mit set in die Klassenvariable geschrieben
    }

    CharCollection(String s){ //erzeugt aus Buchstabensammlung einen String
        List<Character> chars = new ArrayList<>(); //neue Arraylist

        for(int i = 0; i < s.length(); i++) { //for schleife arbeitet s ab
            chars.add(s.charAt(i)); //Characters an der Stelle i werden dem String hinzugefügt
        }

        setChars(chars); //Characters werden mit set in die Klassenvariable geschrieben
    }

    public int size() { //größe der Buchstabensammlung
        return chars.size(); //gibt die Anzahl der Characters zurück
    }

    public int count(char c) { //zählt vorkommen des übergebenen Buchstabens und liefert Anzahl zurück
        Character c2 = c; // neuer Character c2 wird erstellt
        int count = 0; //int count, zum Zählen des Buchstabens wird zu Anfang auf 0 gesetzt

        for(int i = 0; i < size(); i++) { //for schleife arbeitet Buchstabensammlung durch
            if(getChars().get(i).equals(c2)) { //prüft ob Characters an der Stelle i gleich c2 ist
                count++; //falls das zutrifft, wird count um 1 erhöht
            }
        }

        return count; //gibt zurück wie oft der Buchstabe vorkommt
    }

    public int different() { //gibt die Anzahl verschiedener Buchstaben zurück
        List<Character> tmp = new ArrayList<>(); //neue Arraylist

        for(int i = 0; i < size(); i++) { //for schleife arbeitet Buchstabensammlung durch
            if(!tmp.contains(chars.get(i))) { //falls tmp noch nicht den Character an der Stelle i enthält
                tmp.add(chars.get(i)); //wird dieser in tmp gespeichert
            }
        }

        return tmp.size(); //gibt Anzahl der Chars zurück
    }

    public char top() { //liefert den Buchstaben der am häufigsten vorkommt
        if(size() == 0) { //prüft ob Buchstabensammlung leer ist
            return 0; //wenn ja wird eine 0 zurückgegeben
        }

        int topCharIndex = 0; //Index des Characters, welcher am häufigsten vorkommt
        int topCharAmount = 0; //Anzahl wie oft der topChar vorkommt

        for(int i = 0; i < size(); i++) { //for schleife arbeitet Buchstabensammlung durch
            if(count(chars.get(i)) > topCharAmount) { //wenn eine Buchstabe an der Stelle i öfter vorkommt als topCharAmount
                topCharAmount = count(chars.get(i)); //dann wird Anzahl der Buchstaben in topCharAmount gespeichert
                topCharIndex = i; //und Index i wird in topCharIndex gespeichert
            }
        }

        return chars.get(topCharIndex); //gibt den Buchstaben zurück, welcher am häufigsten vorkommt
    }

    public String toString() { //liefert lesbare Darstellung der Characters
        String s = "("; //erstellen eines Strings s mit geöffneter Klammer

        for(int i = 0; i < size(); i++) { //for schleife arbeitet Buchstabensammlung durch
            s += chars.get(i); //Characters an der Stelle i werden s hinzugefügt
            if(i < size()-1) {
                s += ", "; //hinter jedem Character, bis auf das Letzte, wird ein Komma gesetzt
            }
        }

        s += ")"; //Klammer wird geschlossen
        return s; //und String s zurückgegeben
    }

    public CharCollection moreThan(int m) { //liefert Buchstaben die mehr als m mal vorkommen, m wird übergeben
        CharCollection returnCollection = new CharCollection(""); //leere CharCollection wird erstellt

        for(int i = 0; i < size(); i++) { //for schleife arbeitet Buchstabensammlung durch
            if(count(this.chars.get(i)) > m) { //zählt Buchstaben und prüft ob Anzahl des Buchstabens an Stelle i schon größer ist als m
                returnCollection.getChars().add(this.getChars().get(i));  //fügt der CharCollection den am häufigsten vorkommenden Buchstaben zu
            }
        }

        return returnCollection; //gibt die CharCollection zurück
    }

    public boolean equals(Object x) { //prüft ob x eine Sammlung mit den gleichen Buchstaben ist
        if(x instanceof CharCollection) { //Prüft ob x Objekt der Klasse CharCollection ist
            for(int i = 0; i < size(); i++) { //for schleife arbeitet Buchstabensammlung durch
                Character tmp = this.getChars().get(i); //liefert Character an der Stelle i
                if(((CharCollection) x).count(tmp) != this.count(tmp)) { //prüft ob ein Buchstabe unterschiedlich oft vorkommt
                    return false; //wenn ja, wird false zurückgegeben
                }
            }
            return true; //
        } else {
            return false; //
        }
    }

    public CharCollection except(CharCollection cc) { //liefert neue Buchstabensammlung, wobei alle Buchstaben von cc entfernt wurden
        CharCollection ccReturn = new CharCollection(this); //neue CharCollection ccReturn, in welcher das this Objekt gespeichert wird

        for(int i = 0; i < cc.size(); i++) { //for schleife arbeitet cc durch
            char tmp = cc.getChars().get(i); //zwischenspeichern von den Characters an der Stelle i
            for(int j = 0; j < ccReturn.size(); j++) { //for schleife arbeitet ccReturn durch
                if(tmp == ccReturn.getChars().get(j)) { //prüfe ob tmp gleich den Characters an der Stelle j ist
                    ccReturn.getChars().remove(j); //wenn ja, entferne die Chars an Stelle j
                    break; //gehe aus for schleife raus
                }
            }
        }

        return ccReturn; //gibt CharCollection zurück
    }

    public boolean isSubset(CharCollection cc) { //prüft ob übergebene Sammlung in Sammlung vorhanden ist
        for(int i = 0; i < cc.size(); i++) { //for schleife arbeitet cc durch
            if(cc.count(cc.getChars().get(i)) >  this.count(cc.getChars().get(i))) { //prüfe ob Anzahl der Buchstaben in cc größer ist als im this Objekt
                return false; //wenn ja kann cc nicht in this enthalten sein
            }
        }
        return true; //wenn nicht wird true zurückgegeben
    }

    public List<Character> getChars() {
        return chars; //gibt chars zurück
    }


    public void setChars(List<Character> chars) {
        this.chars = chars; //
    }
}