#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <stdio.h>
#include <ws2tcpip.h>

int WinMain(
  HINSTANCE Instance,
  HINSTANCE PrevInstance,
  LPSTR     CmdLine,
  int       ShowCmd)
{
  AllocConsole();
  freopen("CONOUT$", "w+", stdout);

  WSADATA WsData;
  WORD Ver = MAKEWORD(2, 2);
  int WsOK = WSAStartup(Ver, &WsData);
  if(WsOK != 0) return -1;

  SOCKET ListeningSocket = socket(AF_INET, SOCK_STREAM, 0);
  if(ListeningSocket == INVALID_SOCKET) return -2;

  sockaddr_in Hint;
  Hint.sin_family = AF_INET;
  Hint.sin_port = htons(54000);
  Hint.sin_addr.S_un.S_addr = INADDR_ANY;

  u_long Mode = 0;
  ioctlsocket(ListeningSocket, FIONBIO, &Mode);

  bind(ListeningSocket, (sockaddr *)&Hint, sizeof(Hint));
  listen(ListeningSocket, SOMAXCONN);

  fd_set MasterSet;
  FD_ZERO(&MasterSet);
  FD_SET(ListeningSocket, &MasterSet);
  while(true)
  {
    fd_set CopySet = MasterSet;
    int SocketCount = select(0, &CopySet, 0, 0, 0);
    for(int i=0; i<SocketCount; ++i)
    {
      SOCKET Socket = CopySet.fd_array[i];
      if(Socket == ListeningSocket)
      {
        printf("Client connected.\n");
        SOCKET ClientSocket = accept(ListeningSocket, 0, 0);

        int NonBlocokingRequestResult;
        u_long NonBlockingMode = 0;

        NonBlocokingRequestResult = ioctlsocket(ClientSocket, FIONBIO, &NonBlockingMode);

        if(NonBlocokingRequestResult == SOCKET_ERROR)
        {
          printf("Error: %d.\n", WSAGetLastError());
        }

        FD_SET(ClientSocket, &MasterSet);
        char *WelcomeMessage = "Welcome to the test server!";
        send(ClientSocket, WelcomeMessage, strlen(WelcomeMessage) + 1, 0);
      }
      else
      {
        char BufferIn[4096];
        ZeroMemory(BufferIn, 4096);
        int BytesIn = recv(Socket, BufferIn, 4096, 0);
        if(BytesIn <= 0)
        {
          printf("Client disconnected.\n");
          closesocket(Socket);
          FD_CLR(Socket, &MasterSet);
        }
        else
        {
          for(int i=0; i<MasterSet.fd_count; ++i)
          {
            SOCKET SocketOut = MasterSet.fd_array[i];
            if(SocketOut != ListeningSocket && SocketOut != Socket)
            {
              printf("CLIENT> %s\n", BufferIn);

              send(SocketOut, BufferIn, BytesIn, 0);
            }
          }
        }
      }
    }
  }

  WSACleanup();

  return(0);
}

#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <windowsx.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include <conio.h>
#include <process.h>

#include <ws2tcpip.h>

int ShouldClose = false;

int MousePosX;
int MousePosY;
int MouseLeftDown;

int LastSentMousePosX;
int LastSentMousePosY;

char DataReceived[4096] = {};
char DataSent[1024] = {};

SOCKET Socket;

DWORD NetworkThreadID;

DWORD
NetworkThreadProc(LPVOID LParam)
{
  DWORD Result = 0;

  ZeroMemory(DataReceived, 4096);

  int BytesReceived = 1;
  while(BytesReceived > 0)
  {
    BytesReceived = recv(Socket, DataReceived, 4096, 0);
    if(BytesReceived < 0)
    {
      int Error = WSAGetLastError();
    }
    else if(BytesReceived > 0)
    {
      printf("SERVER> %s\n", DataReceived);
    }
    else
    {
      printf("Disconnected.\n");
    }

    Sleep((1.0f/30)*1000);
  }

  return(Result);
}

LRESULT
MainWindowProc(
  HWND   Window,
  UINT   Message,
  WPARAM WParam,
  LPARAM LParam)
{
  LRESULT Result = 0;

  switch(Message)
  {
    case WM_LBUTTONDOWN:
    case WM_LBUTTONUP:
    {
      MouseLeftDown = (Message == WM_LBUTTONDOWN);
    } break;

    case WM_MOUSEMOVE:
    {
      MousePosX = GET_X_LPARAM(LParam);
      MousePosY = GET_Y_LPARAM(LParam);
    } break;

    case WM_CLOSE:
    case WM_DESTROY:
    {
      ShouldClose = true;
    } break;

    default:
    {
      Result = DefWindowProc(Window, Message, WParam, LParam);
    } break;
  }

  return(Result);
}


int WinMain(
  HINSTANCE Instance,
  HINSTANCE PrevInstance,
  LPSTR     CmdLine,
  int       ShowCmd)
{
  AllocConsole();
  freopen("CONOUT$", "w+", stdout);

  char *IpAddress = "127.0.0.1";
  int Port = 54000;

  WSAData Data;
  WORD Version = MAKEWORD(2, 2);
  int WsResult = WSAStartup(Version, &Data);
  if(WsResult != 0) return -1;

  Socket = socket(AF_INET, SOCK_STREAM, 0);
  if(Socket == INVALID_SOCKET)
  {
    WSACleanup();
    return -2;
  }
  sockaddr_in Hint;
  Hint.sin_family = AF_INET;
  Hint.sin_port = htons(Port);
  inet_pton(AF_INET, IpAddress, &Hint.sin_addr);

  int ConnResult = connect(Socket, (sockaddr *)&Hint, sizeof(Hint));
  if(ConnResult == SOCKET_ERROR)
  {
    closesocket(Socket);
    WSACleanup();
    return -3;
  }

  WNDCLASSA WindowClass={};
  WindowClass.style = CS_OWNDC|CS_HREDRAW|CS_VREDRAW;
  WindowClass.lpfnWndProc = MainWindowProc;
  WindowClass.hInstance = Instance;
  // WindowClass.hCursor;
  WindowClass.lpszClassName = "MainWindowClassName";

  RegisterClassA(&WindowClass);

  HWND Window = CreateWindowExA(
    0,
    WindowClass.lpszClassName,
    "Client for Networking Exp 2",
    // WS_OVERLAPPEDWINDOW,
    WS_OVERLAPPEDWINDOW|WS_VISIBLE,
    CW_USEDEFAULT,
    CW_USEDEFAULT,
    400,
    400,
    0,
    0,
    Instance,
    0
  );

  HANDLE NetworkThread = CreateThread(
    0,
    0,
    NetworkThreadProc,
    0,
    CREATE_SUSPENDED,
    &NetworkThreadID
  );

  ResumeThread(NetworkThread);

  while(!ShouldClose)
  {
    MSG Message = {};
    while(PeekMessageA(&Message, 0, 0, 0, PM_REMOVE))
    {
      TranslateMessage(&Message);
      DispatchMessageA(&Message);
    }

    if(MouseLeftDown)
    {
      if(MousePosX != LastSentMousePosX ||
         MousePosY != LastSentMousePosY)
      {
        LastSentMousePosX = MousePosX;
        LastSentMousePosY = MousePosY;

        ZeroMemory(DataSent, 1024);
        char XValueStr[32];
        char YValueStr[32];
        itoa(MousePosX, XValueStr, 10);
        itoa(MousePosY, YValueStr, 10);
        strcat(DataSent, XValueStr);
        strcat(DataSent, ",");
        strcat(DataSent, YValueStr);

        ZeroMemory(DataReceived, 4069);
        int SendResult = send(Socket, DataSent, strlen(DataSent) + 1, 0);
        if(SendResult == SOCKET_ERROR)
        {

        }
      }
    }

    Sleep((1/30.0f)*1000);
  }

  TerminateThread(NetworkThread, 0);

  closesocket(Socket);
  WSACleanup();

  return(0);
}