// carddav.cpp - Main CardDAV Object file.
//
// (c) 2012-2015 Xestia Software Development.
//
// This file is part of Xestia Address Book.
//
// Xestia Address Book is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by the
// Free Software Foundation, version 3 of the license.
//
// Xestia Address Book is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with Xestia Address Book. If not, see <http://www.gnu.org/licenses/>

#include "carddav.h"
#include "../version.h"
#include <wx/wx.h>
#include <wx/tokenzr.h>
#include <wx/ffile.h>
#include <libxml/parser.h>
#include <libxml/tree.h>
#include <map>
#include <thread>
#include "../vcard/vcard.h"
#include "../common/dirs.h"

size_t WritebackFunc(char *ptr, size_t size, size_t nmemb, wxString *stream){
	
	wxString Data;
	Data = wxString::FromUTF8((char *)ptr);
	
	stream->Append(Data);
	
	return size * nmemb;

}

int ProgressFunc(void *clientdata, double TTDown, double NDown, double TTUp, double NUp){

	int ProgressRet;
	
	CardDAV *IncCardDAV = static_cast<CardDAV*>(clientdata);
	ProgressRet = IncCardDAV->ProgressFuncProc(clientdata, TTDown, NDown, TTUp, NUp);
	if (ProgressRet != 0){
		return 1;
	}
	return 0;

}

wxString CardDAV::ServerAddress;
int CardDAV::ServerPort;
wxString CardDAV::ServerUser;
wxString CardDAV::ServerPass;
wxString CardDAV::ServerPrefix;
wxString CardDAV::ServerAccount;
bool CardDAV::ServerSSL;
bool *CardDAV::ServerResult;
bool *CardDAV::ServerMonitor;
bool CardDAV::SSLStatus;
bool CardDAV::SSLVerified;
bool CardDAV::ValidResponse;
bool CardDAV::AuthPassed;
bool CardDAV::HasCalDAVSupport;
bool CardDAV::AbortConnection;
wxString CardDAV::ServerResponse;
wxString CardDAV::ServerMethod;
wxString CardDAV::ServerFilenameLocation;
wxString CardDAV::ServerUploadData;
wxString CardDAV::ETagData;
wxString CardDAV::ETagResult;
bool CardDAV::UploadMode;
bool CardDAV::EditMode;
long CardDAV::ItemIndex;
std::map<int, int> *CardDAV::ActivityListPtr;
char CardDAV::curlerrbuffer[CURL_ERROR_SIZE];
SSLCertCollection CardDAV::SSLCertCol;
int CardDAV::SSLErrorCode;
int CardDAV::ConnectionErrorCode;
wxString CardDAV::PageHeader;
wxString CardDAV::PageData;
CURLcode CardDAV::claconncode;
int CardDAV::HTTPErrorCode;
wxString CardDAV::ErrorMessage;
SSLCertCollection CardDAV::VerifyCertCollection;
bool CardDAV::AllowSelfSign;

CardDAV::CardDAV(){
	ServerPort = 8080;
	SSLStatus = FALSE;
	SSLVerified = FALSE;
	AuthPassed = FALSE;
	ValidResponse = FALSE;
	HasCalDAVSupport = FALSE;
	SSLCertCol.SuccessCode = 0;
	AllowSelfSign = FALSE;

	AbortConnection = FALSE;
	UploadMode = FALSE;
	EditMode = FALSE;
	HTTPErrorCode = 0;
}

CardDAV::~CardDAV(){

}

size_t UploadReadFunc(void *ptr, size_t size, size_t nmemb, void *userdata){

	struct UploadDataStruc *UploadPtr = (struct UploadDataStruc *)userdata;

	if (UploadPtr->sizeleft){

		//MeepMoop->sizeleft--;
		//return 1;

		UploadPtr->sizeleft--;
		wxString wxSChar;

		wxSChar = UploadPtr->readptr->Mid(UploadPtr->seek,1);

		//*(char *)ptr = (char)wxSChar.mb_str();

		strncpy((char *)ptr, (const char*)wxSChar.mb_str(wxConvUTF8), 1);

		UploadPtr->seek++;

		return 1;

	}

	return 0;

}

bool CardDAV::SetupConnection(wxString SvrAddress, int SvrPort, wxString SvrUser, wxString SvrPass, bool SvrSSL){

	ServerAddress = SvrAddress;
	ServerPort = SvrPort;
	ServerUser = SvrUser;
	ServerPass = SvrPass;
	ServerSSL = SvrSSL;
	
	return TRUE;

}

bool CardDAV::SetupConnection(wxString SvrAddress, int SvrPort, wxString SvrUser, wxString SvrPass, bool SvrSSL, wxString SvrPrefix, wxString SvrAccount){

	ServerAddress = SvrAddress;
	ServerPort = SvrPort;
	ServerUser = SvrUser;
	ServerPass = SvrPass;
	ServerSSL = SvrSSL;
	ServerPrefix = SvrPrefix;
	ServerAccount = SvrAccount;

	return TRUE;

}

bool CardDAV::SetupResultBools(bool *SvrResult, bool *SvrMonitor){

	ServerResult = SvrResult;
	ServerMonitor = SvrMonitor;

	return TRUE;

}

bool CardDAV::HasValidResponse(){

	return ValidResponse;

}

bool CardDAV::CanDoCardDAV(){

	return HasCalDAVSupport;

}

bool CardDAV::CanDoSSL(){

	return SSLStatus;

}

bool CardDAV::SSLVerify(){

	return SSLVerified;

}

bool CardDAV::AbleToLogin(){

	return AuthPassed;

}

bool CardDAV::IsSelfSigned(){

	return AllowSelfSign;

}

/*

size_t CardDAV::WritebackFunc(char *ptr, size_t size, size_t nmemb, FILE *stream){

	wxString Data;
	Data = wxString::FromUTF8((char *)ptr);
	if ((bool)stream == TRUE){
		PageHeader.Append(Data);
	} else {
		PageData.Append(Data);
	}
	return size * nmemb;

}

*/

int CardDAV::ProgressFuncProc(void *clientdata, double TTUp, double NUp, double TTDown, double NDown){

	if (AbortConnection == TRUE){
	
		return -1;
	
	} else {
	
		return 0;
	
	}

}

void CardDAV::Abort(){

	AbortConnection = TRUE;

}

SSLCertCollection CardDAV::GetSSLVerifyResults(){
	return VerifyCertCollection;
}

void CardDAV::AllowSelfSignTest(bool AllowSelfSignIn){
	AllowSelfSign = AllowSelfSignIn;
}

void CardDAV::GetSSLResults(){

	

}

void CardDAV::SetServerFilename(wxString Filename){

	ServerFilenameLocation = Filename;

}

wxString CardDAV::GetPageData()
{

	return PageData;

}

wxString CardDAV::ETagValueResult(){

	return ETagResult;

}

void CardDAV::SetupData(wxString Method, wxString FilenameLocation, wxString UploadData){

	ServerMethod = Method;
	ServerFilenameLocation = FilenameLocation;
	ServerUploadData = UploadData;

	// Check if ServerFilenameLocation has a / at 
	// the start and if not then append it.
	
	if (ServerFilenameLocation.Left(1) != wxT("/")){
	
		// Not there so insert.
		
		ServerFilenameLocation = wxT("/") + ServerFilenameLocation;
	
	}

}

void CardDAV::SetupVariables(std::map<int, int> *actlist, int actindex){

	ActivityListPtr = actlist;
	ItemIndex = actindex;

}

wxString CardDAV::GetETagData(){

	return ETagData;

}

void CardDAV::SetUploadMode(bool IncMode){

	UploadMode = IncMode;

}

void CardDAV::SetEditMode(bool EditModeInc){

	EditMode = EditModeInc;

}

int CardDAV::GetResultCode(){

	return (int)claconncode;

}

int CardDAV::GetHTTPCode(){

	return HTTPErrorCode;

}

wxString CardDAV::GetErrorBuffer(){

	wxString ErrorBuffer = wxString::FromUTF8(curlerrbuffer);

	return ErrorBuffer;

}

SSLCertCollection CardDAV::BuildSSLCollection(CURL *conn){

	SSLCertCollection SSLCertInfo;

	// Grab the certificate data.

	union {
		struct curl_slist *certdata;
		struct curl_certinfo *certinfo;
	} certptr;

	certptr.certdata = NULL;
	
	curl_easy_getinfo(conn, CURLINFO_CERTINFO, &certptr.certinfo);

	wxString CertPropName;
	wxString CertPropValue;

	for (int i = 0; i < certptr.certinfo->num_of_certs; i++){

		struct curl_slist *slist;
		SSLCertData SSLCertDataInc;
		
		for (slist = certptr.certinfo->certinfo[i]; slist; slist = slist->next){
			
			wxStringTokenizer CertDataInc(wxString::FromUTF8(slist->data), ":");
			
			// Get first token as the property name.
			
			CertPropName = CertDataInc.GetNextToken();
			
			// Get remaining tokens as the property value.
			
			while(CertDataInc.HasMoreTokens()){
			
				CertPropValue.Append(CertDataInc.GetNextToken());
			
			}
			
			SSLCertDataInc.CertData.insert(std::make_pair(CertPropName, CertPropValue));
			CertPropName.clear();
			CertPropValue.clear();
			
		}
	
		SSLCertInfo.SSLCollection.insert(std::make_pair(i, SSLCertDataInc));
	
	}
	
	return SSLCertInfo;

}

SSLCertCollection CardDAV::GetCertificateData(){

	// Pass on the collected certificate data.

	return SSLCertCol;

}

wxString CardDAV::GetErrorMessage(){

	return ErrorMessage;

}