#include "variant.h"
#include "deletie.h"
#include "insertie.h"
#include "inversie.h"
#include "delinsertie.h"
#include "substitutie.h"

#include <iostream>

// Default constructor
Variant::Variant(int const start, int const eind):start(start), eind(eind) {
    std::cerr << "Variant::Variant" << std::endl;
} // Variant::Variant

// Copy constructor voor variant
Variant::Variant(Variant const &var): Variant(var.start, var.eind) {
    std::cerr << "Variant::Variant" << std::endl;
} // Variant::Variant

// Destructor
Variant::~Variant() {
    std::cerr << "Variant::~Variant" << std::endl;
} // Variant::~Variant()

// Maakt de variant van de waardes en geeft een pointer ernaar terug
Variant* Variant::read(int const start, int const eind, std::string const type, std::string const seq) {
    std::cout << "start: " << start << std::endl;
    std::cout << "eind: " << eind << std::endl;
    std::cout << "type: " << type << std::endl;
    std::cout << "seq: " << seq << std::endl;
    if((type != ">" && start > eind) || start < 0 || eind < 0) {
        std::cerr << "De ingevoerde start en/of eind zijn onmogelijke grenzen" << std::endl;
        return nullptr;
    } // Checkt de grenzen van [start, eind]

    if(type == "del") {
        return new Deletie(start, eind);
    } // Deletie

    if(type == "inv") {
        return new Inversie(start, eind);
    } // Inversie

    if(type == "ins") {
        if(start != eind) {
            std::cerr << "Start en eind moeten hetzelfde zijn voor een insertie" << std::endl;
            return nullptr;
        } // Als start != eind, dan is het een deletie-insertie en geen insertie
        return new Insertie(start, eind, seq);
    } // Insertie

    if(type == ">") {
        if(seq.length() != 1) {
            std::cerr << "De gegeven sequentie is te groot om een substitutie mee te doen" << std::endl;
            return nullptr;
        } // Een substitutie bestaat maar uit één symbool
       return new Substitutie(start, eind, seq);
    } // Substitutie

    if(type == "delins") {
        return new DelInsertie(start, eind, seq);
    } // Deletie-Insertie

    std::cerr << "Ingevoerde type variant is onbekend" << std::endl;
    return nullptr; // Geen goede type ingevuld
} // Variant::read

// Leest de waardes in voor een variant: start, eind, type [, seq]
// en geeft een pointer terug naar de variant
Variant* Variant::read() {
    int start = 0; 
    int eind = 0;
    std::string type = "";

    std::cin >> start >> eind >> type;
    if(start > eind || start < 0 || eind < 0) {
        std::cerr << "De ingevoerde start en/of eind zijn onmogelijke grenzen" << std::endl;
        return nullptr;
    } // Checkt de grenzen van [start, eind]

    if(type == "del") {
        return new Deletie(start, eind);
    } // Deletie

    if(type == "inv") {
        return new Inversie(start, eind);
    } // Inversie

    std::string seq = "";
    std::cin >> seq; // De volgende types hebben een sequentie input

    if(type == "ins") {
        if(start != eind) {
            std::cerr << "Start en eind moeten hetzelfde zijn voor een insertie" << std::endl;
            return nullptr;
        } // Als start != eind, dan is het een deletie-insertie en geen insertie
        return new Insertie(start, eind, seq);
    } // Insertie

    if(type == ">") {
        if(seq.length() != 1) {
            std::cerr << "De gegeven sequentie is te groot om een substitutie mee te doen" << std::endl;
            return nullptr;
        } // Een substitutie bestaat maar uit één symbool
        if(start != eind - 1) {
            std::cerr << "De gegeven grenzen kloppen niet voor substitutie" << std::endl;
            return nullptr;
        } // Eind moet Start + 1 zijn
       return new Substitutie(start, eind, seq);
    } // Substitutie

    if(type == "delins") {
        return new DelInsertie(start, eind, seq);
    } // Deletie-Insertie

    std::cerr << "Ingevoerde type variant is onbekend" << std::endl;
    return nullptr; // Geen goede type ingevuld
} // Variant::read

// Getter voor start
int Variant::get_start() const {
    return start;
} // Variant::get_start

// Getter voor eind
int Variant::get_eind() const {
    return eind;
} // Variant::get_eind

// Virtual getter voor inserted/seq
std::string Variant::get_inserted() const {
    return std::string(); //geeft een lege string terug
} // Variant::get_inserted

// Virtual getter voor het type variant
std::string Variant::get_type() const {
    return std::string(); //geeft een lege string terug
} // Variant::get_type

// Schrijft de waardes van de variant weg
void Variant::write() const{
    std::cout << get_start() << " " << get_eind() << " "
              << get_type();
    if(get_inserted() != "") {
        std::cout << " " << get_inserted();
    }
    std::cout << std::endl;
} // Variant::write