package wi18.oose;

import java.util.Comparator;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.Arrays;

public class AL<E> implements List<E> {
  protected E[] store = (E[]) new Object[5];
  protected int size = 0;

  public AL(E... es) {
    //E... bedeutet es muss nichts gegeben sein oder alles was gegeben wird
    // wird als Liste übernommen, von dieser Liste werden dann alle Element mit der for Schleife
    // dem Array store eingefügt
    for (E e : es)
      add(e);
  }

  private void mkNewStore() {
    E[] newStore = (E[]) new Object[size + 5];
    for (int i = 0; i < store.length; i++)
      newStore[i] = store[i];
    store = newStore;
  }

  public void add(E e) {
    if (store.length <= size)
      mkNewStore();
    store[size++] = e;
  }

  public int size() {
    return size;
  }

  public E get(int i) {
    return store[i];
  }

  @Override
  public void addAll(List<E> cs) {
    for (int i = 0; i < cs.size(); i++) {
      add(cs.get(i));
    }
  }

  @Override
  public void remove(int i) {
    if (i<0){return;}
    if (i>store.length){return;}
    else{
      for (; i < (size-1) ; i++){
        store[i]=store[i++];
      }
    }

  }

  @Override
  public void insert(int i, E e) {
    //if (i==null){return;}
    if (i<0){return;}
    if (i>=size){
      add(e);
    }
    else {
      for (int s=size-1; s > i ; s--) {
        store[++s]=store[s];
      }
      store[i]=e;
      size++;
    }
  }

  @Override
  public boolean contains(E e) {
    for (int i = 0; i < store.length; i++) {
      if (get(i).equals(e)){
        return true;
      }

    }
    return false;
  }

  @Override
  public boolean containsWith(Predicate<E> pred) {
    for (int i = 0; i < store.length; i++) {
      if (pred.test(get(i))) {
        return true;
      }
    }
    return false;
  }

  @Override
  public void reverse() {
    E[] newStore = (E[]) new Object[size];
    for (int i = 0; i<size; i++) {
      newStore[i]=store[--size];
    }
    store = newStore;

  }

  @Override
  public void forEach(Consumer<? super E> consumer) {
    for(E e : store){
      consumer.accept(e);
    }
  }

  @Override
  public boolean startsWith(List<E> that) {
    int x = that.size();
    if (x > size) {
      return false;
    }
    for (int i = 0; i < x; i++) {
      if (!(store[i] == that.get(i))) {
        return false;
      }
    }
    return true;
  }

  @Override
  public boolean endsWith(List<E> that) {
    //store = 1,2,3,4,5 size = 5
    //that = 3,4,5 size = 3
    // output= true
    int z = 0;
    int x = size - that.size(); // x = 5-3 = 2 also index 2
    for (; x <size; x++) { // von index 2 überprüfe ob alle store[x++] == that[i] mit i=0; i++;
      if (!(store[x]==that.get(z++))){return false;}

    }
    return true;
  }

  @Override
  public List<E> sublist(int i, int l) {
    List<E> newList = new AL<E>();
    if (l>(size-i))
      l--;
    for (; i < l; i++) {
      newList.add(store[i]);
    }
    return newList;
  }
  public void swap(int i,int j) {
    E tmp=store[i];
    store[i]=store[j];
    store[j]=tmp;
  }

  @Override
  public void sortBy(Comparator<? super E> cmp) {
    for (int i = 0; i < size; i++) {
      for (int j = 0; j < size; j++) {
        if((cmp.compare(store[j],store[j+1]))>0){
          swap(j,j+1);
        }
      }
    }
  }
}