#include "sequentie.h"

// Default constructor
Sequentie::Sequentie():
    data("") {
} // Sequentie::Sequentie

// Intialisatie constructor Sequentie
Sequentie::Sequentie(Sequentie const &sequentie):
    data(sequentie.data) {
} // Sequentie::Sequentie

// Intialisatie constructor string
Sequentie::Sequentie(std::string const &sequentie):
    data(sequentie) {
} // Sequentie::Sequentie

// Geeft de lengte van de Sequentieuentie in symbolen
int Sequentie::length() const {
    return data.size();
} // Sequentie::length

// Geeft char terug op positie post
char Sequentie::char_at(int const pos) const {
    return data[pos];
} // Sequentie::char_at

// Concateneert Sequentie met andere Sequentie
Sequentie Sequentie::concat(Sequentie const &other) const {
    return Sequentie(data + other.data);
} // Sequentie::concat

// Geeft een nieuwe Sequentieuentie met de symbolen [start, end)
Sequentie Sequentie::slice(int const start, int const eind) const {
    if(start > eind || start < 0 || eind > length()) {
        std::cerr << "Start en eind zitten niet binnen de grenzen van de sequentie." << std::endl;
        return Sequentie();
    } 
    return Sequentie(data.substr(start, eind - start));
} // Sequentie::slice

// Checkt of twee Sequentieuenties hetzelfde zijn en
// retourneert true als dat zo is, anders false
bool Sequentie::equal(Sequentie const &sequentie) const {
    if(data.compare(sequentie.data) == 0) {
        return true;
    }
    return false;
} // Sequentie::equal

// Voert de varianten in de meegegeven vector uit op de sequentie 
// en retourneerd het resultaat. Alleen voor de variant inversie moeten
// er aparte dingen gebeuren, de rest kan allemaal in eenzelfde 'algoritme'
Sequentie Sequentie::apply(std::vector<Variant const*> varianten) const {
    int vectorSize = varianten.size(); 
    Sequentie product(data); // Steeds het product na toepassing van een variant
    
    for(int k = 0; k < vectorSize; k++) {
        Variant const* var = varianten.at(k); // Hulppointer naar variant
        if(var->get_eind() > product.length()) {
            std::cerr << "Deze variant komt buiten de grenzen van de sequentie." << std::endl;
            return Sequentie();
        } // Checkt de grenzen van de variant
        Sequentie const prefix = product.slice(0, var->get_start());
        Sequentie const insert(var->get_inserted()); 
        Sequentie const suffix = product.slice(var->get_eind(), product.length()); 
        Sequentie temp = prefix.concat(insert); // prefix + insert
        if(var->get_type() == "inv") {
            Sequentie const inside = product.slice(var->get_start(), var->get_eind());
            std::string seq; // Hierin komt de reverse complement van inside
            for(int i = inside.length(); i >= 0; i--) {
                char symbol = inside.char_at(i);
                if(symbol == 'A') {
                    seq += 'T';
                }
                else if(symbol == 'T') {
                    seq += 'A';
                }
                else if(symbol == 'C') {
                    seq += 'G';
                }
                else if(symbol == 'G') {
                    seq += 'C';
                }
            } // Voegt per symbol van inside, van achter naar voren, het complement in seq
            temp = prefix.concat(Sequentie(seq)); // prefix + seq
        } // Inversie
        product = temp.concat(suffix); // temp + suffix
        delete var;
    } // Voert steeds de variant uit op de sequentie in product
    varianten.clear();
    return product;
} // Sequentie::apply

// Drukt de sequentie af
void Sequentie::drukAf() const {
    std::cout << data << std::endl;
} // Sequentie::drukAf