rute.cpp

#include "rute.h"

using namespace std;

extern Stoppesteder* gStoppesteder;

Rute::Rute() {
}

Rute::~Rute() {
}
Stopp* Rute::ny(const int& eksisterende, int pos) {
    string stoppPlass = "";
    Stoppested *stoppested, *forrigeStoppested;
    Stopp *stopp, *forrigeStopp;
    stoppested = nullptr;
    stopp = nullptr;
    bool forsteStopp = true;

    do {
        forrigeStoppested = stoppested;
        forrigeStopp = stopp;
        if (eksisterende != -1) {
            forrigeStoppested = gStoppesteder->hentEksisterende(eksisterende);
            forrigeStopp = new Stopp;
            forrigeStopp->indexStoppested = eksisterende;
        }
        stopp = new Stopp;
        stoppested = nullptr;
        if (alleStoppestedenePaaRuten.size() > 0) forsteStopp = false;
        cout << "\nSkriv inn navn eller nummer på stoppeplass du ønsker "
             << "å legge til (blankt for avbryt):";
        getline(cin, stoppPlass);

        // Strengen ikke er tom
        if (!stoppPlass.empty()) {
            stoppPlass = hjelp.rensStreng(stoppPlass);
            if (!hjelp.erBokstav(stoppPlass)) {
                // Hvis tall
                stoppested = gStoppesteder->hentEksisterende(stoi(stoppPlass) - 1);
            } else
                // Else bokstav(r)
                stoppested = gStoppesteder->hentEksisterende(stoppPlass);

            // Hvis stoppestedet ikke eksisterer fra før og input er bokstaver
            if (stoppested == nullptr && hjelp.erBokstav(stoppPlass)) {
                cout << "\nError: Stoppested eksisterer ikke!" << '\n'
                     << "Oppretter nytt stoppsted basert på forrige gitte parameter."
                     << '\n';
                if (forsteStopp)
                    gStoppesteder->ny(stoppPlass, false);
                else
                    gStoppesteder->ny(stoppPlass, true);
                stoppested = gStoppesteder->hentEksisterende(stoppPlass);
            }
            stopp->indexStoppested = gStoppesteder->hentIndex(stoppested);

            // Er ikke første stopp og har ikke nabostopp
            if (!forsteStopp && stoppested->hentTidNaboStopp() < 0) {
                stopp->minutterFraForrigeStoppested = lesTid();
            } else if (forsteStopp)
                stopp->minutterFraForrigeStoppested = 0;
            else {
                stopp->minutterFraForrigeStoppested = -1;  // stoppested->hentTidNaboStopp();
            }
            if (!sjekkOmStoppEksisterer(stopp)) {
                oppdaterStoppestedVectorer(stoppested,
                                           forrigeStoppested,
                                           stopp,
                                           forrigeStopp);
                if (eksisterende != -1 && pos == alleStoppestedenePaaRuten.size()) {
                    alleStoppestedenePaaRuten.push_back(stopp);
                } else if (eksisterende != -1) {
                    auto it = alleStoppestedenePaaRuten.begin();
                    advance(it, pos);

                    Stopp* tmpstopp = *it;
                    int tmpTid = tmpstopp->minutterFraForrigeStoppested;
                    tmpstopp->minutterFraForrigeStoppested = stopp->minutterFraForrigeStoppested;
                    stopp->minutterFraForrigeStoppested = tmpTid;
                    // slettStoppested(pos, pos);

                    alleStoppestedenePaaRuten.insert(it, stopp);

                    pos++;

                } else
                    alleStoppestedenePaaRuten.push_back(stopp);
                cout << "\nStopp lagt til!" << '\n';
                // return stopp;
            } else
                cout << "\nError: Stopp er allerede lagt til!" << '\n';
        }
    } while (!stoppPlass.empty());

    // Hvis ikke nok stopp er lagt inn på ruten
    if (alleStoppestedenePaaRuten.size() <= 1 && eksisterende != -1) {
        cout << "\nIkke nok stopp lagt inn! Avbryter" << '\n';
        return nullptr;
    }
    return stopp;
}

void Rute::ryddOppMinne() {
    for (const auto& val : alleStoppestedenePaaRuten) {
        delete val;
    }
    alleStoppestedenePaaRuten.clear();
}
bool Rute::sjekkOmStoppEksisterer(Stopp* stopp) {
    for (const auto& val : alleStoppestedenePaaRuten) {
        if (val->indexStoppested == stopp->indexStoppested) return true;
    }
    return false;
}

void Rute::skrivData() {
    skrivDataForlengs();
    skrivDataBaklengs();
}

void Rute::skrivDataForlengs() {
    Stoppested* stopp;
    int totalTid, storrelseListe;
    totalTid = 0;
    storrelseListe = alleStoppestedenePaaRuten.size();
    cout << "\n\n..::Stoppested navn\tTid mellom stopp"
         << "\tTotal tid fra rutestart::..";
    for (const auto& val : alleStoppestedenePaaRuten) {
        if (val->minutterFraForrigeStoppested != 0)
            totalTid += val->minutterFraForrigeStoppested;
        stopp = gStoppesteder->hentEksisterende(val->indexStoppested);
        if (stopp != nullptr) {
            cout << "\n\t"
                 << stopp->hentNavn()
                 << "\t" << val->minutterFraForrigeStoppested
                 << "\t" << totalTid;
        }
    }
}

void Rute::skrivDataBaklengs() {
    Stoppested* stoppested;
    Stopp *stopp, *forrigeStopp;
    int totalTid, storrelseListe;
    bool forste = true;

    totalTid = 0;
    cout << "\n\n..::Stoppested navn\tTid mellom stopp"
         << "\tTotal tid fra rutestart::..";

    for (auto it = alleStoppestedenePaaRuten.rbegin();
         it != alleStoppestedenePaaRuten.rend(); it++) {
        stopp = *it;
        stoppested = gStoppesteder->hentEksisterende(stopp->indexStoppested);
        if (!forste) {
            totalTid += forrigeStopp->minutterFraForrigeStoppested;
            cout << "\n\t"
                 << stoppested->hentNavn()
                 << "\t" << forrigeStopp->minutterFraForrigeStoppested
                 << "\t" << totalTid;
        } else {
            cout << "\n\t"
                 << stoppested->hentNavn()
                 << "\t" << 0
                 << "\t" << 0;
            forste = false;
        }
        forrigeStopp = *it;
    }
}

void Rute::endre() {
    int valg, antall;
    cout << "\n\n1 - Slett stoppested\n2 - Smett inn stoppested\n0 - Avbryt" << '\n';
    valg = lesInt("Kommando", 0, 2);
    antall = alleStoppestedenePaaRuten.size();
    if (valg > 0) {
        int start, slutt;
        start = slutt = 0;
        start = lesInt("Hvilke stoppested utgjør start punktet?",
                       1, antall);
        // if (start + 1 >= alleStoppestedenePaaRuten.size())
        if (valg == 1 && antall > 2 && start < antall) {
            slutt = lesInt("Hvilket stoppested utgjør slutt ytterpunkt?",
                           start + 2, antall);
            slettStoppested(start, slutt);
        } else if (valg == 2)
            slutt = lesInt("Hvilket stoppested utgjør slutt ytterpunkt?",
                           start, antall);
        else
            cout << "\nError i sletting: ugyldig input!" << '\n';

        if (valg == 2 && slutt - 1 == start || valg == 2 && slutt == start)
            smettInnStoppested(start, slutt);

        /*else if (valg == 1 && start == slutt - 1 || slutt == 0)
            cout << "\nError i sletting: ugyldig input!" << '\n';*/
        else if (valg == 2)
            cout << "\nError: For smett inn så må slutt være rett etter start "
                 << "for at innsmettingen skal være entydig!\n";  //" << '\n'
    }
}

void Rute::slettStoppested(const int& start, const int& slutt) {
    Stopp* stopp;
    cout << "\nlist size: " << alleStoppestedenePaaRuten.size() << "\n\n";
    auto it = alleStoppestedenePaaRuten.begin();
    advance(it, start);
    for (int i = start; i < slutt - 1; i++) {
        stopp = *it;
        delete stopp;
        it = alleStoppestedenePaaRuten.erase(it);
    }
    skrivData();
}

void Rute::smettInnStoppested(const int& start, const int& slutt) {
    Stopp* stopp;
    list<Stopp*>::iterator it = alleStoppestedenePaaRuten.begin();
    advance(it, start - 1);
    stopp = *it;
    if (slutt == start && start < alleStoppestedenePaaRuten.size())
        ny(stopp->indexStoppested, start - 1);
    else
        ny(stopp->indexStoppested, start);
}

void Rute::leggTilStoppestedIRute(Stopp* stopp) {
    if (stopp != nullptr)
        alleStoppestedenePaaRuten.push_back(stopp);
}

void Rute::skrivType() {
}

void Rute::oppdaterStoppestedVectorer(Stoppested* stoppested,
                                      Stoppested* forrigeStoppested,
                                      Stopp* stopp,
                                      Stopp* forrigeStopp) {
    int tmpTid2, tmpTid;
    tmpTid2 = tmpTid = -1;
    int antIVec = stoppested->hentAntallStoppestedVector();
    Stoppested* tmpstd = stoppested;
    // gStoppesteder->hentEksisterende(stoppested->hentNaboStoppIndex(true));
    //  Stoppested* tmpstd2 = gStoppesteder->hentEksisterende(stoppested->hentNaboStoppIndex(true));
    if (stoppested != nullptr) {
        tmpTid = stoppested->hentTidNaboStopp();
        // tmpTid2 = tmpstd2->hentTidNaboStopp();
    }

    if (forrigeStoppested != nullptr) {
        if (stopp->minutterFraForrigeStoppested == -1) {
            /*     for (const auto& val : gStoppesteder->alleStoppesteder) {
                     if (val->hentNaboStoppIndex(true) == stopp->indexStoppested) {
                         forrigeStoppested->leggTilNaboBakerst(stopp->indexStoppested,
                                                               val->hentTidNaboStopp());
                         cout << val->hentTidNaboStopp() << "\n\n";
                         //break;
                     }
                 }*/
            tmpTid2 = stoppested->hentTidForsteNabo();
            if (tmpTid2 == -1) tmpTid2 = stoppested->hentTidNaboStopp();
            // Legger nåværende stopp til i forrige stoppested
            forrigeStoppested->leggTilNaboBakerst(stopp->indexStoppested,
                                                  tmpTid2);
            cout << "\n\n||" << tmpTid2 << " : "
                 << stopp->indexStoppested << "\n\n";

        } else
            forrigeStoppested->leggTilNaboBakerst(stopp->indexStoppested,
                                                  stopp->minutterFraForrigeStoppested);

        if (stoppested->hentIndex() != forrigeStopp->indexStoppested) {
            if (stopp->minutterFraForrigeStoppested == -1) {
                // Legger til nåværende stopp til stoppested
                stoppested->leggTilNaboFremst(forrigeStopp->indexStoppested,
                                              tmpTid2);
                cout << "\n\n--" << tmpTid2
                     << " : " << forrigeStopp->indexStoppested << "\n\n";
            } else
                stoppested->leggTilNaboFremst(forrigeStopp->indexStoppested,
                                              stopp->minutterFraForrigeStoppested);

            /*if (forrigeStopp->minutterFraForrigeStoppested > 0)
                stoppested->leggTilNaboFremst(forrigeStopp->indexStoppested,
                                              forrigeStopp->minutterFraForrigeStoppested);
            else
                stoppested->leggTilNaboFremst(forrigeStopp->indexStoppested,
                                              stopp->minutterFraForrigeStoppested);*/
        }
    } else if (antIVec < 1) {
        stoppested->leggTilNaboStopp(-1, -1);
    }
    // Gir stopp nabo-tid slik at rute beskrivelse fungerer korrekt
    if (stopp->minutterFraForrigeStoppested == -1)
        stopp->minutterFraForrigeStoppested = stoppested->hentTidNaboStopp();

    // stopp->minutterFraForrigeStoppested = tmpTid;
}

int Rute::lesTid() {
    return lesInt("Tid mellom forrige stopp i minutter",
                  MIN_MINUTTER,
                  MAX_MINUTTER);
}

void Rute::tabell() {
    Retning retning = Annen;
    Stoppested* stoppested;
    string stopp, stopp2, navn;
    char valg = '\0';
    bool ikkeFullt, igjen;
    ikkeFullt = igjen = true;
    vector<vector<int>> valgtTid;
    int avgangsTid, fraKlTime, fraKlMin, tilKlTime, tilKlMin,
        tmpTime, tmpMin, forrigeTmpMin, totTid, utregning;

    tmpTime = tmpMin = forrigeTmpMin = totTid = utregning = fraKlTime = 0;
    tilKlMin = MIN_MINUTTER;
    tilKlTime = MIN_TIMER;
    stopp = gStoppesteder->hentEksisterende(
                             alleStoppestedenePaaRuten.front()->indexStoppested)
                ->hentNavn();
    stopp2 = gStoppesteder->hentEksisterende(
                              alleStoppestedenePaaRuten.back()->indexStoppested)
                 ->hentNavn();
    cout << "\nFram: Retningen: "
         << stopp
         << " - "
         << stopp2
         << "\nTilbake: Retningen: "
         << stopp2
         << " - "
         << stopp
         << '\n'
         << "\nVelg retning F = Fram, T = Tilbake"
         << '\n';

    while (valg != 'F' && valg != 'T') {
        valg = lesChar("Kommando: ");
        if (valg == 'F')
            retning = Fram;
        else if (valg == 'T')
            retning = Tilbake;

        switch (retning) {
            case Fram:
                skrivDataForlengs();
                break;
            case Tilbake:
                skrivDataBaklengs();
                break;
            default:
                cout << "\nUgyldig valg!" << '\n';
                break;
        }
    }
    cout << "\n\nSkriv inn navnet på stoppet: ";
    getline(cin, navn);
    navn = hjelp.rensStreng(navn);
    stoppested = gStoppesteder->hentEksisterende(navn);
    if (stoppested != nullptr) {
        cout << "\nTime= 0 og Minutt= 0 for å AVSLUTTE innlesning" << '\n';
        do {
            igjen = true;
            do {
                cout << "\nFra kl. (";
                hjelp.skrivKlokkeslett(tilKlTime, tilKlMin);
                cout << " - ";
                hjelp.skrivKlokkeslett(MAX_TIMER, MAX_MINUTTER);
                cout << "): "
                     << "\nTime: ";
                fraKlTime = hjelp.lesTall();
                cout << "\nMinutt: ";
                fraKlMin = hjelp.lesTall();
                if (fraKlTime < MAX_TIMER &&
                    fraKlTime > tilKlTime &&
                    fraKlMin < MAX_MINUTTER &&
                    fraKlMin >= 0)
                    igjen = false;
                if (fraKlTime <= 0 && fraKlMin <= 0)
                    igjen = false;
            } while (igjen);

            // Hvis ikke avslutte
            if (fraKlTime > 0 || fraKlMin > 0) {
                avgangsTid = lesInt("Tid mellom avganger", MIN_AVGANGS_TID, MAX_AVGANGS_TID);

                tmpTime = fraKlTime + (avgangsTid / 60);
                tmpMin = fraKlMin + (avgangsTid % 60);
                if (tmpMin > MAX_MINUTTER) {
                    tmpTime++;
                    tmpMin = tmpMin % 60;
                }

                // Hvis tid gitt går over max verdi i.e. 24t
                if (tmpTime > MAX_TIMER)
                    ikkeFullt = false;

                do {
                    cout << "\nTil kl. (";
                    hjelp.skrivKlokkeslett(tmpTime, tmpMin);
                    cout << " - ";
                    hjelp.skrivKlokkeslett(MAX_TIMER, MAX_MINUTTER);
                    cout << "): "
                         << "\nTime: ";
                    tilKlTime = hjelp.lesTall();
                    cout << "\nMinutt: ";
                    tilKlMin = hjelp.lesTall();
                } while (tilKlTime > MAX_TIMER ||
                         tilKlTime < tmpTime ||
                         tilKlMin > MAX_MINUTTER || tilKlMin < 0);

                /*if (fraKlTime == 0 && fraKlMin == 0 ||
                    tilKlTime == 0 && tilKlMin == 0)
                    cout << "\nAvbryter" << '\n';*/

                // Legger til tider i vector
                if (ikkeFullt) {
                    valgtTid.push_back({fraKlTime, tmpTime, tmpMin, avgangsTid,
                                        tilKlTime, tilKlMin});
                }
            } else {
                fraKlTime = fraKlMin = tilKlTime = tilKlMin = 0;
                //cout << "\nAvbryter" << '\n';
            }

        } while (fraKlTime > 0 || fraKlMin > 0 || tilKlTime > 0 || tilKlMin > 0);  // fraKlTime != 0 || fraKlMin != 0 && tilKlTime != 0 || tilKlMin != 0 && ikkeFullt);

        if (retning == Fram)
            totTid = hentTotalTidForan(gStoppesteder->hentIndex(stoppested));
        else
            totTid = hentTotalTidTilbake(gStoppesteder->hentIndex(stoppested));

        // Har tid har blitt lagt til i vector
        if (valgtTid.size() > 0) {
            cout << "\n\t..::Rutetabell for stoppestedet: " << navn
                 << "::.."
                 << "\n\n";
            // Klokkeslett
            for (int i = valgtTid.front()[0];
                 i <= valgtTid.back()[4]; i++) {
                if (i <= 9)
                    cout << "\t\t0" << i;
                else
                    cout << "\t\t" << i;
                cout << ":";
                // Tabell for stopp på 'i' klokkeslett
                for (const auto& val : valgtTid) {
                    if (i >= val[0] && i <= val[4]) {
                        // cout << "inne i if!\n\n";
                        // int iEnTime = (60 / (totTid + val[2]));
                        int tall = totTid + val[2];
                        igjen = true;
                        while (igjen) {
                            if (tall < MAX_MINUTTER) {
                                cout << "\t" << tall;
                                tall += tall;
                            } else
                                igjen = false;
                        }
                        // else cout << "\t" << totTid + val[2];

                        /* utregning = (totTid + val[2]) / 60;
                         if (utregning < MAX_MINUTTER)

                             else if (i == val[4] - 1) {
                                 cout << "\t" << totTid + val[1];
                             }*/
                    }
                }
                cout << '\n';
            }
        }
    } else
        cout << "\nError: Fant ikke noe stoppested med det navnet!" << '\n';
}

int Rute::hentTotalTidForan(const int& pos) {
    int totalTid;
    totalTid = 0;
    for (const auto& val : alleStoppestedenePaaRuten) {
        if (val->minutterFraForrigeStoppested != 0)
            totalTid += val->minutterFraForrigeStoppested;
        if (val->indexStoppested == pos)
            return totalTid;
    }
    return -1;
}

int Rute::hentTotalTidTilbake(const int& pos) {
    Stopp *stopp, *forrigeStopp;
    int totalTid;
    bool forste = true;
    totalTid = 0;

    for (auto it = alleStoppestedenePaaRuten.rbegin();
         it != alleStoppestedenePaaRuten.rend(); it++) {
        stopp = *it;
        if (!forste) {
            totalTid += forrigeStopp->minutterFraForrigeStoppested;
            if (stopp->indexStoppested == pos) return totalTid;
        } else {
            forste = false;
        }
        forrigeStopp = *it;
    }
    return -1;
}
// int Ruter::finnTidTilNesteIRute()