#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>



// deklaracja struktury obraz
// elementy struktury: szerokosc obrazu, wysokosc obrazu, glebia(liczba oznaczajaca biel, 0 oznacza czern)
// wskaznik na tablice danych
// wskaznik na nazwe zmiennej strukturalnej
struct obraz
{
    int szerokosc;
    int wysokosc;
    int glebia;
    int **dane;
    char nazwa[50];

};

// funkcja zwalniajaca pamiec zaalokowana na przechowywanie obrazu
// jako argument przekazujemy wskaznik na adres pamieci
void zwolnij_obraz(struct obraz ** ptr)
{
    int i;
    if (ptr == NULL || *ptr == NULL) return;
    {
        if ((*ptr)->dane != NULL)
        {
            for (i = 0; i < (*ptr)->wysokosc; ++i) free((*ptr)->dane[i]);
            free((*ptr)->dane);
        }
        free(*ptr);
        *ptr = NULL;

    }

}
// funkcja alokujaca pamiec na strukture obrazu
// jako argumenty przyjmuje wysokosc obrazu, szerokosc obrazu i glebie obrazu
// zwraca wartosc wskaznika na zaalokowana pamiec
// w przypadku bledu zwraca NULL
struct obraz *alokacja_pam(int _wys, int _szer, int _gleb)
{
    struct obraz * ptr;
    int i;
    ptr = (struct obraz *)malloc(sizeof(struct obraz));
    if (ptr == NULL) return NULL;
    ptr->szerokosc = _szer;
    ptr->wysokosc = _wys;
    ptr->glebia = _gleb;
    ptr->dane = (int**)malloc(sizeof(int*)*_wys);
    if (ptr->dane == NULL)
    {
        zwolnij_obraz(&ptr);
        return NULL;
    }
    for (i = 0; i < _wys; ++i)
    {
        ptr->dane[i] = (int*)calloc(_szer, sizeof(int));
        if (ptr->dane[i] == NULL)
        {
            zwolnij_obraz(&ptr);
            return NULL;
        }
    }

    return ptr;

}
// funkcja wczytujaca pojednyncze znaki z pliku obrazu
// jako argument przekazywany jest deskryptor pliku
// zwraca liczbe odczytana z pliku
// val- wartosc liczbowa, zn - znak
int wczytajliczbe(FILE *f)
{


    char buf[10];
    int val; // wartosc
    char zn; // znak
    while (1)
    {
        if (fscanf(f, " %s", buf) != 1) return -1; // zczytuje do spacji, ew 10
        if (sscanf(buf, "%d", &val) == 1) return val; // zczytuje wartosc w znaku
        if (buf[0] == '#')
        {

            do
            {
                zn = fgetc(f); // konczy wraz koncem lini
            } while (zn != '\n' && zn >= 0);
        }
    }

}
// funkcja wczytujaca plik pgm i zapisujaca go jako strukture "obraz"
// przyjmuje jako argument wskaznik na  zmienna strukturalna
// i, j - operatory petli, wysokosc szerokosc i glebia obrazu,
// w przypadku bledu zwraca wartosc 0
struct obraz * load_obraz(struct obraz * wczytywany)
{

    FILE *f;

    f = NULL;
    int i, j;
    char buf[20];
    char *nazwa;
    int wysokosc, szerokosc, glebia;
    nazwa = (char*)malloc(sizeof(char) * 100);
    if (nazwa == NULL) return 0;
    while (f == NULL)
    {
        printf("Podaj sciezke pliku, ktory chcesz wczytac\n\t- ");
        scanf("%s", nazwa);
        f = fopen(nazwa, "r");
        while (buf[0] != 'P' || buf[1] != '2')
        {
            while (f == NULL)
            {
                printf("\n\nNie udalo sie wczytac pliku \"%s\"\nPodaj sciezke pliku jeszcze raz\t- ", nazwa);
                scanf("%s", nazwa);
                f = fopen(nazwa, "r");
            }
            fscanf(f, "%s", buf);
            if (buf[0] != 'P' || buf[1] != '2')
            {
                printf("\n\nBledny format pliku.\n");
                f = NULL;
                fclose(f);
            }


            szerokosc = wczytajliczbe(f);
            if (szerokosc < 1)
            {
                printf("\n\nPlik uszkodzony, nieprawidlowa szerokosc.\n\n");
                f = NULL;
                fclose(f);
            }
            else
            {
                wysokosc = wczytajliczbe(f);
                if (wysokosc < 1)
                {
                    printf("\n\nPlik uszkodzony, nieprawidlowa wysokosc.\n\n");
                    f = NULL;
                    fclose(f);
                }
                else
                {
                    glebia = wczytajliczbe(f);
                    if (glebia < 1)
                    {
                        printf("\n\nPlik uszkodzony, nieprawidlowa wartosc maksymalna pola.\n\n");
                        f = NULL;
                        fclose(f);
                    }
                    else
                    {
                        wczytywany = alokacja_pam(wysokosc, szerokosc, glebia);
                        for (i = 0; i < (*wczytywany).wysokosc; i++)
                        {
                            for (j = 0; j < (*wczytywany).szerokosc; j++)
                            {
                                (*wczytywany).dane[i][j] = wczytajliczbe(f);
                            }
                        }
                    }
                }
            }
        }fclose(f);
    }return wczytywany;
}


// funkcja zapisujaca obraz w pliku w formacie pgm
//przyjmuje strukture jako argument
void zapis(struct obraz **zapisywany)
{

    char adres[50];
    int i, j;
    FILE *f = NULL;
    printf("Gdzie chcesz go aktualnie zapisac?\n\n  -");
    scanf("%s", adres);
    f = fopen(adres, "w");
    while (f == NULL)
    {
        printf("\n\nAdres nieprawidlowy, podaj nowy\n   -");
        scanf("%s", adres);
        f = fopen(adres, "w");
        if ((f = fopen(adres, "w")) == NULL)
            printf("Nie mogê otworzyæ pliku  do zapisu!\n");
    }
    if (fprintf(f, "P2\n%d %d \n%d \n", (*zapisywany)->szerokosc, (*zapisywany)->wysokosc, (*zapisywany)->glebia) < 1)
    {
        printf("\nNie udalo sie zapisac pliku!\n");
        fclose(f);
        return;
    }
    for (i = 0; i < (*zapisywany)->wysokosc; i++)
    {
        for (j = 0; j < (*zapisywany)->szerokosc; j++)
            if (fprintf(f, "%d ", (*zapisywany)->dane[i][j]) < 1)
            {
                printf("\nNie udalo sie zapisac pliku!\n");
                fclose(f);
                return;
            }
        fprintf(f, "\n");
    }
    printf("\n\n\n\nZapis zakonczony pomyslnie.\n\n\n\n");
    //(*zapisywany)->nazwa = adres;
    fclose(f);

}







//funkcja obracajaca obraz w prawo o 90stopni
// przyjmuje podwojny wskaznik na strukture obrazu, zwraca wskaznik na strukture obroconego
// w przypadku bledu zwraca 0
struct obraz *obrot(struct obraz **obr)
{
    int i, j;
    struct obraz * nowy;
    int szerokosc, wysokosc;
    szerokosc = (*obr)->wysokosc;
    wysokosc = (*obr)->szerokosc;

    nowy = alokacja_pam(wysokosc, szerokosc, (**obr).glebia);
    if (nowy == NULL)
    {
        printf("Nie udalo sie obrocic. :(\n");
        return 0;
    }
    for (i = 0; i < wysokosc; ++i)
    {
        for (j = 0; j < szerokosc; ++j)
        {
            (*nowy).dane[i][j] = (*obr)->dane[szerokosc - j - 1][i];

        }

    }
    zwolnij_obraz(obr);
    *obr = nowy;
    return *obr;
}

// funkcja odbijajaca wzgledem osi pionowej
//przyjmuje podwojny wskaznik na strukture obrazu
// zwraca wskaznik na strukture odbitego obrazu
// w przypadku bledu zwraca 0
struct obraz *odbity(struct obraz **wczytywany)
{
    int i;
    int j;
    struct obraz * nowy;
    int szerokosc, wysokosc;
    szerokosc = (*wczytywany)->szerokosc;
    wysokosc = (*wczytywany)->wysokosc;

    nowy = alokacja_pam(wysokosc, szerokosc, (**wczytywany).glebia);
    if (nowy == NULL)
    {
        printf("Nie udalo sie odbic. :(\n");
        return 0;
    }
    for (i = 0; i < wysokosc; ++i)
    {
        for (j = 0; j < szerokosc; ++j)
        {
            (*nowy).dane[i][j] = (*wczytywany)->dane[i][szerokosc - j];

        }

    }

    zwolnij_obraz(wczytywany);
    *wczytywany = nowy;
    return *wczytywany;

}


// funkcja wprowadzajaca negatyw
// przyjmuje podwojny wskaznik na strukture
// zwraca wskaznik na strukture obrazu
// w przypadku bledu zwraca 0
struct obraz *negatyw(struct obraz **wczytywany)
{
    int i, j;
    struct obraz * nowy;
    int szerokosc, wysokosc;
    szerokosc = (*wczytywany)->szerokosc;
    wysokosc = (*wczytywany)->wysokosc;

    nowy = alokacja_pam(wysokosc, szerokosc, (**wczytywany).glebia);
    if (nowy == NULL)
    {
        printf("Nie udalo sie odbic. :(\n");
        return 0;
    }
    for (i = 0; i < wysokosc; ++i)
    {
        for (j = 0; j < szerokosc; ++j)
        {
            (*nowy).dane[i][j] = ((**wczytywany).glebia - (**wczytywany).dane[i][j]);

        }

    }


    zwolnij_obraz(wczytywany);
    *wczytywany = nowy;
    return *wczytywany;

}

// funkcja pytajaca uzytkownika o to czy zapisac zmiany
//czesc menu
int czy_zapis()
{
    int a;
    printf("czy chcesz zapisaæ teraz obraz? \n 1- tak \n 2-nie \n");
    scanf("%d", &a);
    return a;
}


struct obraz *progowanie(struct obraz **wczytywany)
{
    int i, j;
    int prog = (*wczytywany)->glebia / 2;
    struct obraz * nowy;
    int szerokosc, wysokosc;
    if ((*wczytywany)->glebia == 1) return *wczytywany;
    szerokosc = (*wczytywany)->szerokosc;
    wysokosc = (*wczytywany)->wysokosc;

    nowy = alokacja_pam(wysokosc, szerokosc, (*wczytywany)->glebia);
    if (nowy == NULL)
    {
        printf("Nie udalo sie sprogowac. :(\n");
        return 0;
    }
    for (i = 0; i < wysokosc; ++i)
    {
        for (j = 0; j < szerokosc; ++j)
        {
            if (((*wczytywany)->dane[i][j]) > prog)
                (*nowy).dane[i][j] = (*wczytywany)->glebia;

            else
                (*nowy).dane[i][j] = 0;

        }
    }

    zwolnij_obraz(wczytywany);
    *wczytywany = nowy;
    return *wczytywany;

}

int main()
{
    int wyboruzyt;
    struct obraz wczytywany;
    struct obraz *ptr = NULL;
    do
    {
        printf("Czy chcesz:\n 1 -wczytac obraz\n 2 - obrocic obraz\n 3 - odbic obraz\n 4 - uzyc negatywu\n  5- Progowanie \n 6 -zmienic jasnosc \n 7 - wprowadzic kontrast\n ");
        printf(" 0 - wyjsc\n  Twoj wybor to:   ");
        scanf("%d", &wyboruzyt);

        switch (wyboruzyt)
        {
        case 1: // wczytaj obraz
            if (ptr != NULL) zwolnij_obraz(&ptr);
            ptr = load_obraz(&wczytywany);
            if (czy_zapis() == 1) zapis(&ptr);
            break;

        case 2:  //obroc obraz
            if (ptr == NULL)
            {
                printf("prosze wczytac najpierw obraz");
                break;
            }
            ptr = obrot(&ptr);
            if (ptr == 0) printf("blad");
            if (czy_zapis() == 1) zapis(&ptr);
            break;

        case 3:  //odbij
            if (ptr == NULL)
            {
                printf("prosze wczytac najpierw obraz");
                break;
            }
            ptr = odbity(&ptr);
            if (ptr == 0) printf("blad");
            if (czy_zapis() == 1) zapis(&ptr);
            break;

        case 4:  // negatyw
            if (ptr == NULL)
            {
                printf("prosze wczytac najpierw obraz");
                break;
            }
            ptr = negatyw(&ptr);
            if (ptr == 0) printf("blad");
            if (czy_zapis() == 1) zapis(&ptr);
            break;

        case 5:
            if (ptr == NULL)
            {
                printf("prosze wczytac najpierw obraz");
                break;
            }
            ptr = progowanie(&ptr);
            if (czy_zapis() == 1) zapis(&ptr);
            break;

        case 6: // zmien jasnosc
            printf("prosze wprowadzić wartość z zakresu -100 do 100\n");
            if (ptr != NULL) zwolnij_obraz(&ptr);

            break;
        case 7: // wprowadz kontrast
            printf("prosze wprowadzić wartość z zakresu -100 do 100\n");
            if (ptr != NULL) zwolnij_obraz(&ptr);

            break;
        case 8: // przeswietlenia
            printf("prosze wprowadzić wartość z zakresu -100 do 100\n");
            if (ptr != NULL) zwolnij_obraz(&ptr);

            break;

        case 9: // cienie
            printf("prosze wprowadzić wartość z zakresu -100 do 100\n");
            if (ptr != NULL) zwolnij_obraz(&ptr);

            break;

        case 0: // w uprzejmy sposob konczy dzialanie programu
            printf("do zobaczenia :) \n");
            zwolnij_obraz(&ptr);
            break;

        default: printf("nie ma takiej opcji. Wybierz jedna z dostepnych ponizej \n");
        }


    } while (wyboruzyt != 6);
}