//
//  DynArray.cpp
//  pad6
//
//  Created by Marvin Eifler on 16.01.20.
//

#include <stdio.h>
#include "DynArray.h"
#include <iostream>
#include <algorithm>

//Standardkonstruktor mit Kapazität von 4
DynArray::DynArray() {
    arr = new int[4];
    cap = 4;
    siz = 0;
}


//Konstruktor mit der Size als Parameter. Capacity wird durch die Size *2 ermittelt.
DynArray::DynArray(int size) {
    if (size < 0){
        throw std::invalid_argument("Size smaller than 1 is not allowed");
    }
    cap = size*2;
    siz = 0;
    arr = new int[cap];
}


//Copy Constructor
DynArray::DynArray(const DynArray& toCopy)
{
    //Altes arr löschen neu setzen und befüllen. Die Size wird von dem zu kopierendem übernommen
    //delete[] arr;
    this->siz = toCopy.siz;
    cap = toCopy.cap;
    arr = new int[cap];

    //Neues Arr mit den zu kopierenden Werten füllen
    for (int i = 0; i < siz; i++)
    {
        arr[i] = toCopy.arr[i];
    }
}

//Dekonstruktor löscht das Array
DynArray::~DynArray() {
    delete[] arr;
}

//Gibt den Wert am Index zurück
int& DynArray::at(int index) {
    if (index < 0){
        throw std::invalid_argument("Index cant be lower than 0");
    }
    if (index >= siz-1 ){
        throw std::invalid_argument("Index cant be lower than 0");
    }
    return arr[index];
}

//Gibt die Größe zurück
int  DynArray::size() {
    return siz;
}

//Gibt die Capacity zurück
int const DynArray::capacity() {
    return cap;
}

void DynArray::print() {
    for (int i = 0; i < siz; i++) {
        std::cout << arr[i] << ' ';
    }
    std::cout << std::endl;
}

void DynArray::push_back(int value){
    //Verdoppelt Kapazität wenn Size = Cap und erstellt neues temporäres Array.
    if (siz == cap){
        cap *= 2;
        int* tmp = new int[cap];
        //Werte in tmp Kopieren
        for (int i = 0; i < siz; i++){
            tmp[i] = arr[i];
        }
        //Arr löschen und den Zeiger auf tmp setzen
        delete[] arr;
        arr = tmp;
        arr[siz] = value;
        siz++;
    }
    //Fügt den Wert an wenn noch genug Capacity da ist
    else{
        arr[siz] = value;
        siz++;
    }
}

void DynArray::pop_back() {
    //Die größer um 1 verringern ist quasi als ob man das letzte Element löscht.
    if (siz < 1){
        throw std::runtime_error("Size can't be lower than 1");
    }
    siz--;
}

//Kopiert die Elemente die über Index liegen 1 nach vorne und setzt verringert siz um 1
void DynArray::erase(int index) {
    if (index < 0){
        throw std::invalid_argument("Index can't be lower than 0");
    }
    for (int i = index; i < siz; i++) {
        arr[i] = arr[i + 1];
    }
    siz--;
}

//Wendet f auf alle arr an für alle Elemente < siz
void DynArray::apply(std::function<void(int&)> f) {
    for (int i = 0; i < siz; i++) {
        f(arr[i]);
    }
}

//Erstellt ein temporäres arr und wendet f auf alle Elemente < siz des tmp Arrs an
DynArray DynArray::transform(std::function<int(int)> f){
    DynArray tmp(siz);
    for (int i = 0; i < siz; i++) {
        tmp.at(i) = f(arr[i]);
    }

    return tmp;

}

//Std::Sort auf das Arr
void DynArray::sort(){
    std::sort(arr, arr + siz);
}

//Std::Sort auf das Arr mit Comp Funktion
void DynArray::sort(std::function<bool(int, int)> comp){
    std::sort(arr, arr + siz, comp);
}



////Hfile

//
//  DynArray.h
//  pad6
//
//  Created by Marvin Eifler on 16.01.20.
//

#include <functional>
#ifndef DynArray_h
#define DynArray_h
class DynArray {
public:
    DynArray();
    DynArray(int size);
    DynArray(const DynArray &toCopy);
    ~DynArray();
    int& at(int index);
    int size();
    int const capacity();
    void print();
    void push_back(int value);
    void pop_back();
    void erase(int index);
    void apply(std::function<void(int&)> f);
    DynArray transform(std::function<int(int)> f);
    void sort();
    void sort(std::function<bool(int, int)> comp);

private:
    int cap;
    int siz;
    int* arr;
};

#endif /* DynArray_h */