/*
================================================================================
Datorer och programmering, DoP, 10 hsp, termin/år:ST18

Inlämningsuppgift nr 6a

Namn: Max Sonebäck

Personummer: 9302205472

Fyll i (alt stryk det som ej är relevant) av nedanstående:

Den fil som jag lämnar in går att kompilera och
programmet fungerar för alla de testdata som finns för uppgiften: Ja/Nej
     Om Nej, beskriv vilka testdata som ger problem:  __________________

Jag har använt kompilator/editor (namn/version) ___________________________

Jag har använt följande dator (PC/Mac/Annat): PC
      med operativsystemet: Windows

Jag har arbetat ungefär  16 timmar med denna uppgift
================================================================================
 */

#include <cstdlib>
#include <iostream>
#include <string>
#include <fstream>
#include <cctype>
#include <cmath>
#include <valarray>

using namespace std;

const int MAX_KOMPISAR = 20;
const int MAX_PERSONER = MAX_KOMPISAR;
const int MAX_TRANSAKTIONER = 100;

class Person {
private:
    string namn;
    double betalat_andras; // ligger ute med totalt
    double skyldig; // skyldig totalt

public:
    Person();
    Person(string n, double b, double s);
    double haemta_betalat();
    double haemta_skyldig();
    string haemta_namn();
    double raekna_differans(double a, double b);
    void skrivUt();
};

class PersonLista {
private:
    int antal_pers;
    Person pers[MAX_PERSONER];

public:
    PersonLista();
    ~PersonLista();
    void laggTillEn(Person pny);
    void skrivUtOchFixa();
    double summaSkyldig();
    double summaBetalat();
    bool finnsPerson(const string& namn);
};

class Transaktion {
private:
    string datum;
    string typ;
    string namn;
    double belopp;
    int ant_kompisar;
    string kompisar[MAX_KOMPISAR];

public:
    Transaktion();
    ~Transaktion();
    string haemta_namn();
    double haemta_belopp();
    int haemta_ant_kompisar();
    bool finnsKompis(string namnet);
    bool laesEnTrans(istream &is);
    void skrivEnTrans(ostream &os);
};

class TransaktionsLista {
private:
    Transaktion trans[MAX_TRANSAKTIONER];
    int antalTrans;

public:
    TransaktionsLista();
    ~TransaktionsLista();
    void laesin(istream &is);
    void skrivut(ostream &os);
    void laggTill(Transaktion &t);
    double totalkostnad();
    double liggerUteMed(string namnet);
    double aerSkyldig(string namnet);
    PersonLista FixaPersoner();
};


//string namn_pa_fil();
//ifstream oppnaIfstream(const string);
int meny();

int main() {
    int val;
    TransaktionsLista minLista;

    ifstream fin("resa_in.dat");
    ofstream fout("resa_in.dat", ios::app);
    minLista.laesin(fin);
    minLista.FixaPersoner();
    val = meny();

    while (val != 0){
    switch (val) {
        case 0:
            exit(EXIT_SUCCESS);
            break;

        case 1:
            minLista.laesin(cin);
            minLista.skrivut(fout);


            break;

        case 2:
            minLista.laesin(fin);
            minLista.skrivut(cout);

            break;

        case 3:

            cout << "Den totala kostnaden är: " << minLista.totalkostnad()<<endl;

            break;

        case 4:

            break;

        case 5:

            break;

        case 6:
            minLista.FixaPersoner();

            break;

    }
    val = meny();
    }

    return 0;
}
// <editor-fold desc="main-funktioner">

int meny() {
    int val=-1;
    do {
        cout << "Välj i menyn nedan" << endl;
        cout << "0) Avsluta. Alla transaktioner sparas på fil." << endl;
        cout << "1) Läs in en transaktion från tangentbordet." << endl;
        cout << "2) Skriv ut information om alla transaktioner." << endl;
        cout << "3) Beräkna totala kostnaden." << endl;
        cout << "4) Hur mycket är en viss person skyldig?" << endl;
        cout << "5) Hur mycket ligger en viss person ute med?" << endl;
        cout << "6) Lista alla personer mm och FIXA!!!" << endl;
        cin >> val;
    } while (val < 0 || val > 6);
    return val;
}

// <editor-fold desc="filnamns-funktioner">
/*string namn_pa_fil() {
    string filnamn;
    string nyckel = ".txt";

    cout << "Var god läs in namnet på filen: ";
    cin.ignore(1000, '\n');
    getline(cin, filnamn);

    //Om nyckeln inte hittas ELLER om nyckeln inte ligger sist, appenda nyckeln
    if (filnamn.rfind(nyckel) == -1 || filnamn.length() - nyckel.length() != filnamn.rfind(nyckel)) {
        filnamn.append(nyckel);
    }
    return filnamn;
}

//Givet ett filnamn försöker denna funktion öppna filen för läsning. Om filen inte kan öppnas avbryts programmet

ifstream oppnaIfstream(const string filnamn) {

    ifstream fin(filnamn.c_str());

    if (!fin) //felkontroll
    {
        cout << "Filen kunde inte öppnas" << endl;
        exit(EXIT_FAILURE);
    }
    return fin;
}*/
//</editor-fold>
// </editor-fold>


// <editor-fold desc="Person">
//-----------------------------------------------------------------------------
//Klassen Person
//-----------------------------------------------------------------------------
//Konstruktorer & Destruktorer

Person::Person() {

}

Person::Person(string n, double b, double s) {
    namn = n;
    betalat_andras = b;
    skyldig = s;
}

//-----------------------------------------------------------------------------
//Selektorer
//-----------------------------------------------------------------------------

double Person::haemta_betalat() {
    return betalat_andras;
}

double Person::haemta_skyldig() {
    return skyldig;
}

string Person::haemta_namn() {
    return namn;
}

//-----------------------------------------------------------------------------
//Metoder
//-----------------------------------------------------------------------------

void Person::skrivUt() {
    cout << namn << " ligger ute med " << betalat_andras << " kr och är skyldig " << skyldig << " kr. ";
    if (betalat_andras > skyldig) {
        cout << "Skall ha " << raekna_differans(betalat_andras, skyldig) << " kr från potten." << endl;
    } else {
        cout << "Skall betala " << raekna_differans(skyldig, betalat_andras) << " kr till potten." << endl;
    }
}

//Räknar ut differansen mellan skuld/utlagt
double Person::raekna_differans(double a, double b) {
    return (a - b);
}


//</editor-fold>

// <editor-fold desc="PersonLista">
//-----------------------------------------------------------------------------
//Klassen PersonLista
//-----------------------------------------------------------------------------
//Konstruktorer & Destruktorer

PersonLista::PersonLista() {

}

PersonLista::~PersonLista() {

}
//-----------------------------------------------------------------------------
//Metoder
//-----------------------------------------------------------------------------

//Lägger till en ny person sist i person-arrayen
void PersonLista::laggTillEn(Person pny) {

    pers[antal_pers]=pny;
    antal_pers++;

}

void PersonLista::skrivUtOchFixa() {

}

//Räknar ut totalen på allas skuld, borde gå jämt ut med summaBetalt
double PersonLista::summaSkyldig() {
    double summaSkyldig = 0;

    for (int i = 0; i < antal_pers; i++){
        summaSkyldig += pers[i].haemta_skyldig();
    }

    return summaSkyldig;

}

//Räknar ut totalen på vad alla betalat in, borde gå jämt ut med summaSkyldig
double PersonLista::summaBetalat() {
    double summaBetalat = 0;

    for (int i = 0; i < antal_pers; i++){
        summaBetalat += pers[i].haemta_betalat();
    }

    return summaBetalat;

}

//Går igenom arrayen med alla personer och kollar efter ett visst namn, om namnet finns hos någon av personerna, returnera true
bool PersonLista::finnsPerson(const string& namn) {

    for (int i = 0; i < antal_pers; i++) {
        if (namn == pers[i].haemta_namn()) {
            return true;
        }
    }

    return false;
}


// </editor-fold>

// <editor-fold desc="Transaktion">
//-----------------------------------------------------------------------------
//Klassen Transaktion
//-----------------------------------------------------------------------------
//Konstruktorer & Destruktor

Transaktion::Transaktion() {
    datum = "0";
    typ = "odef";
    namn = "";
    belopp = 0;
    ant_kompisar = 0;

}

Transaktion::~Transaktion() {
}
//-----------------------------------------------------------------------------
//Selektorer

string Transaktion::haemta_namn() {

    return namn;
}

double Transaktion::haemta_belopp() {

    return belopp;
}

int Transaktion::haemta_ant_kompisar() {

    return ant_kompisar;
}
//-----------------------------------------------------------------------------
//Metoder
//-----------------------------------------------------------------------------

//Letar igenom en array av kompisar och returnerar true om det givna namnet finns med
bool Transaktion::finnsKompis(string namnet) {

    for (int i = 0; i < ant_kompisar; i++) {

        if (namnet == kompisar[i]) {
            return true;
        }
    }

    return false;
}

//Läser in från en istream till instansvariablerna i en transaktion, returnerar true så länge eof inte är nådd
bool Transaktion::laesEnTrans(istream &is) {

    cout << "Nu är jag i laesEnTrans" << endl;
    is >> datum >> typ >> namn >> belopp >> ant_kompisar;
    for (int i = 0; i < ant_kompisar; i++) {

        is >> kompisar[i];
    }

    return !is.eof();

}

//Skriver över informationen om en transaktion ut på en ostream
void Transaktion::skrivEnTrans(ostream &os) {
    os << endl << datum << " " << typ << " " << namn << " " << belopp << " " << ant_kompisar << " ";
    for (int i = 0; i < ant_kompisar; i++) {
        os << kompisar[i] << " ";
    }
    os << "\n";

}
//-----------------------------------------------------------------------------
// </editor-fold>

// <editor-fold desc="TransaktionsLista">
//-----------------------------------------------------------------------------
//Klassen TransaktionsLista
//-----------------------------------------------------------------------------
//Konstruktorer & Destruktorer

TransaktionsLista::TransaktionsLista() {
    antalTrans = 0;
}

TransaktionsLista::~TransaktionsLista() {
}
//-----------------------------------------------------------------------------
//Metoder
//-----------------------------------------------------------------------------

//Läser in en transaktion/lista av transaktioner från en istream
void TransaktionsLista::laesin(istream &is) {
    Transaktion trans;

    if (&is == &cin) { //Här kollar jag om jag läser från cin eller från fil

        cout << "Läs in datum, kategori, namn, belopp, antal personer, vilka personer" << endl;
        trans.laesEnTrans(is);
        laggTill(trans);
        cout << " Kom jag hit?" << endl;
    }
    else {

        cout << " hit?" << endl;
        while (trans.laesEnTrans(is)) {
            cout << " Eller hit??" << endl;
            laggTill(trans);
        }
    }
}

//Skriver ut alla transaktioner på en ostream
void TransaktionsLista::skrivut(ostream &os) {
    cout << "Nu är jag i skrivut" << endl;

    for (int i = 0; i < antalTrans; i++) {
        trans[i].skrivEnTrans(os);
    }

}

//Lägger till en transaktion sist i en transaktionsarray
void TransaktionsLista::laggTill(Transaktion &t) {

    trans[antalTrans] = t;

    antalTrans++;

}

//Räknar ut den totala kostnaden för alla transaktioner
double TransaktionsLista::totalkostnad() {

    double totKostnad = 0;

    for (int i = 0; i < antalTrans; i++) {
        totKostnad += trans[i].haemta_belopp();
    }

    return totKostnad;

}

double TransaktionsLista::liggerUteMed(string namnet) {
    double utlagt = 0;

    //Går igenom alla transaktioner, jämför det angivna namnet med transaktionens loggade namn
    // Om de är samma, lägg till beloppet till summan
    for (int i = 0; i < antalTrans; i++) {
        if (namnet == trans[i].haemta_namn()) {
            utlagt += trans[i].haemta_belopp();
        }
    }
    return utlagt;
}

double TransaktionsLista::aerSkyldig(string namnet) {
    double skyldig = 0;

    for (int i = 0; i < antalTrans; i++) { //går igenom alla transaktioner

        if (trans[i].finnsKompis(namnet)) {

            //Om namnet finns i listan för kompisar som var med i en given transaktion,
            //dela transaktionens totalkostnad med antalet personer som var med (kompisar + betalare)
            // och lägg till i skulden

            skyldig += trans[i].haemta_belopp() / (trans[i].haemta_ant_kompisar() + 1);
        }

    }

    return skyldig;

}
//Skapar en personlista från de namn som finns med på transaktionerna, förutsätter att alla betalat/blivit betalade för minst 1 gång
PersonLista TransaktionsLista::FixaPersoner() {
    string tempNamn;
    double tempBetalt;
    double tempSkyldig;
    PersonLista pLista;
    Person tempPerson;
    int antalP = 0;
    cout << "Nu är jag i FixaPersoner" << endl;

    //Gå igenom alla transaktioner
    for (int i = 0; i < antalTrans; i++) {

        cout << "Hur många varv kan vi ta: " << antalP << endl << "antal trans: " << antalTrans << endl;
        //Ta ut betalarens namn och se om betalaren finns i Personlistan än, annars: lägg till personen
        //Vi antar att alla någon gång har betalat för sig själv och för andra

        tempNamn = trans[i].haemta_namn();
        if (!pLista.finnsPerson(tempNamn)) {

            tempBetalt = liggerUteMed(tempNamn);
            tempSkyldig = aerSkyldig(tempNamn);
            tempPerson = Person(tempNamn, tempBetalt, tempSkyldig);

            pLista.laggTillEn(tempPerson);
            antalP++;
        }

    }
   /* for (int k = 0; k < antalP; k++){

    } */
    return pLista;

}
// </editor-fold>