/**
 *  Oblig_4
 *
 *  vektlegger:
 *      - struct
 *      - array
 *      - funksjoner
 *      - pekere
 *      - memory
 *
 *  programmet
 *      - holde orden på et arrangement
 *      - ulike oppgaver/gjøremål og bestemt antall personer tildelt til oppgaven
 *      - max 6 personer per oppgave
 *      - max 20 oppgaver
 *      - legge til nye og fjerne gamle oppgaver
 *      - rense memory
 *
 *  @file   Oblig_4.C
 *  @author Chi Hou Fung
 */

#include <stdio.h>
#include <stdbool.h>
#include <string.h>
#include <stdlib.h>
#include "LesData.h"

#define MAXPERS 6           ///< universal variabel for max personer
#define MAXOPPG 20          ///< universal variabel for max oppgaver

/**
 * Oppgave (med navn, totalt antall personer, midlertiodig antall personer
 * og array med personers ID)
 */
 struct Oppgave {
     char* navn;
     int   antallTotalt,
           antallNaa;
     int hvem[MAXPERS];
 };

 void fjernOppgave();
 void ledigeOppgaver();
 void nyOppgave();
 void oppgaveLesData(struct Oppgave* oppgave);
 bool oppgaveLedigPlass(const struct Oppgave* oppgave);
 void oppgaveSkrivData(const struct Oppgave* oppgave);
 void oppgaveTilknyttPersoner(struct Oppgave* oppgave);
 void personerTilknyttesOppgave();
 void oppgaveSlettData(struct Oppgave* oppgave);
 void skrivMeny();
 void skrivOppgaver();

 struct Oppgave* gOppgavene[MAXOPPG];       //oppgavene i oversikten
 int gSisteOppgave = 0;                     //antall oppgaver hittil

 /**
  * Hovedprogrammet
  */
int main() {
    char kommando;

    skrivMeny();
    kommando = lesChar("Kommando");

    while (kommando != 'Q') {
        switch (kommando) {
            case 'N': nyOppgave();                  break;
            case 'A': skrivOppgaver();              break;
            case 'L': ledigeOppgaver();             break;
            case 'T': personerTilknyttesOppgave();  break;
            case 'F': fjernOppgave();               break;
            default:  skrivMeny();                  break;
        }
        kommando = lesChar("\nKommando");
    }
    return 0;
}

/**
 * legger inn (om mulig) ny oppgave)
 *
 * @see OppgaveLesData(struct Oppgave* oppgave)
 */
void nyOppgave() {
    if (gSisteOppgave < MAXOPPG) {
        printf("\nOppgave nr. %i\n", gSisteOppgave+1);
        gOppgavene[gSisteOppgave] = (struct Oppgave*) malloc(sizeof(struct Oppgave));
        oppgaveLesData(gOppgavene[gSisteOppgave]);
        gSisteOppgave++;
    } else {
        printf("Du har n�dd max. antall oppgaver: %i\n", MAXOPPG);
    }
}

/**
 * leser inn dataene til structen
 *
 * @param oppgave - structen som får innlest data
 */
void oppgaveLesData(struct Oppgave* oppgave) {
    oppgave->navn = lagOgLesText("Navn");
    oppgave->antallTotalt = lesInt("Antall personer", 0, MAXPERS);
    oppgave->antallNaa = 0;
}
 /**
  * skriver ut masse printf'er som emny for koden
  */

void skrivMeny() {
    printf("Tilgjengelig kommandoer:\n");
    printf("\tN - Ny Oppgave\n");
    printf("\tA - Skriv ut alle eksisterende oppgaver\n");
    printf("\tL - Sjekke ledige oppgaver\n");
    printf("\tT - Tilfoye personer til oppgave(r)\n");
    printf("\tF - Fjern en oppgave\n");
    printf("\tQ - Avslutt\n\n");
}

/**
 * får gjennom alle nåværende oppgaver, og sørger for
 * at alle data om hver av dem blir skrevet ut
 *
 * @param oppgaveskrivdata (const struct Oppgave* oppgave)
 */
void skrivOppgaver()  {
    printf("Informasjon om eksisterende oppgaver:\n\n");
    for (int i = 0;  i < gSisteOppgave;  i++) {
        oppgaveSkrivData(gOppgavene[i]);
    }
}

/**
 * skriver alle data om en struct
 *
 * @param oppgave - structen som får skrevet ut alle sine data
 */
void oppgaveSkrivData(const struct Oppgave* oppgave) {
    printf("\tNavn: %s\n\tAntall personer: %i\n\tAntall nu: %i\n",
           oppgave->navn, oppgave->antallTotalt, oppgave->antallNaa);
}

/**
 * går gjennom alle nåværende oppgaver, og sørger
 * for at alle data om hver av dem som ikke er oppfylt med nokk personer blir skrevet ut
 *
 * @param oppgaveLedigPlass(const struct Oppgave* oppgave)
 */
void ledigeOppgaver() {
    for (int i = 0; i < gSisteOppgave; i++) {
        if (oppgaveLedigPlass(gOppgavene[i])) {
            printf("Ledige oppgave(r):\n");
            oppgaveSkrivData(gOppgavene[i]);
        } else {
            printf("Ingen ledige oppgave(r)");
        }
    }
}

/**
 * returnerer true/false til om oppgaven ikke er oppfylt med nok personer
 *
 * @param oppgave - structen som skal skjekkes
 */
bool oppgaveLedigPlass(const struct Oppgave* oppgave) {
    if ((oppgave->antallNaa) < (oppgave->antallTotalt)) {
        return true;
    } else {
        return false;
    }
}

/**
 * tilknytter personer til en valgt oppgave
 *
 * @param oppgaveTilknyttPersoner (struct Oppgave* oppgave)
 * @param oppgaveSkrivData (const struct Oppgave* oppgave)
 */
void personerTilknyttesOppgave() {
    int tall;

    if (gSisteOppgave == 0)
        printf("Det er ingen oppgaver tilgjengelig.\n");
    else
    {
        tall = lesInt("Skriv et oppgavenummer: ", 0, gSisteOppgave);
            if (tall == 0)
                printf("Du angrer.\n");
            else
                oppgaveSkrivData(gOppgavene[tall - 1]);
                oppgaveTilknyttPersoner(gOppgavene[tall - 1]);
                oppgaveSkrivData(gOppgavene[tall - 1]);
    }


}

/**
 * leser inn antall personer som tilknyttes til valgt oppgave
 * og gir ID til personene
 *
 * @param oppgave - struct som skal bli knyttet til personer
 */
void oppgaveTilknyttPersoner(struct Oppgave* oppgave)
{
    int lestInn;

    if (oppgave->antallNaa == oppgave->antallTotalt)
        printf("Det er fullt med personer.\n");
    else
        lestInn = lesInt("\nAntall personer tilknyttes oppgaven: ", 0, oppgave->antallTotalt - oppgave->antallNaa);

        for (int i = 0; i < lestInn; i++)
        {
            lesInt("Ditt nummer ", 1, 1000);
        }

    oppgave->antallNaa += lestInn;
}

/**
 * fjerner om mulig en oppgave fra lista med oppgaver
 *
 * @param oppgaveSlettData (struct Oppgave* oppgave)
 */
void fjernOppgave()
{
    int slett;
    char kommando;


    if (gSisteOppgave > 0)
    {                                           //spør bruker om oppgave nr som skal slettes
        slett = lesInt("Nummer for oppgave som skal slettes: ", 0, gSisteOppgave);


        if (slett != 0)
        {                                       //dobbelskjekker om bruker virkelig vil slette
            kommando = lesChar("Virkelig slette (j/N)?");

            if (kommando == 'J')
            {
                if (slett != gSisteOppgave)
            {                                   //kopierer siste vare til der slettede vare lå
                gOppgavene[slett-1] = gOppgavene[gSisteOppgave-1];
                gSisteOppgave--;                //"fjerner" siste vare
                oppgaveSlettData(gOppgavene[slett-1]);
                printf("Oppgave nr. %i er fjernet.\n", slett);
            }                                   //spesiell print dersom bruker ikke sletter siste
                else
                {
                    gSisteOppgave--;            //fjerner siste vare
                    oppgaveSlettData(gOppgavene[slett-1]);
                    printf("\nSlettet siste.\n");
                }                               //spesiell print dersom bruker sletter siste
            } else if (kommando != 'J')
                printf("Ingen slettes.\n");     //angre med å ikke skrive J
        }
        else
            printf("Ingen slettes.\n");         //angre med å skrive 0 som oppgave nr
    } else
        printf("Ingen oppgaver tilgjengelig.\n");



}

/**
 * sletter alle allokerte data inni en oppgave struct
 *
 * @param oppgave structen som får alle sine data frigitt
 */
void oppgaveSlettData(struct Oppgave* oppgave)
{
    free(oppgave->navn);
    free(oppgave);
}