#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<string.h>

typedef struct versenyzo {
    char nev[30];
    int fordulo[6];     /*Egy logikai tömb, amely eldönti hogy egy versenyző részt vett-e egy fordulóban*/
    int pontszam[3];    /*Az 1-1 fordulóban elért 3 pontszámot tárolja (mindig felül lesz írva)*/
    int sorszam;
    int kivalasztas;    /*A párokba állításhoz egy logikai változó*/
}versenyzo;

typedef struct paros {      /*Láncolt lista elemei - pároknak*/
    versenyzo v1;
    versenyzo v2;
    struct paros *next;
}paros;

versenyzo *beolvasas(char *filenev, int *pdb)
{
    versenyzo *dintomb;
    FILE *be;
    char puffer[35];
    int db, i;

    be = fopen(filenev, "r");
    if (be == NULL)
        return 11;
    fgets(puffer, 35, be);
    sscanf(puffer, "%d", &db); /*Első sor beolvasása = ennyi további adatot kell beolvasni*/

    dintomb = (versenyzo*)malloc(db*sizeof(versenyzo));
    if (dintomb == NULL)
        return 12;

    for (i = 0; i < db; ++i)    /*A versenyzők sorszámának és nevének beolvasása egyenként*/
    {
        fgets(puffer, 35, be);
        sscanf(puffer, "%d", &dintomb[i].sorszam);
        fgets(dintomb[i].nev, "%s", be);
    }

    fclose(be);
    *pdb = db;
    return dintomb;
}

versenyzo *feltoltes(versenyzo *Indulok, int *meret)    /*A fordulo tömb feltöltése*/
{
    int j, k;
    for (j = 0; j < *meret; ++j)
    {
        for (k = 0; k < 6; ++k)
        {
            if (k == 0)
                Indulok[j].fordulo[k] = 1;
            else
                Indulok[j].fordulo[k] = 0;
        }
    }
    return Indulok;
}

versenyzo *kinullazas(versenyzo *Indulok, int *meret)   /*Ennek a logikai változónak (kivalasztas) szükséges a 0-ra állítása minden forduló elején*/
{
    int i;
    for (i = 0; i < *meret; ++i)
        Indulok[i].kivalasztas = 0;
    return Indulok;
}

paros *new_par(paros *head, versenyzo v_1, versenyzo v_2)       /*Új pár hozzáadása a listához*/
{
    paros *uj;
    uj = (paros*)malloc(sizeof(paros));
    uj->v1 = v_1;
    uj->v2 = v_2;
    uj->next = head;
    head = uj;
    return head;
}

void print_list(paros *head)        /*A lista kiírása*/
{
    paros *p;
    p = head;
    if (head != NULL)
    {
        while (p != NULL)
        {
            printf("Paros:\n");
            printf("%s\n%s\n\n", p->v1.nev, p->v2.nev);
            p = p->next;
        }
    }
}

paros *pontozas(paros *head)        /*Az egyes játékosok pontozása a láncolt listában*/
{
    int i, random1, random2;
    paros *p;
    p = head;
    if (head != NULL)
    {
        while (p != NULL)
        {
            for (i = 0; i < 3; ++i)
            {
                random1 = rand() % 4;
                random2 = rand() % 4;
                p->v1.pontszam[i] = random1;
                p->v2.pontszam[i] = random2;
            }
            p = p->next;
        }
    }
    return head;
}

paros *tovabbjutas(paros *head, int fordulo)        /*Eldönti a függvény hogy ki nyerte a mérkőzést*/
{
    int sum1 = 0, sum2 = 0, i, random1, random2;
    paros *p;
    p = head;
    if (head != NULL)
    {
        while (p != NULL)
        {
            for (i = 0; i < 3; ++i)         /*Pontok összegzése*/
            {
                sum1 += p->v1.pontszam[i];
                sum2 += p->v2.pontszam[i];
            }
            if (sum1 == sum2)               /*Ha egyenlő a pontszám akkor új forduló*/
            {
                random1 = rand() % 4;
                random2 = rand() % 4;
                while (random1 == random2)
                {
                    random1 = rand() % 4;
                    random2 = rand() % 4;
                }
                if (random1 > random2)
                    p->v1.kivalasztas = 1;      /*A nyertes logikai változójának 1-esre állítása*/
                else
                    p->v2.kivalasztas = 1;
            }
            if (sum1 > sum2)
                p->v1.kivalasztas = 1;
            if (sum2 > sum1)
                p->v2.kivalasztas = 1;
            p = p->next;
        }
    }
    return head;
}

versenyzo *adatatiras(paros *head, versenyzo *Indulok, int *meret, int fordulo)     /*A láncolt listából a nyertesek kiválasztása és az Indulók köv. fordulójának 1-re állítása*/
{
    int i;
    paros *p;
    p = head;
    if (head != NULL)
    {
        while (p != NULL)
        {
            if (p->v1.kivalasztas == 1)
            {
                for (i = 0; i < *meret; i++)
                {
                    if (p->v1.sorszam == Indulok[i].sorszam)
                        Indulok[i].fordulo[fordulo + 1] = 1;
                }
            }
            else
            {
                for (i = 0; i < *meret; i++)
                {
                    if (p->v2.sorszam == Indulok[i].sorszam)
                        Indulok[i].fordulo[fordulo + 1] = 1;
                }
            }
            p = p->next;
        }
    }
    return Indulok;
}

void delete_list(paros *head)       /*A lista törlése.*/
{
    paros *p;
    p = head->next;
    if (head != NULL)
    {
        while (p != NULL)
        {
            free(head);
            head = p;
            p = p->next;
        }
        free(head);
    }
}

versenyzo *verseny(versenyzo *Indulok, int *osszesindulo)
{
    int i, k, j; /*ciklusváltozók*/

    for (i = 0; i < 5; ++i)
    {
        Indulok = kinullazas(Indulok, osszesindulo);            /*Minden forduló elején szükséges!*/
        paros *head;                    /*Minden fordulóban újabb listára van szükség.*/
        head = NULL;

        int tovabbjutottak = 0;
        for (j = 0; j < *osszesindulo; ++j)         /*Megnézi hányan jutottak tovább ebbe a fordulóba.*/
        {
            if (Indulok[j].fordulo[i] == 1)
                tovabbjutottak++;
        }
        int *indexek;
        indexek = (int*)malloc(tovabbjutottak*sizeof(int));     /*Egy dinamikus tömb létrehozása, melyben a továbbjutott indulók indexeit tárolom*/
        int t = 0;

        for (k = 0; k < *osszesindulo; ++k)     /*Továbbjutottak indexeinek beolvasása*/
        {
            if (Indulok[k].fordulo[i] == 1)
            {
                indexek[t] = k;
                t++;
            }
        }

        int kivalaszt = 0;
        versenyzo par[2];           /*Kételemű tömb egy pár eltárolására*/

        while (kivalaszt != tovabbjutottak)     /*Párbaállítás kezdete*/
        {
            int random, a;
            random = rand() % tovabbjutottak + 1;
            for (a = 0; a < 2; ++a)
            {
                if (Indulok[indexek[random - 1]].kivalasztas == 1)  /*Ha már ki lett választva*/
                {
                    while (Indulok[indexek[random - 1]].kivalasztas != 0 && Indulok[indexek[random - 1]].fordulo[i] == 1)   /*Addig generáljon egy random indexet amíg olyan elemet nem talál, amely még nem volt kiválasztva*/
                        random = rand() % tovabbjutottak + 1;
                }
                par[a] = Indulok[indexek[random - 1]];
                /*Hamarabb olvasom be a tömbbe, minthogy 1-re állítanám a logikai változóját -- > a láncolt listában 0 marad így ott is felhasználhatom még.*/
                kivalaszt++;
                Indulok[indexek[random - 1]].kivalasztas = 1;           /*Logikai változójának beállítása - többé ne legyen kiválasztva*/
            }
            head = new_par(head, par[0], par[1]);                   /*A versenyzőket kettesével beolvasom a láncolt listába*/
        }   /*Párbaállítás vége!*/

        head = pontozas(head);          /*Pontozás*/
        head = tovabbjutas(head, i);        /*Továbbjutók kiválasztása (a láncolt listában egyelőre)*/
        adatatiras(head, Indulok, osszesindulo, i);     /*A továbbjutó következő fordulójának 1-re állítása a TÖMBben.*/
        printf("Az %d-dik fordulo versenyzoi:\n\n", i + 1);
        print_list(head);
        printf("\n");

        free(indexek);
        delete_list(head);
    }

    return Indulok;
}

void binarisba_iras(versenyzo *Indulok, int *osszesindulo)
{
    FILE *ki;
    ki = fopen("Nyertes.dat", "wb");
    if (ki == NULL)
        return 15;
    int i;
    char puffer[35];
    for (i = 0; i < *osszesindulo; ++i)
    {
        if (Indulok[i].fordulo[5] == 1)
            strcpy(puffer, Indulok[i].nev);
    }
    if (fwrite(puffer, 36 * sizeof(char), 1, ki) != 1)
        return 16;

    if (fclose(ki) != 0)
        return 17;
    fclose(ki);
}

void binaris_beolvas() /*Ellenőrzés*/
{
    FILE *bin;
    bin = fopen("Nyertes.dat", "rb");
    if (bin == NULL)
        return 18;
    char puffer[35];
    if(fread(puffer, 36*sizeof(char), 1, bin) != 1)
        return 19;
    printf("%s\n", puffer);
    if (fclose(bin) != 0)
        return 20;
    fclose(bin);
}

int main()
{
    versenyzo *Indulok;
    int osszesindulo;
    int l;

    srand(time(NULL));
    /*Adatok beolvasása: */
    Indulok = beolvasas("versenyzok.txt", &osszesindulo);
    /*A forduló logikai tömb feltöltése: */
    Indulok = feltoltes(Indulok, &osszesindulo);
    /*A verseny lebonyolítása: */
    Indulok = verseny(Indulok, &osszesindulo);
    /*Eredmény kiírása bináris fájlba: */
    binarisba_iras(Indulok, &osszesindulo);
    /*printf("\n\n");
    for (l = 0; l < osszesindulo; ++l)
    {
        if (Indulok[l].fordulo[5] == 1)
            printf("A nyertes: %s\n", Indulok[l].nev);
    }*/
    /*Ellenőrzés*/
    binaris_beolvas();
    free(Indulok);
    return 0;
}