#pragma once

#include <string>
#include <map>
#include <queue>
#include <pcap.h>
#include <windows.h>
#include <Winsock2.h>
#include "NetworkObjects.h"


#pragma comment(lib, "wpcap.lib")
#pragma comment(lib, "packet.lib")
#pragma comment(lib, "Ws2_32.lib")
#pragma comment(lib, "kernel32.lib")

class C_Sniffer
{
public:
	C_Sniffer(void);
	~C_Sniffer(void);
	
	bool Start();
	bool Stop();
	bool IsRunning();


protected:
	typedef struct _S_ThreadArgs
	{
		pcap_t *m_Handle;
		bool m_Running;
		C_Sniffer* m_Instance;
	} S_ThreadArgs;

	typedef struct _S_WinPcapPacket
	{
	public:
		_S_WinPcapPacket(const pcap_pkthdr* header, const unsigned char* data)
		{
			
			this->data = (unsigned char*)malloc(header->len);
			if(this->data == NULL)
			{
				memset(&this->header,0,sizeof(this->header));
				return;
			}

			memcpy(&this->header,header,sizeof(this->header));
			memcpy(this->data,data,header->len);
			
		}
		_S_WinPcapPacket(const _S_WinPcapPacket& right)
		{
			
			this->data = (unsigned char*)malloc(right.header.len);
			if(this->data == NULL)
			{
				memset(&this->header,0,sizeof(this->header));
				return;
			}

			memcpy(&this->header,&right.header,sizeof(this->header));
			memcpy(this->data,right.data,right.header.len);
		}
		
		struct pcap_pkthdr header;
		u_char* data;

	} S_WinPcapPacket;

	static void Callback(u_char *param, const struct pcap_pkthdr *header, const u_char *pkt_data);
	static DWORD WINAPI ThreadCapturingProc( LPVOID lpParam );
	static DWORD WINAPI ThreadProcessingProc( LPVOID lpParam );
	

protected:
	typedef std::map<long, std::string> T_ResolveMap;
	typedef std::pair<long, std::string> T_ResolvePair;

	T_ResolveMap m_IpResolver;

	static std::queue<S_WinPcapPacket> m_Packets;
	static CRITICAL_SECTION m_PacketsSection;

	S_ThreadArgs m_CapturingArgs;
	S_ThreadArgs m_ProcessingArgs;
	
	bool m_ThreadCapturingRunning;
	bool m_ThreadProcessingRunning;
	
	HANDLE m_ThreadCapturing;
	DWORD m_ThreadCapturingId;

	HANDLE m_ThreadProcessing;
	DWORD m_ThreadProcessingId;
};