/**** Szymon Wróblewski *******
 **** Projekt zaliczeniowy ****
 **** Informatyka 2019/20 *****/

#include <math.h>
#include <stdio.h>
#include <time.h>

#include "stdlib.h"
#include "winbgi2.h"

int wczytaj_int()
{
    int wartosc;
    scanf("%d", &wartosc);
    return wartosc;
}

float wczytaj_float()
{
    float wartosc;
    scanf("%f", &wartosc);
    return wartosc;
}

void bledne_dane()
{
    printf("Wczytane dane sa ze zlego przedzialu.\n")
    exit(1);
}

int wczytaj_liczbe_osob()
{
    printf("Podaj liczbe osob [1, inf]:\n");
    int liczba_osob = wczytaj_int();

    if (liczba_osob < 1)
        bledne_dane();

    return liczba_osob;
}

int wczytaj_liczbe_ruchow()
{
    printf("Podaj liczbe ruchow [0, 800]:\n");
    int liczba_ruchow = wczytaj_int();

    if (liczba_ruchow < 0 || liczba_ruchow > 800)
        bledne_dane();

    return liczba_ruchow;
}

int wczytaj_prog()
{
    printf("Podaj prawdopodobienstwo ruchu w lewo [0 - 1]:\n");
    float prog = wczytaj_float();

    if (wartosc < 0 || wartosc > 1)
        bledne_dane();

    return prog;
}

bool czy_lewo(float prog)
{
    float los = (float) rand() / (float) RAND_MAX;
    return los < prog;
}

void inicjalizacja_pozycji(int *osoba, int liczba_ruchow)
{
    for (int i = 0; i < liczba_osob ; i++)
        osoba[i] = liczba_ruchow;   // pozycja poczatkowa to liczba_ruchow, zeby uniknac pozycji ujemnych
}

void symulacja(int *osoba, int liczba_osob, int liczba_ruchow, float prog)
{
    for (int i = 0; i < liczba_ruchow ; i++) {
        for ( int j = 0; j < liczba_osob; j++) {
            if (czy_lewo(prog))
                osoba[j] --;
            else
                osoba[j] ++;
        }
    }
}

int policz_wysokosc_maksimum(int *wysokosc, int *osoba, int liczba_osob, int liczba_ruchow)
{
    for (int i = 0; i <= 2 * liczba_ruchow; i++)
        wysokosc[i] = 0;

    for (int i = 0 ; i < liczba_osob; i++)
        wysokosc[osoba[i]] ++;

    for (int i = 0 ; i <= 2 * liczba_ruchow; i++)
        maksimum = std::max(maksimum, wysokosc[i]);

    return maksimum;
}

void rysuj_wykres(int *wysokosc, int liczba_ruchow, int maksimum)
{
    graphics(200 + 2 * liczba_ruchow, 800);
    line(50, 650, 150 + 2 * liczba_ruchow, 650);
    line(100 + liczba_ruchow, 700 , 100 + liczba_ruchow, 870);

    for( int i = 0 ; i <= 2 * liczba_ruchow; i++)
        line( 100 + i, 650, 100 + i, 650 - wysokosc[i] * 620 / maksimum);
}

void main()
{
    // Deklaracja zmiennych
    int liczba_osob, liczba_ruchow;    // liczba osob uczestniczacych w symulacji, dlugosc symulacji
    int *osoba;         // tablica z pozycja danej osoby
    float prog;         // wartosc graniczna decydujaca o kierunku ruchu

    int *wysokosc;      // liczba osob konczacych na danej pozycji
    int maksimum = 0;   // zmienna pomocnicza z maksymalna liczba osob na pozycji

    // Wczytanie danych wejsciowych
    liczba_osob = wczytaj_liczbe_osob();
    liczba_ruchow = wczytaj_liczbe_ruchow();
    prog = wczytaj_prog();

    // Alokacja tablic i ziarna losowania
    srand(time(NULL));
    osoba = (int*) malloc(liczba_osob * sizeof(int));
    wysokosc = (int*) malloc((2 * liczba_ruchow + 1) * sizeof(int));

    // Inicjalizacja pozycji osob
    inicjalizacja_pozycji(osoba, liczba_ruchow);

    // Symulacja bladzenia
    symulacja(osoba, liczba_osob, liczba_ruchow, prog);

    // Policzenie rozkladu
    maksimum = policz_wysokosc_maksimum(wysokosc, osoba, liczba_osob, liczba_ruchow);

    // Rysowanie wykresu
    rysuj_wykres(wysokosc, liczba_ruchow, maksimum);

    // Zwalnianie pamieci
    free(wysokosc);
    free(osoba);
    wait();
}