/******************************************************************
 Grafika komputerowa, środowisko MS Windows - program  przykładowy
 *****************************************************************/


#include <string.h>
#include <stdlib.h>
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include "winet.h"
#include "common.h"
#include "network.h"
#include "logic.h"
#define MAXSIZE 512

int psi, teta, stan=0, blokada=0, client=1, wait=0;
char odbiorcza[250],wysylajaca[250];
struct sockaddr_in sin;
struct hostent *host;
char hoststr[30];
int rozmiar,x,y;
SOCKET klient;

char **board2buf(int board[SIZE][SIZE])
{
  int i,j;
  char **buf = malloc(SIZE * sizeof(char *));
    for (i = 0; i < SIZE; i++)
    buf[i] = malloc((SIZE + 2) * sizeof(char));
    for(i = 0; i < SIZE; i++)
    {
      for (j = 0; j < SIZE; j++)
      {
        // Coordinates alternation
        buf[i][j] = board[j][i] + '0';
      }
      buf[i][SIZE] = '\n';
      buf[i][SIZE+1] = '\0';
    }

  return buf;
}

void senddata(int sockfd, int code, char **buf)
{
  char  out[MAXSIZE];
  int   i, n;

  if (code == rp_ok)
  {
    sprintf(out, "1\n");
    for (i = 0; i < SIZE; i++)
    {
      strcat(out, buf[i]);
    }
  }
  else
  {
    sprintf(out, "0\n");
  }

  fprintf(stderr, "Sending: %s", out);
  n = strlen(out);
  if (writen(sockfd, out, n) != n)
    fprintf(stderr, "str_echo: writen error\n");
}

void input_callback(int sockfd)
{
  int n;
  int res;
  int x, y, c;
  char line[MAXSIZE + 1];

  n = readline(sockfd, line, MAXSIZE);
  if (n == 0)
  {
    perror("Connection terminated\n");
    return;		/* connection terminated */
  }
  else if (n < 0)
    perror("readline error\n");

  if (client)
  {
    line[n] = '\0';	/* null terminate */
    if (line[0] == '1')
    {
      for (int i = 0; i < SIZE; i++)
      {
        n = readline(sockfd, line, MAXSIZE);
        if (n < 0)
          perror("str_cli: readline error\n");

        line[n] = '\0';	/* null terminate */
        for (int j = 0; j < SIZE; j++)
        {
          board[j][i] = line[j] - '0';
        }
      }


    }		
  }
  else
  {
    printf("Received: %s", line);
    if (!wait)
    {
      if (line[0] == '0')
      {
        res = init();
      }
      else if (line[0] == '1')
      {
        res = 0;
        wait = 1;
      }
    }
    else
    {
      sscanf(line, "%d,%d,%d", &x, &y, &c);
      if (x == SIZE)
        senddata(sockfd, rp_ok, board2buf(board));
      else
      {
        res = place(x, y, c);
        wait = 0;
      }
    }

    if (res)
    {
      senddata(sockfd, rp_ok, board2buf(board));
    }
    else
    {
      senddata(sockfd, rp_error, NULL);
    }

  }

}

BOOLEAN timeout(void)
{
  int n;
  char sendline[MAXSIZE + 1];

  sprintf(sendline, "1\n%d,%d,%d\n", SIZE, SIZE, SIZE);
  printf("%s", sendline);

  n = strlen(sendline);
  if (writen(klient, sendline, n) != n)
    perror("str_cli: writen error on socket\n");

  return TRUE;
}

static BOOLEAN board_clicked(void)
{
  int n;
  char sendline[MAXSIZE + 1];

  if (client)
  {
    sprintf(sendline, "1\n%d,%d,%d\n", x, y , 1);
    printf("%s", sendline);

    n = strlen(sendline);
    if (writen(klient, sendline, n) != n)
      perror("str_cli: writen error on socket\n");
  }
  else
  {
    place(x,y, tl_white);
  }

  return TRUE;
}

//deklaracja funkcji obslugi okna
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

//funkcja Main - dla Windows
 int WINAPI WinMain(HINSTANCE hInstance,
               HINSTANCE hPrevInstance,
               LPSTR     lpCmdLine,
               int       nCmdShow)
{
	MSG meldunek;		  //innymi slowy "komunikat"
	WNDCLASS nasza_klasa; //klasa g&#322;ównego okna aplikacji
	HWND okno;
	static char nazwa_klasy[] = "Podstawowa";

	for(psi=0; psi<8; psi++)
	{
		for(teta=0; teta<8; teta++) board[psi][teta]=0;
	}
    wysylajaca[0]='0';
    odbiorcza[0]=0;

	//Definiujemy klase g&#322;ównego okna aplikacji
	//Okreslamy tu wlasciwosci okna, szczegoly wygladu oraz
	//adres funkcji przetwarzajacej komunikaty
	nasza_klasa.style         = CS_HREDRAW | CS_VREDRAW;
	nasza_klasa.lpfnWndProc   = WndProc; //adres funkcji realizuj&#261;cej przetwarzanie meldunków 
 	nasza_klasa.cbClsExtra    = 0 ;
	nasza_klasa.cbWndExtra    = 0 ;
	nasza_klasa.hInstance     = hInstance; //identyfikator procesu przekazany przez MS Windows podczas uruchamiania programu
	nasza_klasa.hIcon         = 0;
	nasza_klasa.hCursor       = LoadCursor(0, IDC_ARROW);
	nasza_klasa.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);
	nasza_klasa.lpszMenuName  = "Menu" ;
	nasza_klasa.lpszClassName = nazwa_klasy;

    //teraz rejestrujemy klas&#281; okna g&#322;ównego
    RegisterClass (&nasza_klasa);
	
	/*tworzymy okno g&#322;ówne
	okno b&#281;dzie mia&#322;o zmienne rozmiary, listw&#281; z tytu&#322;em, menu systemowym
	i przyciskami do zwijania do ikony i rozwijania na ca&#322;y ekran, po utworzeniu
	b&#281;dzie widoczne na ekranie */
 	okno = CreateWindow(nazwa_klasy, "Reversi", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
						CW_USEDEFAULT, WS_MAXIMIZE, 410, 435, NULL, NULL, hInstance, NULL);
	
	
	/* wybór rozmiaru i usytuowania okna pozostawiamy systemowi MS Windows */
   	ShowWindow (okno, SW_SHOW) ;
    
	//odswiezamy zawartosc okna
	UpdateWindow (okno) ;

/** Start winsocketow ************************/
	

	int blad;
	WORD wersja;
	WSADATA wsaData;
	wersja = MAKEWORD( 2, 0 );
	blad = WSAStartup(wersja, &wsaData );
 
	if ( blad != 0 )
	{
		MessageBox(okno,"error WSA","ERROR",MB_OK);
		WSACleanup();
	}

	if ( LOBYTE( wsaData.wVersion ) != 2 || HIBYTE( wsaData.wVersion ) != 0 )
	{
		MessageBox(okno,"error z&#322;a wersja winsocket","ERROR",MB_OK);
		WSACleanup();
	}

	klient = socket( AF_INET, SOCK_STREAM, 0 );

	host=gethostbyname("127.0.0.1");
	memset( &sin, 0, sizeof sin );
	sin.sin_family = AF_INET;
	sin.sin_addr.s_addr = ((struct in_addr *)(host->h_addr))->s_addr;
	sin.sin_port = htons(SERV_TCP_PORT);

 	connect(klient,(struct sockaddr *) &sin, sizeof(sin));
 	writen(klient, "0\n", 2);

	WSAAsyncSelect(klient,okno,WM_USER,FD_CONNECT|FD_READ|FD_WRITE|FD_ACCEPT);

	rozmiar = sizeof(sin);

	// G&#321;ÓWNA P&#280;TLA PROGRAMU
	while (GetMessage(&meldunek, NULL, 0, 0))
     /* pobranie komunikatu z kolejki; funkcja GetMessage zwraca FALSE tylko dla
	 komunikatu wm_Quit; dla wszystkich pozosta&#322;ych komunikatów zwraca warto&#347;&#263; TRUE */
	{
		TranslateMessage(&meldunek); // wst&#281;pna obróbka komunikatu
		DispatchMessage(&meldunek);  // przekazanie komunikatu w&#322;a&#347;ciwemu adresatowi (czyli funkcji obslugujacej odpowiednie okno)
	}
	return (int)meldunek.wParam;
}



/********************************************************************
FUNKCJA OKNA realizujaca przetwarzanie meldunków kierowanych do okna aplikacji*/
LRESULT CALLBACK WndProc (HWND okno, UINT kod_meldunku, WPARAM wParam, LPARAM lParam)
{
	POINT twoj_stary[2];
	
	
	
/* PONI&#379;SZA INSTRUKCJA DEFINIUJE REAKCJE APLIKACJI NA POSZCZEGÓLNE MELDUNKI */
	switch (kod_meldunku) 
	{
	case WM_LBUTTONDOWN: //reakcja na lewy przycisk myszki
		{
			x = LOWORD(lParam);
			y = HIWORD(lParam);
			
			x/=50;
			y/=50;
			board_clicked();
			//writen(klient, "1\n%d,%d,%d\n", x, y, tl_white, 8); 
            //timeout();
			/*if(place(x,y,tl_white))
            {
                 senddata(klient, rq_place, board2buf(board));
                 InvalidateRect(okno, NULL, FALSE);
            }*/
            
			InvalidateRect(okno, NULL, FALSE);
			return 0;
		}

	//case WM_RBUTTONDOWN: //reakcja na prawy przycisk myszy
		//{
		//	int x = LOWORD(lParam);
		//	int y = HIWORD(lParam);
			

		//		InvalidateRect(okno, NULL, FALSE);
		//		n++;
		//	}

		//	return 0;
	//	}
	
	case WM_PAINT:
		{
			PAINTSTRUCT paint;
			HDC kontekst;
			kontekst = BeginPaint(okno, &paint);

			int j;
			
/*************** Rysuj kratke ***********************************/
				HPEN kreska = CreatePen(PS_SOLID, 1, RGB(0,0,0));
				for(j=0; j<SIZE; j++)
				{
					SelectObject(kontekst, kreska);
					MoveToEx(kontekst, j*50,0, twoj_stary);
					LineTo(kontekst, j*50,400);
					MoveToEx(kontekst, 0, j*50, twoj_stary);
					LineTo(kontekst, 400, j*50);
				}
				DeleteObject(kreska);
				
				HBRUSH wypelnienie2 = CreateSolidBrush(RGB(0,0,0));	
				HBRUSH wypelnienie = CreateSolidBrush(RGB(255,255,255));
				HPEN	obramowanie = CreatePen(PS_SOLID,2, RGB(0,0,0));
				for(psi=0; psi<8; psi++)
				{
					for(teta=0; teta<8; teta++)
					{
						if(board[psi][teta]==tl_white)
						{
/***********************	Bialy kapsel *************************************/
							SelectObject(kontekst, obramowanie);
							SelectObject(kontekst, wypelnienie);
							Ellipse(kontekst, 3 + 50*psi, 3 + 50*teta, 48 + 50*psi, 48 + 50*teta);				
						}
						else if(board[psi][teta]==tl_black)
						{
/************************	Czarny kapsel *************************************/
							SelectObject(kontekst, wypelnienie2);
							Ellipse(kontekst, 3 + 50*psi, 3 + 50*teta, 48 + 50*psi, 48 + 50*teta);
						}
					}
				}
				DeleteObject(obramowanie);
				DeleteObject(wypelnienie2);
				DeleteObject(wypelnienie);

		
			/*if(stan==0)
	{
               writen(klient, "0\n", 2);
               stan=1;
               InvalidateRect(okno, NULL, FALSE);
    }*/
			EndPaint(okno, &paint);

			return 0;
		}
  	
	case WM_DESTROY: //obowi&#261;zkowa obs&#322;uga meldunku o zamkni&#281;ciu okna
		closesocket(klient);
		WSACleanup();
		PostQuitMessage (0) ;
		return 0;

	case WM_USER:
		{
			switch (WSAGETSELECTEVENT(lParam))
			{
                
				case FD_ACCEPT:
                        //MessageBox(okno,"po&#322;&#261;czono","connect",MB_OK);
                        /*if (stan==0)
                        {
                           send(klient,(char*)&wysylajaca,sizeof(wysylajaca),0);
                        }
						break;*/

				case FD_READ:
                        //input_callback(klient);
                        InvalidateRect(okno, NULL, FALSE);                        
                        if(stan==0)
                        {
                                   InvalidateRect(okno, NULL, FALSE);
                                   stan==0;
                                   timeout();
                        }
                        /*recv(klient,odbiorcza,dshfkjhds,0);
                        if(stan==0 && odbiorcza[0]==1)
                        {
                                   init();
                                   InvalidateRect(okno, NULL, FALSE);
                                   //MessageBox(okno,"Response!","response",MB_OK);
                                   odbiorcza[0]=0;
                                   stan=1;
                        }
                        else if(stan=1 && odbiorcza[0]=='1')
                        {
                             int n;
                             n=2;
                             for (int i = 0; i < SIZE; i++)
					         {
                                      for (int j = 0; j < SIZE; j++)
                                      {
                                               board[j][i]=wysylajaca[n++] - '0';
                                      }
                             }
                        }*/
                        
						break;

				case FD_CONNECT:
                     //MessageBox(okno,"po&#322;&#261;czono","connect",MB_OK);
                     //writen(klient, "0\n", 2);
						break;

				case FD_WRITE:
						break;
			}
			return 0;
		}
    
	default: //standardowa obs&#322;uga pozosta&#322;ych meldunków
		return DefWindowProc(okno, kod_meldunku, wParam, lParam);
	}
}