#include "../include/sequentie.h"
#include "../include/variant.h"
#include "../include/deletie.h"
#include "../include/insertie.h"
#include "../include/inversie.h"
#include "../include/delinsertie.h"
#include "../include/substitutie.h"
#include "../include/seqpointer.h"
#include "../include/seqarray.h"

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <cstdint>
#include <stdio.h>

// Menu voor het type waarin de sequentie komt
std::string menuType() {
    std::string keuze = std::string();
    std::cout << "Welke sequentie type wilt u kiezen? " << std::endl
            << "- typ 'string' voor type string" << std::endl
            << "- typ 'array' voor type array" << std::endl
            << "- typ 'pointer' voor type pointerlijst" << std::endl;
    std::cin >> keuze;
    std::cout << std::endl;

    if(keuze != "string" && keuze != "array" && keuze != "pointer") {
        std::cerr << "U heeft geen goed type ingevuld." << std::endl << std::endl;
        return std::string();
    } // Geen geldige type

    return keuze;
} // menuType

// Menu voor het type integer, geldt alleen bij de array en pointerlijst
int menuTypeInteger() {
    int keuze;
    std::cout << "Welke type integer wilt u kiezen?" << std::endl
            << "- typ '8' voor 8-bit integer" << std::endl
            << "- typ '16' voor 16-bit integer" << std::endl
            << "- typ '32' voor 32-bit integer" << std::endl
            << "- typ '32' voor 64-bit integer" << std::endl;
    std::cin >> keuze;
    std::cout << std::endl;

    if(keuze != 8 && keuze != 16 && keuze != 32 && keuze != 64) {
        return 0;
    } // Geen geldige keuze

    return keuze;
} // menuTypeInteger

// Leest een sequentie in uit een file en retourneerd deze
std::string inlezenSequentie(std::string const input) {
    std::string sequentie; // de sequentie
    std::ifstream invoer;
    invoer.open(input, std::ifstream::in);

    std::cout << std::endl;
    if(invoer.fail()) {
        std::cerr << "Kon file niet openen/vinden." << std::endl << std::endl;
        return std::string();
    } // Er is iets mis gegaan

    while(!invoer.eof()) {
        std::string temp;
        invoer >> temp;
        sequentie += temp;
    } // Voor als er endlines in de file zitten

    invoer.close();
    if(sequentie == std::string()) {
        std::cerr << "De file is leeg." << std::endl << std::endl;
    } // Lege file

    return sequentie;
} // inlezenSequentie

// Leest de varianten in uit een file en retourneerd deze in een vector
std::vector<Variant const*> inlezenVarianten() {
    std::vector<Variant const*> varianten; // de varianten
    std::string input = std::string(); // filenaam

    std::cout << "Wat is de naam van de file met de varianten? " << std::endl;
    std::cin >> input;
    std::cout << std::endl;
    std::ifstream invoer;
    invoer.open(input, std::ifstream::in);

    if(invoer.fail()) {
        std::cerr << "Kon file niet openen/vinden." << std::endl << std::endl;
        return varianten;
    } // Er is iets mis gegaan

    while(!invoer.eof()) {
        int begin = int(); // begin
        int eind = int(); // eind
        std::string variantType = std::string(); //variant-type
        std::string insert = std::string(); // insert-sequentie
        invoer >> begin;
        invoer >> eind;
        invoer >> variantType;
        if(variantType == ">" || variantType == "ins" || variantType == "delins") {
            invoer >> insert;
        } // Bij deze varianten hoort een insert-sequentie
        Variant const* var = var->read(begin, eind, variantType, insert); // Maakt de variant

        if(var == nullptr) {
            invoer.close();
            varianten.clear();
            return varianten;
        } // De variant is niet geldig
        varianten.push_back(var);
    } // Voor als er endlines in de file zitten

    invoer.close();
    if(varianten.empty()) {
        std::cerr << "De file is leeg." << std::endl << std::endl;
    } // Lege file

    return varianten;
} // inlezenVarianten

// Schrijft de sequentie weg naar een file
void wegschrijven(std::string sequentie) {
    std::ofstream uitvoer;
    std::string input = std::string(); // filenaam

    std:: cout << "Wat is de naam van de file waarin de sequentie moet worden weggeschreven? " << std::endl;
    std::cin >> input;
    std::cout << std::endl;
    uitvoer.open(input, std::ofstream::out);

    if(uitvoer.fail()) {
        std::cerr << "Kon file niet openen/vinden." << std::endl << std::endl;
        uitvoer.close();
        return;
    } // Er is iets mis gegaan

    uitvoer << sequentie;

    uitvoer.close();
} // wegschrijven

// Menu voor de opties die de gebruiker kan doen met de sequentie
int menuKeuzes() {
    int keuze = 0;
    while(keuze < 1 || keuze > 5) {
        std::string input;
        std:: cout << "Wat wilt u doen? (typ het cijfer)" << std::endl
                << "1) Een file met varianten op de huidige sequentie uitvoeren" << std::endl
                << "2) Een nieuwe type sequentie uit een file inlezen" << std::endl
                << "3) De huidige sequentie wegschrijven naar een file" << std::endl
                << "4) De huidige sequentie afdrukken op het scherm" << std::endl
                << "5) Stoppen met het programma" << std::endl;
        std::cin >> input;
        if(input.length() == 1) {
            keuze = input[0] - '0';
        }
        std::cout << std::endl;
    }
    return keuze;
} // menuKeuzes

// Menu voor type string
int menuString(Sequentie seq) {
    int stoppen = 0;
    while(stoppen == 0) {
        int menuKeuze = menuKeuzes();
        switch(menuKeuze) {
            case 5: {
                stoppen = 1;
            }
            break; // stoppen met het programma
            case 4: {
                seq.drukAf();
                std::cout << std::endl;
            }
            break; // sequentie afdrukken op scherm
            case 3: {
                std::ofstream uitvoer;
                std::string input = std::string(); // filenaam

                std:: cout << "Wat is de naam van de file waarin de sequentie moet worden weggeschreven? " << std::endl;
                std::cin >> input;
                std::cout << std::endl;
                uitvoer.open(input, std::ofstream::out);

                if(uitvoer.fail()) {
                    std::cerr << "Kon file niet openen/vinden." << std::endl << std::endl;
                    uitvoer.close();
                } // Er is iets mis gegaan
                std::streambuf *coutbuf = std::cout.rdbuf();
                std::cout.rdbuf(uitvoer.rdbuf()); // redirect cout naar de file

                seq.drukAf();

                std::cout.rdbuf(coutbuf); // reset naar cout

                uitvoer.close();
            }
            break; // sequentie wegschrijven naar file
            case 2: {
                stoppen = 2;
            }
            break; // stoppen met het menu
            case 1: {
                std::vector<Variant const*> varianten = inlezenVarianten();
                if(!varianten.empty()) {
                    seq = seq.apply(varianten);
                }
            }
            break; // varianten toepassen op sequentie
        }
    }
    return stoppen;
} // menuString

// Menu voor type array
template <typename T>
int menuArray(SeqArray<T> seq) {
    int stoppen = 0;
    while(stoppen == 0) {
        int menuKeuze = menuKeuzes();
        switch(menuKeuze) {
            case 5: 
                stoppen = 1;
            break; // stoppen met het programma
            case 4: 
                seq.drukAf();
                std::cout << std::endl;
            break; // sequentie afdrukken op scherm
            case 3: {
                std::ofstream uitvoer;
                std::string input = std::string(); // filenaam

                std:: cout << "Wat is de naam van de file waarin de sequentie moet worden weggeschreven? " << std::endl;
                std::cin >> input;
                std::cout << std::endl;
                uitvoer.open(input, std::ofstream::out);

                if(uitvoer.fail()) {
                    std::cerr << "Kon file niet openen/vinden." << std::endl << std::endl;
                    uitvoer.close();
                } // Er is iets mis gegaan
                std::streambuf *coutbuf = std::cout.rdbuf();
                std::cout.rdbuf(uitvoer.rdbuf()); // redirect cout naar de file

                seq.drukAf();

                std::cout.rdbuf(coutbuf); // reset naar cout

                uitvoer.close();
            }
            break; // sequentie wegschrijven naar file
            case 2: 
                stoppen = 2;
                break; // stoppen met het menu
            case 1: {
                std::vector<Variant const*> varianten = inlezenVarianten();
                if(!varianten.empty()) {
                    seq.copy(seq.apply(varianten));
                }
            }
            break; // varianten toe passen op sequentie
        }
    }
    return stoppen;
} // menuArray

// Menu voor type pointerlijst
template <typename T>
int menuPointer(SeqPointer<T> seq) {
    int stoppen = 0;
    while(stoppen == 0) {
        int menuKeuze = menuKeuzes();
        switch(menuKeuze) {
            case 5: 
                stoppen = 1;
            break; // stoppen met het programma
            case 4: 
                seq.drukAf();
                std::cout << std::endl;
            break; // sequentie afdrukken op scherm
            case 3: {
                std::ofstream uitvoer;
                std::string input = std::string(); // filenaam

                std:: cout << "Wat is de naam van de file waarin de sequentie moet worden weggeschreven? " << std::endl;
                std::cin >> input;
                std::cout << std::endl;
                uitvoer.open(input, std::ofstream::out);

                if(uitvoer.fail()) {
                    std::cerr << "Kon file niet openen/vinden." << std::endl << std::endl;
                    uitvoer.close();
                } // Er is iets mis gegaan
                std::streambuf *coutbuf = std::cout.rdbuf();
                std::cout.rdbuf(uitvoer.rdbuf()); // redirect cout naar de file

                seq.drukAf();

                std::cout.rdbuf(coutbuf); // reset naar cout

                uitvoer.close();
            }
            break; // sequentie wegschrijven naar file
            case 2: 
                stoppen = 2;
            break; // stoppen met het menu
            case 1: {
                std::vector<Variant const*> varianten = inlezenVarianten();
                if(!varianten.empty()) {
                    seq.copy2(seq.apply(varianten));
                }
            }
            break; // varianten toe passen op sequentie
        }
    }
    return stoppen;
} // menuPointer

// Algemene menu voor type sequentie, type integer, 
// inlezen sequentie en de menu's voor de types
void menu() {
    int keuze = 0;
    while(keuze != 1) {
        std::string type = std::string(); // type
        std::string input = std::string(); // filenaam voor sequentie
        std::string sequentie = std::string(); // de ingelezen sequentie
        int typeInteger = 0; // grootte/type integer

        while(type == std::string()) {
            type = menuType();
        } // type sequentie

        if(type == "array" || type == "pointer") {
            while(typeInteger == 0) {
                typeInteger = menuTypeInteger();
            }
        } // type integer, voor de types array en pointer

        while(sequentie == std::string()) {
            std:: cout << "Wat is de naam van de file met de sequentie? " << std::endl;
            std::cin >> input;
            sequentie = inlezenSequentie(input);
        } // de sequentie inlezen

        if(type == "string") {
            keuze = menuString(Sequentie(sequentie));
        } // string
        else if(type == "array") {
            switch(typeInteger) {
                case 64:
                    keuze = menuArray<uint64_t>(SeqArray<uint64_t>(sequentie));
                    break;
                case 32: 
                    keuze = menuArray<uint32_t>(SeqArray<uint32_t>(sequentie));
                    break;
                case 16:
                    keuze = menuArray<uint16_t>(SeqArray<uint16_t>(sequentie));
                    break;
                case 8:
                default:
                    keuze = menuArray<uint8_t>(SeqArray<uint8_t>(sequentie));
                    break;
            }
        } // array
        else {
            switch(typeInteger) {
                case 64:
                    keuze = menuPointer<uint64_t>(SeqPointer<uint64_t>(sequentie));
                    break;
                case 32: 
                    keuze = menuPointer<uint32_t>(SeqPointer<uint32_t>(sequentie));
                    break;
                case 16:
                    keuze = menuPointer<uint16_t>(SeqPointer<uint16_t>(sequentie));
                    break;
                case 8:
                default:
                    keuze = menuPointer<uint8_t>(SeqPointer<uint8_t>(sequentie));
                    break;
            }
        } // pointerlijst
    }
} // menu

int main() {
    menu();
}