// HttpClient.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <iostream>
#include <process.h>
using namespace std;

#define GET_METHOD				"GET %s HTTP/1.1\r\n"
#define HOST_SECTION			"Host: %s\r\n"
#define CONNECTION_SECTION		"Connection: keep-alive\r\n"
#define AUTH_SECTION			"Authorization: Basic %sz\r\n"
#define ACCECPT_SECTION			"Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8\r\n"
#define AGENT_SECTION			"User-Agent: Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/35.0.1916.153 Safari/537.36\r\n"
#define ENCODE_SECTION			"Accept-Encoding: gzip,deflate,sdch\r\n"
#define LANGUAGE_SECTION		"Accept-Language: en-US,en;q=0.8,zh-TW;q=0.6,zh;q=0.4\r\n\r\n"

HANDLE g_handle = NULL;

void Base64Encode (const char* s, char* dest)
{
	char * Code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
	char coded [5];
	int x;
	int y = strlen(s) - (strlen(s) % 3);

	// clear to NULL string
	*dest = 0;

	for(x = 0; x < y; x += 3)
	{
		/* Take the bottom six bits of the last byte, and the
		 * top six bits of the first byte.
		 */

		coded [3] = Code [s [x + 2] % 64];
		coded [0] = Code [s [x] >> 2];

		/* The second character requires the bottom two bits of
		 * the first byte and the top four bits of the second byte.
		 */

		coded [1] = (s [x] % 4) << 4;
		coded [1] += (s [x + 1] >> 4);
		coded [1] = Code [coded [1]];

		/* The third character requires the bottom four bits of
		 * the second byte and the top two bits of the third byte.
		 */

		coded [2] = (s [x + 1] % 16) << 2;
		coded [2] += (s [x + 2] / 64);
		coded [2] = Code [coded [2]];

		/* Zero terminate the string and append it to the result */

		coded [4] = 0;
		strcat (dest, coded);
	}

	x = y;

	if ((strlen (s) % 3) != 0)
	{
		/* The next blocks of code are if the length of the string is not
		 * a zero modulus of three.
		 */
		if ((strlen (s) % 3) == 1)
		{
			/* Pad the last two characters as equal signs */

			coded [2] = '=';
			coded [3] = '=';

			/* Character 1 is the same as above, character 2 uses only
		 	 * the bottom two bits of the only byte.
		 	 */

			coded [0] = Code [s [x] >> 2];
			coded [1] = Code [(s [x] % 4) << 4];

			/* Zero terminate the string and append it to the result,
			 * then retrn.
			 */

			coded [4] = 0;
			strcat (dest, coded);
		}
		else
		{
			/* Pad the last character with an equal sign */
			coded [3] = '=';

			/* First and second characters exactly as above */

			coded [0] = Code [s [x] >> 2];
			coded [1] = (s [x] % 4) << 4;
			coded [1] += (s [x + 1] >> 4);
			coded [1] = Code [coded [1]];

			/* Third character uses only the bottom four bits of the second byte */

			coded [2] = Code [(s [x + 1] % 16) << 2];

			/* Zero terminate, append to the result, and return */

			coded [4] = 0;
			strcat (dest, coded);
		}
	}
}
char* GetResponseMsg(char* receive_message)
{
	char *chString = NULL;
	chString = strstr(receive_message, "\r\n\r\n");

	if (chString)
	{
		chString = (chString+4);
	}
	return chString;
}

#define PTZ_PRESET_CGI				"/config/ptz_preset.cgi?name=%d&act=go"
#define PTZ_AUTOSCAN_CGI			"/config/ptz_autorun.cgi?name=scan"


enum PTZ_ACTION
{
	PTZ_PRESET = 0,
	PTZ_AUTOSCAN
};
struct PTZAuthenticate
{
	wstring		strIP;
	wstring		strUserName;
	wstring		strPassword;
	int			nPort;
	PTZ_ACTION	ptzAction;
	int			ptzPresetPoint;
};

void GetCGIString(const PTZAuthenticate& ptzAuthenticate, char* chValue)
{
	if (ptzAuthenticate.ptzAction == PTZ_PRESET)
	{
		sprintf(chValue, PTZ_PRESET_CGI, ptzAuthenticate.ptzPresetPoint);
	}
	else
	{
		sprintf(chValue, PTZ_AUTOSCAN_CGI);
	}
}


char* HttpClient()
{
	PTZAuthenticate	m_ptzAuthenticate;
	m_ptzAuthenticate.strIP = _T("10.1.21.110");
	m_ptzAuthenticate.nPort = 80;
	m_ptzAuthenticate.strUserName = _T("root");
	m_ptzAuthenticate.strPassword = _T("pass");
	m_ptzAuthenticate.ptzAction = PTZ_PRESET;
	m_ptzAuthenticate.ptzPresetPoint = 1;

	sockaddr_in webserver;
	int nResult = 0, sockfd = 0, addr_len = sizeof(sockaddr_in);
	char receive_message[1024] = {0};
	char chAuthEncode[30] = {0};
	char chIP[16] = {0};
	char chCGI[125] = {0};
	char chUserPass[125] = {0};

	int nPort = m_ptzAuthenticate.nPort;
	string str( m_ptzAuthenticate.strIP.begin(), m_ptzAuthenticate.strIP.end() );
	sprintf(chIP, str.c_str());

	GetCGIString(m_ptzAuthenticate, chCGI);
// 	if (m_ptzAuthenticate.ptzAction == PTZ_PRESET)
// 	{
// 		sprintf(chCGI, PTZ_PRESET_CGI, m_ptzAuthenticate.ptzPresetPoint);
// 	}
// 	else
// 	{
// 		sprintf(chCGI, PTZ_AUTOSCAN_CGI);
// 	}

	string strUser(m_ptzAuthenticate.strUserName.begin(),m_ptzAuthenticate.strUserName.end());
	string strPass(m_ptzAuthenticate.strPassword.begin(),m_ptzAuthenticate.strPassword.end());
	sprintf(chUserPass, "%s:%s",strUser.c_str(), strPass.c_str());
	Base64Encode(chUserPass, chAuthEncode);

	sockfd = socket(AF_INET,SOCK_STREAM,0);
	webserver.sin_family=AF_INET;
	webserver.sin_port=htons(nPort);
	webserver.sin_addr.s_addr=inet_addr(chIP);

	char chCGIString[1024] = {0};
	sprintf(chCGIString, GET_METHOD, chCGI);

	char chIPString[1024] = {0};
	sprintf(chIPString, HOST_SECTION, chIP);

	char chAuthString[1024] = {0};
	sprintf(chAuthString, AUTH_SECTION, chAuthEncode);

	char send_message[1024] = {0};
	sprintf(send_message,"%s%s%s%s%s%s%s%s",
		chCGIString,
		chIPString,
		CONNECTION_SECTION,
		chAuthString,
		ACCECPT_SECTION,
		AGENT_SECTION,
		ENCODE_SECTION,
		LANGUAGE_SECTION);

	nResult = connect(sockfd,(sockaddr*)(&webserver),sizeof(sockaddr));
	nResult = send(sockfd,send_message,sizeof(send_message), 0);
	nResult = recvfrom(sockfd, receive_message,sizeof(receive_message), 0 , (sockaddr*)&webserver ,&addr_len);
	closesocket(sockfd);
	return GetResponseMsg(receive_message);

	/*sockaddr_in webserver;
	int nResult = 0, sockfd = 0, addr_len = sizeof(sockaddr_in);
	char receive_message[1024] = {0};
	char chAuthEncode[30] = {0};

	int nPort = 80;
	char chIP[] = "10.1.21.64";
	char chCGI[] = "/config/stream_info.cgi";
	Base64Encode("root:pass", chAuthEncode);

	sockfd = socket(AF_INET,SOCK_STREAM,0);
	webserver.sin_family=AF_INET;
	webserver.sin_port=htons(nPort);
	webserver.sin_addr.s_addr=inet_addr(chIP);

	char chCGIString[1024] = {0};
	sprintf(chCGIString, GET_METHOD, chCGI);

	char chIPString[1024] = {0};
	sprintf(chIPString, HOST_SECTION, chIP);

	char chAuthString[1024] = {0};
	sprintf(chAuthString, AUTH_SECTION, chAuthEncode);

	char send_message[1024] = {0};
	sprintf(send_message,"%s%s%s%s%s%s%s%s",
		chCGIString,
		chIPString,
		CONNECTION_SECTION,
		chAuthString,
		ACCECPT_SECTION,
		AGENT_SECTION,
		ENCODE_SECTION,
		LANGUAGE_SECTION);

	nResult = connect(sockfd,(sockaddr*)(&webserver),sizeof(sockaddr));
	nResult = send(sockfd,send_message,sizeof(send_message), 0);
	nResult = recvfrom(sockfd, receive_message,sizeof(receive_message), 0 , (sockaddr*)&webserver ,&addr_len);
	closesocket(sockfd);
	return GetResponseMsg(receive_message);*/
}

void SendENCPBroadcast()
{
	sockaddr_in ENCPserver;
	int nResult = 0, sockfd = 0;
	char receive_message[1024] = {0};

	sockfd = socket(AF_INET,SOCK_DGRAM,0);
	ENCPserver.sin_family=AF_INET;
	ENCPserver.sin_port=htons(32154);
	ENCPserver.sin_addr.s_addr=inet_addr("255.255.255.255");

	char send_message[12] = 
	{
		0x41, 0x44, 0x43, 0x54, 0x05, 0x0c, 0x00, 0x03, 
		0xff, 0xe0, 0x00, 0x00
	};

	int bcast = 1;
	nResult = setsockopt(sockfd, SOL_SOCKET, SO_BROADCAST, (char *)&bcast, sizeof(bcast));
	nResult = sendto(sockfd,send_message,sizeof(send_message),0,(struct sockaddr *)(&ENCPserver),sizeof(struct sockaddr));
	//nResult = connect(sockfd,(struct sockaddr *)(&ENCPserver),sizeof(struct sockaddr));
	//nResult = send(sockfd,send_message,sizeof(send_message), 0);
	closesocket(sockfd);
}

void UnpackMsg(sockaddr_in& localserver, char *preceive_message)
{
	char *pAddr = inet_ntoa(localserver.sin_addr);

	unsigned char mac[6] = {0};
	memcpy(mac, (preceive_message+9), 6);

	char ip[16] = {0};

	memcpy(ip, pAddr, 16);
	printf("%s\t %02x-%02x-%02x-%02x-%02x-%02x\n", ip, 
		 mac[0],mac[1],mac[2],mac[3],mac[4],mac[5]);

	

	char model[125] = {0};
	preceive_message+17;
}

void ENCPBroadcast()
{
	sockaddr_in localserver;
	int nResult = 0;
	int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
	char receive_message[1024] = {0};
	int addr_len = sizeof(sockaddr_in);

	localserver.sin_family=AF_INET;
	localserver.sin_port=htons(32153);
	localserver.sin_addr.s_addr=INADDR_ANY;

	nResult = bind(sockfd,(sockaddr*)&localserver,sizeof(localserver));
	SendENCPBroadcast();

	fd_set fd;
	timeval tv;
	tv.tv_sec = 5;
	tv.tv_usec = 0;
	FD_ZERO(&fd);
	FD_SET(sockfd,&fd);
	
	while(1)
	{
		nResult = select(sockfd,&fd,NULL,NULL,&tv);
		if (nResult != -1)
		{
			if (FD_ISSET(sockfd,&fd))
			{
				nResult = recvfrom(sockfd, receive_message,sizeof(receive_message), 0 , (sockaddr*)&localserver ,&addr_len);
				UnpackMsg(localserver, receive_message);
			}
			else
			{	
				break;
			}
		}
		else
		{
			break;
		}
	}
	closesocket(sockfd);
}

int _tmain(int argc, _TCHAR* argv[])
{
	if (!AfxSocketInit())
	{
		return FALSE;
	}
	
	//char chMsg[1024] = {0};
	//memcpy(chMsg, HttpClient(), 1024);
	//ENCPBroadcast();
	//printf("%s", chMsg);

	HttpClient();

	int a = 0;
	cin>>a;
	return 0;
}