//-----------------------Includes
#include <winsock2.h>
#include <ws2tcpip.h>
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <iostream>
//-----------------------

#define MAXDATASIZE 100

//-----------------------MISC
#pragma comment(lib, "wsock32")
using namespace std;
//-----------------------

int main()
{
    SOCKET sock,client; //our sockets
	int numbytes;
	char buf[MAXDATASIZE];
    int size, ret, z; //size and return value integers
    SOCKADDR_IN addr,k; //our address to specify in <- we can get IP information from this struct
    WSAData dat; //winsock data
    WORD ver; // our version to use
    ver = MAKEWORD(2,0); //use winsock version 2.0
    int i = WSAStartup(ver,&dat);
    if (i!=0) // did we error
    {
        cout << "We fucked it up" << endl;
        WSACleanup(); //clean our asses up
        return 0; //bye bye
    }
    sock = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
    /*defined as: int socket(int af, int type, int proto);
    All of the parameters are integers because winsock
    already has the specific types of paremeters defined
    as integers.All exceptable types of the parameters
    will be listed below in the tables // // //
    we use the Internet address family
    the Streaming type of socket
    and the TCP/IP protocol as opposed to the UDP protocol
    UDP = user datagram protocol
    */
    addr.sin_addr.s_addr = INADDR_ANY; // here we will allow any incoming connections
    addr.sin_family = AF_INET; //once more our Internet af
    addr.sin_port = htons(8200); // htons is a winsock function to convert a short int to a port struct, either way 8200 is our port
    // there is another member of the struct present, and that is 'zero'. It is actaully unused in most all cases, including this one
    size = sizeof(addr); // the size of our addr struct
    ret = bind(sock,(SOCKADDR*)&addr,size); //bind our socket to port
    if (ret==SOCKET_ERROR)
    {
        cout << "Error Binding Socket to Port" << endl;
        WSACleanup(); //clean up winsock
        return 0; // die with the error
    }
    // if we got here than we succesfully binded and initialized our basic server
    // now lets begin our listening routine
    ret = listen(sock,10);
    // defined as: int listen(SOCKET s, int backlog);
    /* a little bit more to explain, not much though
     listen function begins the listening on our binded socket -sock -
     it will backlog 10 connections simulaineously
     what this means is that when somebody connects to our
     server, then it will keep waiting for another connection
     but it wont accept it until after our server is finished
     dealing with the first connection. The backlog serves as how many
     people you will keep waiting to connect to the server. After the number
     10 has been reached then it will start kicking off connection requests
     to the attempting clients.
     This method will only accept one connection at a time and is good in dealing
     with single user tasks, such as remote desktop management (such as in VCN and
     other RAT's), and other applications of the sort. What it isnt good for is
     being a full fledged server. This is becuase a self-contained server must
     accept a large quantity of connections at a single time, so it must multi-task.
     That will be covered in the next part of the winsock tutorial.
     */
    z = sizeof(k);
    while (1)
    { //easily done with for(;;) or an infinite jump command as well
        client = accept(sock,(SOCKADDR*)&k,&z);
		cout << "Connected" << endl;
		
		char msg[100];
			
			cout << "Send: "; //Ask for the sent message string
			cin >> msg;
			int len, bytes_sent; //length, and number of bytes sent
			len = strlen(msg); //length of string

			bytes_sent = send(client, msg, len, 0);
			if ((numbytes=recv(client, buf, MAXDATASIZE-1, 0)) == -1)
			{
				cout << "Error Recieving" << endl;
			}


			buf[numbytes] = '\0'; //The Buffer Variable
     		printf("Received: %s",buf);

        /* We will now accept our connections
        Notice we put the server on an infinite loop.
        This will come into play, more, in latter versions
        and more full fledged servers. As of now, it really
        doesnt matter, unless you are always trying to listen
        for a single connection no matter who it is.
        we are accepting on our listening socket (sock) and putting
        all connection information into SOCKADDR_IN k value.
        The k struct will allow us to obtain specific information about
        the client such as the IP address (mainly it is just the IP address
        but other functions in the winsock library will allow us to get
        more info from this struct).
        Our new socket is called client, and it contains the important info
        about the client, minus the IP.
        */

        /* Now that we have accepted the connection we will do our functions
        so (functions here) then we will exit)
        */
        closesocket(client);
        // this closes our client socket
        closesocket(sock);
        return 0;
        // this closes our listening socket
        // we are not totally disabled
        // and our server function has ended
        // how was that for a mucky first server?
    }
    //THIS POINT IS NEVER REACHED
}