LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)                  /* handle the messages */
    {
      case WM_CREATE:
        CreateWindowEx(0,                                      //more or 'extended' styles
                       TEXT("BUTTON"),                         //'class' of control to create
                       TEXT("Connect"),            //the control caption
                       WS_CHILD|WS_VISIBLE|BS_DEFPUSHBUTTON,   //control style: how it looks
                       10,                                     //control position: left
                       10,                                     //control position: top
                       100,                                    //control width
                       20,                                     //control height
                       hwnd,                                   //parent window handle
                       (HMENU)IDC_CONNECT,                                   //control's ID
                       g_hInst,                                //application instance
                       NULL); 
        CreateWindowEx(0,                                      //more or 'extended' styles
                       TEXT("BUTTON"),                         //'class' of control to create
                       TEXT("Wait"),            //the control caption
                       WS_CHILD|WS_VISIBLE|BS_DEFPUSHBUTTON,   //control style: how it looks
                       120,                                     //control position: left
                       10,                                     //control position: top
                       100,                                    //control width
                       20,                                     //control height
                       hwnd,                                   //parent window handle
                       (HMENU)IDC_SERVER,                                   //control's ID
                       g_hInst,                                //application instance
                       NULL);  
                       
      break;
      case WM_WSAASYNC:
      // what word?
        
        switch(WSAGETSELECTEVENT(lParam))
        {
          case FD_ACCEPT:
            MessageBox(NULL,"Connection request received","Alert!",MB_OK); //this comes up
            // check for an error
            if (WSAGETSELECTERROR(lParam))
              return(FALSE);
            // process message
            try
            {
            netwkobj.Accept();
            }
            catch (const NetErr& error)
            {
              MessageBox(NULL,error.what(),"Network Error",MB_OK|MB_ICONEXCLAMATION);
            }
            return(0);
          break;
          case FD_READ:
           //receiving data
          break;
          case FD_WRITE:
          //..
          break;
          case FD_CONNECT:
          //server got our connect message
            MessageBox(NULL,"Connect request accepted","Alert!",MB_OK); // this never comes up
          break;
          case FD_CLOSE:
          //connection closed
            PostQuitMessage(0); //just quit for now...i guess
          break;
        }
        
      break; 
      case WM_COMMAND:
        switch(LOWORD(wParam))
        {
          case IDC_CONNECT: //button pressed: try to connect to a server
            try
            {
              netwkobj.Init(hwnd,false); 
              netwkobj.Connect("192.168.2.15");
            }
            catch (const NetErr& error)
            {
              MessageBox(NULL,error.what(),"Network Error!",MB_OK|MB_ICONEXCLAMATION);
            }
            //MessageBox(NULL,"Connected","OK",MB_OK);
          break;
          case IDC_SERVER:
            try
            {
              netwkobj.Init(hwnd,true); //move this to when we try to join or host a game in a menu
            }
            catch (const NetErr& error)
            {
              MessageBox(NULL,error.what(),"Network Error!",MB_OK|MB_ICONEXCLAMATION);
            }
        //    MessageBox(NULL,"Listening...","OK",MB_OK);
          break;
        }
      break;    
      case WM_DESTROY:
        PostQuitMessage (0);       /* send a WM_QUIT to the message queue */
      break;
      default:                      /* for messages that we don't deal with */
        return DefWindowProc (hwnd, message, wParam, lParam);
    }

    return 0;
}

//network class member fcns
Network::Network()
{
hSocket = INVALID_SOCKET;
numclients=0;

}

void Network::Init(HWND hwnd, bool isserver) 
{
init = true;
WSADATA wsaData;
if (WSAStartup(MAKEWORD(REQ_WINSOCK_VER,0), &wsaData)==0) //start winsock
{
// Check if major version is at least REQ_WINSOCK_VER
  if (LOBYTE(wsaData.wVersion) < REQ_WINSOCK_VER)
  {
    throw NetErr("Required Winsock Version not met!");
  }
}  
else
  throw NetErr("Error starting Winsock!");
// create and test the socket
hSocket = socket(AF_INET, SOCK_STREAM, 0);
if (hSocket == INVALID_SOCKET)
  throw NetErr("INVALID_SOCKET");
// make the socket asynchronous and notify of read, write, connect and close events
// this is the client socket
if (!isserver)
{
WSAAsyncSelect(hSocket, hwnd, WM_WSAASYNC, FD_WRITE | FD_CONNECT |
                                        FD_READ | FD_CLOSE); //set up asynchronous sockets
                            //request WRITE, READ, CONNECT, and CLOSE messages be sent
server=false;
}
// make the socket asynchronous and notify of read, write, accept and close events
// this is the server socket
else
{
//is this the right order? (set to listen before call to WSAAsyncSelect()?

sockaddr_in    sockAddr = {0};
SetServerSockAddr(&sockAddr, SERVER_PORT);
if (bind(hSocket, reinterpret_cast<sockaddr*>(&sockAddr), sizeof(sockAddr))!=0) 
  throw NetErr("Could not bind socket.");
if (listen(hSocket, SOMAXCONN)!=0) //set socket to listen for incoming data
  throw NetErr("Could not put socket into listening mode.");

WSAAsyncSelect(hSocket, hwnd, WM_WSAASYNC, FD_READ | FD_WRITE |
                                        FD_ACCEPT | FD_CLOSE); //again, async sockets


  
                                        
server=true;
}

}

void Network::Connect(const char* servIp)
{
if (!init)
  throw NetErr("Network not initialized!");
sockaddr_in    sockAddr = {0};
FillSockAddrDot(&sockAddr, servIp, SERVER_PORT);

if ((hSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == INVALID_SOCKET)
  throw NetErr("Could not create socket.");
        
        // Connect to server
if (connect(hSocket, reinterpret_cast<sockaddr*>(&sockAddr), sizeof(sockAddr))!=0)
  throw NetErr("Could not connect.");


}

void Network::Accept()
{
if (!init)
  throw NetErr("Network not initialized!");
  int clientSockSize = sizeof(client_addr);
  client_sock[0] = accept(hSocket,reinterpret_cast<sockaddr*>(&client_addr), &clientSockSize);
//I never get an exception thrown, and if I put a messagebox here
//it never comes up
  if (client_sock[numclients]==INVALID_SOCKET)
    throw NetErr("Could not accept incoming connection");
  numclients++;  
}

void Network::Send(const char* data)
{

  int bOptVal = strlen(data);
  int bOptLen = sizeof(int);
  setsockopt(hSocket,SOL_SOCKET, SO_SNDBUF, (char*)&bOptVal, bOptLen); 
  while(TRUE) {
        if (send(hSocket, data, strlen(data), 0) == SOCKET_ERROR) { //send the whole read buffer

            if (WSAGetLastError() != WSAEWOULDBLOCK) {
                
                  throw NetErr("Failed to send data.");
                
            }
            else {
                return; //we have filled the buffer, we will wait for another FD_WRITE...

            }
        }

}
}

 case FD_WRITE:
           try
            {
            netwkobj.Send("Some data");
            }
            catch (const NetErr& error)
            {
              MessageBox(NULL,error.what(),"Error!",MB_OK);
            }
            MessageBox(NULL,"Data sent","Completed",MB_OK);
          break;  
 case FD_READ:
          {
           //receiving data
           char tempbuf[TEMP_BUFFER_SIZE];           
           int bytes_recv = recv(wParam, tempbuf, sizeof(tempbuf), 0);
           
           MessageBox(NULL,tempbuf,"Received",MB_OK);
           break;
          }

           int bytes_recv = recv(wParam, tempbuf, sizeof(tempbuf) - 1, 0);
           
           if (bytes_recv >= 0) tempbuf[bytes_recv] = '\0';

           MessageBox(NULL,tempbuf,"Received",MB_OK);

void Network::Accept()
{
if (!init)
  throw NetErr("Network not initialized!");  
if (numclients>=MAX_CONNECTIONS)
  throw NetErr("Too many connections"); //figure out how to handle this better later  
  int clientSockSize = sizeof(client_addr);
  client_sock[numclients] = accept(hSocket,reinterpret_cast<sockaddr*>(&client_addr), &clientSockSize);
  if (WSAAsyncSelect(client_sock[numclients], chwnd, WM_WSAASYNC,  FD_CONNECT | FD_WRITE |
                                        FD_READ | FD_CLOSE)!=0) //set up asynchronous sockets
                            //request WRITE, READ, CONNECT, and CLOSE messages be sent
  {
    throw NetErr("WSAAsyncSelect() Failed!");
  }
  if (client_sock[numclients]==INVALID_SOCKET)
    throw NetErr("Could not accept incoming connection");
  numclients++; 
}

bool Network::Send(const char* data)
{
if (wait)
  return false; //can't send data right now...
if (send(hSocket, data, strlen(data), 0) == SOCKET_ERROR) { //send the whole read buffer

    if (WSAGetLastError() != WSAEWOULDBLOCK)
   {
      throw NetErr("Failed to send data.");
   }
   wait=true;  
}
return true;
}