/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package grp24_ueb04;

/**
 * @author iam102683 Leon Singh
 * @author iam101589 Max Hasson
 */
public class Element {

    private int value;
    private Element next;

    /**
     * Getter-Methode der Instanzvariable value
     *
     * @return Wert der Instanzvariable value
     */
    public int getValue() {
        return this.value;
    }

    /**
     * Setter-Methode der Instanzvariable value
     *
     * @param value Wert den value bekommt
     */
    public void setValue(int value) {
        this.value = value;
    }

    /**
     * Getter-Methode der Instanzvariable next
     *
     * @return next nächstes Element
     */
    public Element getNext() {
        return this.next;
    }

    /**
     * Setter-Methode der Instanzvariable next
     *
     * @param next nächstes Element
     */
    public void setNext(Element next) {
        this.next = next;
    }

    /**
     * Anhängen eines neuen Listenelements hinter den vorhandenen
     * Listenelementen
     *
     * @param value Wert des anzuhängenden Listenelementes
     * @return Liste mit angehägten Listenelement
     */
    public Element appendElement(int value) {
        if (this.next == null) { //Prüft ob nächstes Element null ist.
            this.next = new Element();
            this.next.setValue(value); //Wenn ja wird nächstes Element value zugewiesen.
        } else {
            this.next = this.next.appendElement(value); //Wenn Wert im nächsten Element vorhanden ist, soll die Funtkion mit dem nächsten Element nochmal aufgerufen werden.
        }
        return this;
    }

    /**
     * Sortiertes Einfügen eines neuen Listenelements
     *
     * @param value Wert des anzuhängenden Listenelementes
     * @return Liste mit sortiert eingefügtem Listenelement
     */
    public Element insertElement(int value) {
        if (this.value >= value) { // Prüft ob derzeiter Wert größer oder gleich value ist.
            Element newElement = new Element();
            newElement.setValue(value);// Wenn ja, sollen die Werte vertauscht werden.
            newElement.setNext(this);
            return newElement;
        } else if (this.next == null) { //Wenn das nächste Element null ist, soll value darin eingefügt werden.
            Element newElement = new Element();
            newElement.setValue(value);
            this.next = newElement;
            return this;
        } else {
            this.next = this.next.insertElement(value);// Wenn nichts zutrifft soll insertElement mit dem nächsten Element geöffnet werden.
            return this;
        }
    }

    /**
     * Löscht ein Listenelement
     *
     * @param value Wert des zu löschenden Listenelementes
     * @return Liste ohne zu löschenden Listenelement; unveränderte Liste, wenn
     * Listenelement nicht vorhanden
     */
    public Element deleteElement(int value) {
        if (this.value == value) { //Wenn derzeitiger Wert gleich ist mit value, soll die Liste ab den nächsten Element zurück gegeben werden.
            return this.next; //
        } else {
            if (this.next != null && this.next.value <= value) { //Wenn nächstes Element nicht leer ist, und der nächste Wert kleiner gleich als value ist:
                this.next = this.next.deleteElement(value);//Dann soll die Rekursion mit dem nächsten Element fortfahren.
            }
            return this;
        }
    }

    /**
     * Gibt die Liste per println aus
     */
    public void printList() {
        System.out.println(value);
        if (this.next != null) {
            this.next.printList();
        }
    }

    /**
     * berechnet die Anzahl der Elemente
     *
     * @return Anzahl der Elemente
     */
    public int size() {
        if (this.next == null) { // Abbruchbedingung der Rekursion
            return 1;
        } else {
            return 1 + this.next.size(); //Wird mit jedem Aufruf um 1 erhört.
        }
    }

    /**
     * berechnet die Summe der Werte dieses und aller folgenden Elemente
     *
     * @return Summe
     */
    public int sum() {
        if (this.next == null) { // Abbruchbedingung der Rekursion
            return this.value;
        } else {
            return this.value + this.next.sum(); // Rechnet die Werte zusammen.
        }
    }

    /**
     * prüft, ob der Wert des folgenden Elemetes oder der fogenden Elemente
     * keinen kleineren Wert hat
     *
     * @return true, wenn kein Element folgt oder die folgenden Elemente jeweils
     * keinen kleineren Wert enthalten als ihr Vorgänger
     */
    public boolean isSorted() {
        if (this.next == null) { // Wenn am Ende angekommen, soll true zurück gegeben werden.
            return true;
        } else {
            if (this.value > this.next.value) { //Wenn derzeitiger Wert größer als der Wert im nächsten Element ist, soll false zurück gegeben werden.
                return false;
            }
            return this.next.isSorted(); //Geht alle Elemente mit einer Rekursion durch.
        }
    }

    /**
     * prüft, ob ein übergebener Wert den Wert dieses oder eines der folgenden
     * Elemente enhält
     *
     * @param value Wert der geprüft werden soll
     * @return true, wenn dieses oder eines der folgenden Elemente den
     * übergebenen Wert enthält
     */
    public boolean existsElement(int value) {
        if (this.value == value) { // Wenn gleicher Wert gefunden soll true zurück gegeben werden.
            return true;
        } else {
            if (this.next == null|| this.next.value > value) {//Wenn am Ende angekommen und kein gleicher Wert gefunden, oder Nächster Wert schon größer als Value ist, soll false zurück gegeben werden.
                return false;
            }
            return this.next.existsElement(value); // Rekursion --> Ruft nächstes Element auf.
        }
    }

    /**
     * liefert einen String mit diesem Wert und jeweils durch ein Leerzeichen
     * getrennt alle folgenden Werte
     *
     * @return String
     */
    public String showValues() {
        if (this.next == null) { // Abbruchbedingung der Rekursion
            return String.valueOf(this.value);
        } else {
            return String.valueOf(this.value) + " " + String.valueOf(this.next.showValues()); // Geht alle Elemente mit einer Rekursion durch und speichert sie als String getrennt durch einen Leerzeichen ein.
        }
    }

    /**
     * liefert den Wert an der Stelle index
     *
     * @param index Index
     * @return Wert an der Stelle von index; index ungültig, Integer.MAX_VALUE
     */
    public int getValueAt(int index) {
        if (index != 0 && this.next == null) { // Wenn index 0 noch nicht erreicht wurde, aber der nächste index schon null ist, da gibt es den index(Parameter) nicht.
            return Integer.MAX_VALUE;// Maximaler Integer Wert wird zurück gegeben.
        } else {
            if (index == 0) { //Abbruchbedingung der Rekursion --> Return der Wert am Index
                return this.value;
            }
            return this.next.getValueAt(index - 1); // Wenn Index 0 nicht erreicht wurde, soll index um 1 verkleinert werden.
        }
    }

    /**
     * fügt ein neues Element mit dem übergebenen Wert an der Stelle index ein
     *
     * @param value Wert der eingefügt werden soll
     * @param index Stelle, an der der Wert eingefügt werden soll
     * @return Liste mit eingefügtem Listenelement; Liste mit angehägtem
     * Listenelement, wenn Index = Arraylänge; Listenelement und alle Folgenden
     * unverändert, wenn index ungültig
     */
    public Element insertElementAt(int value, int index) {
        if (index == 1 && this.next == null) {
            return appendElement(value);
        } else if (index == 0) {
            Element newElement = new Element();
            newElement.setValue(value);
            newElement.setNext(this);
            return newElement;
        } else if (this.next != null) {
            this.next = this.next.insertElementAt(value, index - 1);
        }
        return this;
    }

    /**
     * fügt ein Element mit dem Wert value an den Anfang der Liste
     *
     * @param value einzufügender Wert
     * @return Liste mit angefügten Element
     */
    public Element insertElementAtFront(int value) {
        return this.insertElementAt(value, 0);
    }