#include "funkcje.h"
#include "opcje.h"

#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <unistd.h>

int czytaj(FILE *plik_we, Obraz* obraz) {
  char buf[DL_LINII];      /* bufor pomocniczy do czytania naglowka i komentarzy */
  char typObrazu;
  int znak;                /* zmienna pomocnicza do czytania komentarzy */
  int koniec=0;            /* czy napotkano koniec danych w pliku */
  /*Sprawdzenie czy podano prawid�owy uchwyt pliku */

  /* assert(plik_we != NULL); */

  char* status = fgets(buf, DL_LINII, plik_we);

  /* Sprawdzenie "numeru magicznego" - powinien by� P2 */
  if (status==NULL)   /* Wczytanie pierwszej linii pliku do bufora */
    koniec=1;                              /* Nie udalo sie? Koniec danych! */

  assert( ((buf[0]!='P') || ((buf[1]!='2') || (buf[1]!='3')) || koniec) && "Blad: To nie jest plik PGM\n");
  typObrazu = buf[1];

    if (typObrazu == '2')
    {
        obraz->kolor = 0;
    }
    else
    {
        obraz->kolor = 1;
    }

  /* Pominiecie komentarzy */
  do
    {
        znak=fgetc(plik_we);

        if (znak=='#')
        {         /*    Czy linia rozpoczyna sie od znaku '#'? */
            if (fgets(buf,DL_LINII,plik_we)==NULL)
            {                                                           /* Przeczytaj ja do bufora                */
                koniec=1;                   /* Zapamietaj ewentualny koniec danych */
            }
        }
        else
        {
            ungetc(znak,plik_we);                   /* Gdy przeczytany znak z poczatku linii */
        }                                         /* nie jest '#' zwroc go                 */
    } while (znak=='#' && !koniec);   /* Powtarzaj dopoki sa linie komentarza */
                                    /* i nie nastapil koniec danych         */

    /* Pobranie wymiarow obrazu i liczby odcieni szarosci */
    if (fscanf(plik_we,"%d %d %d",&(obraz->wymx), &(obraz->wymy),&(obraz->szarosci))!=3)
    {
        fprintf(stderr,"Blad: Brak wymiarow obrazu lub liczby stopni szarosci\n");
        return(0);
    }

    /* Zaalokowanie pamieci dla obrazu */
    zaalokuj_pamiec(obraz);

    wczytaj(plik_we, obraz);

    return obraz->wymx*obraz->wymy;   /* Czytanie zakonczone sukcesem    */
}                       /* Zwroc liczbe wczytanych pikseli */

/* Wyswietlenie obrazu o zadanej nazwie za pomoca programu "display"   */
void wyswietl(char *n_pliku) {
  char polecenie[DL_LINII];      /* bufor pomocniczy do zestawienia polecenia */

  strcpy(polecenie,"display ");  /* konstrukcja polecenia postaci */
  strcat(polecenie,n_pliku);     /* display "nazwa_pliku" &       */
  strcat(polecenie," &");
  printf("%s\n",polecenie);        /* wydruk kontrolny polecenia */
  system(polecenie);             /* wykonanie polecenia        */
}

void wyswietl_aktualny(Obraz* obraz)
{
    FILE* plik;
  char polecenie[DL_LINII];      /* bufor pomocniczy do zestawienia polecenia */
  char ppm_nazwa_tmp[] = "tmp.ppm";
  char pgm_nazwa_tmp[] = "tmp.pgm";

  if(obraz->kolor)
  {
    plik=fopen(ppm_nazwa_tmp, "w");
    if(plik==NULL)
        {
            return;
        }
        zapisz(plik,obraz);
    wyswietl(ppm_nazwa_tmp);
    system("clear");              /*Niewyswietlanie na terminalu rm -f tmp.ppm"*/

    sleep(1);

    strcpy(polecenie,"rm -f ");    /* konstrukcja polecenia postaci */
    strcat(polecenie,ppm_nazwa_tmp);     /* rm -f tmp.pgm       */
    system(polecenie);
  }
  else
  {
    plik=fopen(pgm_nazwa_tmp, "w");
        if(plik==NULL)
        {
            return;
        }
    zapisz(plik, obraz);
    wyswietl(pgm_nazwa_tmp);
    system("clear");              /*Niewyswietlanie na terminalu rm -f tmp.pgm"*/

    sleep(1);

    strcpy(polecenie,"rm -f ");    /* konstrukcja polecenia postaci */
    strcat(polecenie,pgm_nazwa_tmp);     /* rm -f tmp.pgm       */
    system(polecenie);
  }
}

void zapisz(FILE* plik,Obraz* obraz)
{
  /* Funckja zapisz, ktora zapisuje obecny plik obraz_pgm do pliku */
    int i,j; /*zmienne pomocnicze */

    if(obraz->kolor)
    {
        fprintf(plik, "P3\n");
        fprintf(plik, "%d %d\n%d\n", obraz->wymx, obraz->wymy, obraz->szarosci);  /* wymiar�w do pliku */

        for(i=0; i<obraz->wymy; i++) /* petla ktora zapisuje szary do pliku */
        {
            for(j=0; j<obraz->wymx; j++)
            {
                fprintf(plik, "%d %d %d ", obraz->r[i][j], obraz->g[i][j], obraz->b[i][j]);
            }
            fprintf(plik, "\n");
        }

    }
    else
    {
        fprintf(plik, "P2\n");
        fprintf(plik, "%d %d\n%d\n", obraz->wymx, obraz->wymy, obraz->szarosci);  /* wymiar�w do pliku */

        for(i=0; i<obraz->wymy; i++) /* petla ktora zapisuje szary do pliku */
        {
            for(j=0; j<obraz->wymx; j++)
            {
                fprintf(plik, "%d ", obraz->sz[i][j]);
            }
            fprintf(plik, "\n");
        }
    }

    fclose(plik); /* zamkniecie otwartego pliku */
}

void wczytaj(FILE* plik_we, Obraz* obraz)           /* funkcja wczytujaca piksele obrazu    */
{
    int i, j;

    if(obraz->kolor)
    {
        for (i=0;i<obraz->wymy;i++)
        {
            for (j=0;j<obraz->wymx;j++)
            {
                if (fscanf(plik_we,"%d %d %d",&(obraz->r[i][j]), &(obraz->g[i][j]), &(obraz->b[i][j])) !=3 )
                {
                    fprintf(stderr,"Blad: Niewlasciwe wymiary obrazu\n");
                    return;
                }
            }
        }
    }
    else
    {
        for (i=0;i<obraz->wymy;i++)
        {
            for (j=0;j<obraz->wymx;j++)
            {
                if (fscanf(plik_we,"%d",&(obraz->sz[i][j])) !=1 )
                {
                    fprintf(stderr,"Blad: Niewlasciwe wymiary obrazu\n");
                    return;
                }
            }
        }
    }
}

void zaalokuj_pamiec(Obraz* obraz)
{
    int i;

    if(obraz->kolor)
    {
        obraz->sz=malloc(obraz->wymy*sizeof(int*));              /*********************************/
        obraz->r=malloc(obraz->wymy*sizeof(int*));           /*                               */
        obraz->g=malloc(obraz->wymy*sizeof(int*));            /*                               */
        obraz->b=malloc(obraz->wymy*sizeof(int*));          /*                               */
                                                                    /*  zaalokowanie pamieci dla     */
        for(i=0;i<obraz->wymy;i++)                                  /*                               */
        {                                                           /*  obrazow kolorowych           */
            (obraz->sz)[i]=malloc(obraz->wymx*sizeof(int));      /*                               */
            (obraz->r)[i]=malloc(obraz->wymx*sizeof(int));   /*                               */
            (obraz->g)[i]=malloc(obraz->wymx*sizeof(int));    /*                               */
            (obraz->b)[i]=malloc(obraz->wymx*sizeof(int));  /*                               */
        }                                                           /*********************************/
    }
    else
    {
        obraz->sz=malloc(obraz->wymy*sizeof(int*));              /*********************************/
                                                                    /*                               */
        for(i=0;i<obraz->wymy;i++)                                  /*  a tutaj dla szarych          */
        {                                                           /*                               */
            (obraz->sz)[i]=malloc(obraz->wymx*sizeof(int));      /*********************************/
        }
    }
}


void negatyw(Obraz* obraz)
{
  /* funkcja ktora wykonuje negatyw obrazu */
  int i,j; /* zmienne pomocnicze */
  if(obraz->kolor)
  {
    for(i=0; i<obraz->wymy; i++)
    {
      for(j=0;j<obraz->wymx;j++)
      {
        obraz->r[i][j]=obraz->szarosci-obraz->r[i][j];
        obraz->g[i][j]=obraz->szarosci-obraz->g[i][j];
        obraz->b[i][j]=obraz->szarosci-obraz->b[i][j];
      }
    }
  }
  else
  {
    for(i=0; i<obraz->wymy; i++)
    {
      for(j=0;j<obraz->wymx;j++)
      {
        obraz->sz[i][j]=obraz->szarosci-obraz->sz[i][j]; /* wykonanie negatywu */
      }
    }
  }
}

void progowanie(Obraz* obraz, float prog)
{
  /* funkcja wykonujaca progowanie */
  int i,j; /* zmienne pomocnicze */

  if(obraz->kolor)
  {
    for(i=0; i<obraz->wymy; i++) /* petla zamieniajaca wartosci pikseli na wartosc po progowaniu */
    {
      for(j=0; j<obraz->wymx; j++)
      {
        if(obraz->r[i][j]<=prog)
        {
          obraz->r[i][j]=0;
        }
        else
        {
          obraz->r[i][j]=obraz->szarosci;
        }

        if(obraz->g[i][j]<=prog)
        {
          obraz->g[i][j]=0;
        }
        else
        {
          obraz->g[i][j]=obraz->szarosci;
        }

        if(obraz->b[i][j]<=prog)
        {
          obraz->b[i][j]=0;
        }
        else
        {
          obraz->b[i][j]=obraz->szarosci;
        }
      }
    }
  }

  else
  {
    for(i=0; i<obraz->wymy; i++) /* petla zamieniajaca wartosci pikseli na wartosc po progowaniu */
    {
      for(j=0; j<obraz->wymx; j++)
      {
        if(obraz->sz[i][j]<=prog)
        {
          obraz->sz[i][j]=0;
        }
        else
        {
          obraz->sz[i][j]=obraz->szarosci;
        }
      }
    }
  }
}


void konturowanie(Obraz* obraz)
{
  /* funkcja wykonujaca konturowanie obrazu */
  int i,j;  /*  zmienne pomocnicze          */

  if(obraz->kolor)    /* sprawdzenie czy obraz jest kolorowy   */
  {
    for (i=0; i<(obraz->wymy-1); ++i)
    {
      for(j=0; j<(obraz->wymx-1); ++j)
      {
        obraz->r[i][j]=abs(obraz->r[i+1][j]-obraz->r[i][j])+abs(obraz->r[i][j+1]-obraz->r[i][j]);
        obraz->g[i][j]=abs(obraz->g[i+1][j]-obraz->g[i][j])+abs(obraz->g[i][j+1]-obraz->g[i][j]);
        obraz->b[i][j]=abs(obraz->b[i+1][j]-obraz->b[i][j])+abs(obraz->b[i][j+1]-obraz->b[i][j]);
      }
    }

  }

  else
  {
    for (i=0; i<(obraz->wymy-1); ++i)
    {
      for(j=0; j<(obraz->wymx-1); ++j)
      {
        obraz->sz[i][j]=abs(obraz->sz[i+1][j]-obraz->sz[i][j])+abs(obraz->sz[i][j+1]-obraz->sz[i][j]);
      }
    }
  }

}

void konwertuj_do_szarosci(Obraz* obraz)
{
  /* funkcja wykonujaca konwersje do szarosci */
  int i,j;

  if(!obraz->kolor)    /* jesli obraz nie jest kolorowy  */
  {
      fprintf(stderr,"To nie jest obraz kolorowy\n");
      sleep (1);
      return;
  }

  obraz->kolor=0;
  for(i=0; i<obraz->wymy; ++i)
  {
      for(j=0; j<obraz->wymx; ++j)
      {
          obraz->sz[i][j]=(obraz->r[i][j]+obraz->g[i][j]+obraz->b[i][j])/3;
      }
  }
}