// Copyright © 2010 sss
// 
// This program 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; either version 2
// of the License, or (at your option) any later version.
// 
// This program 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 this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

#include "commonheaders.h"


wstring new_key;
HANDLE new_key_hcnt = NULL;

int RecvMsgSvc(WPARAM w, LPARAM l)
{
	CCSDATA *ccs = (CCSDATA*)l;
	if (!ccs)
		return CallService(MS_PROTO_CHAINRECV, w, l);
	PROTORECVEVENT *pre = (PROTORECVEVENT*)(ccs->lParam);
	if (!pre)
		return CallService(MS_PROTO_CHAINRECV, w, l);
	char *msg = pre->szMessage;
	if (!msg)
		return CallService(MS_PROTO_CHAINRECV, w, l);
	BOOL unicode = (BOOL)(pre->flags&PREF_UNICODE);

	{ //check for gpg related data
		wchar_t *tmp = mir_utf8decodeW(msg);
		wstring str = tmp;
		mir_free(tmp);
		wstring::size_type s1 = wstring::npos, s2 = wstring::npos;

		if((str.find(_T("-----END PGP PUBLIC KEY BLOCK-----")) != wstring::npos) && (str.find(_T("-----BEGIN PGP PUBLIC KEY BLOCK-----")) != wstring::npos))
		{
			s2 = str.find(_T("-----END PGP PUBLIC KEY BLOCK-----"));
			s1 = str.find(_T("-----BEGIN PGP PUBLIC KEY BLOCK-----"));
		}
		else if((str.find(_T("-----BEGIN PGP PRIVATE KEY BLOCK-----")) != wstring::npos) && (str.find(_T("-----END PGP PRIVATE KEY BLOCK-----")) != wstring::npos))
		{
			s2 = str.find(_T("-----END PGP PRIVATE KEY BLOCK-----"));
			s1 = str.find(_T("-----BEGIN PGP PRIVATE KEY BLOCK-----"));
		}
		if((s2 != wstring::npos) && (s1 != wstring::npos))
		{  //this is public key
/*			if(!DBGetContactSettingByte(ccs->hContact, szGPGModuleName, "GPGEncryption", 0))
				; */
			void ShowNewKeyDialog();
			s1 = 0;
			while((s1 = str.find(_T("\r"), s1)) != wstring::npos)
			{
				str.erase(s1, 1);
			}
			if((str.find(_T("-----END PGP PUBLIC KEY BLOCK-----")) != wstring::npos) && (str.find(_T("-----BEGIN PGP PUBLIC KEY BLOCK-----")) != wstring::npos))
			{
				s2 = str.find(_T("-----END PGP PUBLIC KEY BLOCK-----"));
				s1 = str.find(_T("-----BEGIN PGP PUBLIC KEY BLOCK-----"));
				s2 += _tcslen(_T("-----END PGP PUBLIC KEY BLOCK-----"));
			}
			else if((str.find(_T("-----BEGIN PGP PRIVATE KEY BLOCK-----")) != wstring::npos) && (str.find(_T("-----END PGP PRIVATE KEY BLOCK-----")) != wstring::npos))
			{
				s2 = str.find(_T("-----END PGP PRIVATE KEY BLOCK-----"));
				s1 = str.find(_T("-----BEGIN PGP PRIVATE KEY BLOCK-----"));
				s2 += _tcslen(_T("-----END PGP PRIVATE KEY BLOCK-----"));
			}
			new_key.append(str.substr(s1,s2-s1));
			new_key_hcnt = ccs->hContact;
			ShowNewKeyDialog();
			return CallService(MS_PROTO_CHAINRECV, w, l);
		}
		s1 = str.find(_T("-----BEGIN PGP MESSAGE-----"));
		s2 = str.find(_T("-----END PGP MESSAGE-----"));
		if((s2 != wstring::npos) && (s1 != wstring::npos))
		{ //this is generic encrypted data block
			void setSrmmIcon(HANDLE);
			void setClistIcon(HANDLE);
			bool isContactHaveKey(HANDLE hContact);
			if(!DBGetContactSettingByte(ccs->hContact, szGPGModuleName, "GPGEncryption", 0))
			{
				if(MessageBox(0, _T("We received encrypted message from contact with encryption turned off.\nDo you want turn on encryption for this contact ?"), _T("Warning"), MB_YESNO) == IDYES)
				{
					if(!isContactHaveKey(ccs->hContact))
					{
						void ShowLoadPublicKeyDialog();
						extern map<int, HANDLE> user_data;
						extern int item_num;
						item_num = 0;		 //black magic here
						user_data[1] = ccs->hContact;
						ShowLoadPublicKeyDialog();
					}
					else
					{
						DBWriteContactSettingByte(ccs->hContact, szGPGModuleName, "GPGEncryption", 1);
						setSrmmIcon(ccs->hContact);
						setClistIcon(ccs->hContact);
					}
					if(isContactHaveKey(ccs->hContact))
					{
						DBWriteContactSettingByte(ccs->hContact, szGPGModuleName, "GPGEncryption", 1);
						setSrmmIcon(ccs->hContact);
						setClistIcon(ccs->hContact);
					}
				}
				else if(MessageBox(0, _T("Do you want try to decrypt encrypted message ?"), _T("Warning"), MB_YESNO) == IDNO)
					return CallService(MS_PROTO_CHAINRECV, w, l);
			}
			{
				wstring::size_type p = 0;
				while((p = str.find(_T("\r"), p)) != wstring::npos)
					str.erase(p, 1);
			}
			s2 += _tcslen(_T("-----END PGP MESSAGE-----"));
			char *tmp = mir_t2a(str.substr(s1,s2-s1).c_str());
			TCHAR *tmp2 = UniGetContactSettingUtf(NULL, szGPGModuleName, "szHomePath", _T(""));
			wstring path = tmp2;
			path.append(_T("\\encrypted_data.asc"));
			wfstream f(path.c_str(), std::ios::out);
			f<<tmp;
			mir_free(tmp);
			f.close();
			{
				extern TCHAR *password;
				string out;
				DWORD code;
				wstring cmd;
				cmd += _T("--batch ");
				{
					TCHAR *tmp = UniGetContactSettingUtf(NULL, szGPGModuleName, "szKeyPassword", _T(""));
					if(_tcslen(tmp) > 0)
					{
						cmd += _T("--passphrase \"");
						cmd += tmp;
						cmd += _T("\" ");
					}
					else if(password)
					{
						cmd += _T("--passphrase \"");
						cmd += password;
						cmd += _T("\" ");
					}
					mir_free(tmp);
				}
				cmd += _T("--output \"");
				cmd += tmp2;
				cmd += _T("\\decrypted_data\"");
				cmd += _T(" -d -a \"");
				cmd += path;
				cmd += _T("\"");
				gpg_execution_params params;
				pxResult result;
				params.cmd = &cmd;
				params.useless = "";
				params.out = &out;
				params.code = &code;
				params.result = &result;
				HANDLE gpg_thread = mir_forkthread(pxEexcute_thread, (void*)&params);
				if(WaitForSingleObject(gpg_thread, 10000) == WAIT_TIMEOUT)
				{
					TerminateThread(gpg_thread, 0);
					MessageBox(0, _T("GPG execution timed out, aborted"), _T(""), MB_OK);
				}
				if(result == pxNotFound)
				{
					MessageBox(0, _T("Set path to gpg.exe first!"), _T("Warning"), MB_OK);
					DeleteFile(path.c_str());
					return CallService(MS_PROTO_CHAINRECV, w, l);
				}
				while(out.find("public key decryption failed: bad passphrase") != string::npos)
				{
					void ShowLoadKeyPasswordWindow();
					ShowLoadKeyPasswordWindow();
					wstring cmd2 = cmd;
					if(password)
					{
						wstring tmp = _T("--passphrase \"");
						tmp += password;
						tmp += _T("\" ");
						cmd2.insert(0, tmp);
					}
					out.clear();
					gpg_execution_params params;
					pxResult result;
					params.cmd = &cmd2;
					params.useless = "";
					params.out = &out;
					params.code = &code;
					params.result = &result;
					HANDLE gpg_thread = mir_forkthread(pxEexcute_thread, (void*)&params);
					if(WaitForSingleObject(gpg_thread, 10000) == WAIT_TIMEOUT)
					{
						TerminateThread(gpg_thread, 0);
						MessageBox(0, _T("GPG execution timed out, aborted"), _T(""), MB_OK);
					}
					if(result == pxNotFound)
					{
						MessageBox(0, _T("Set path to gpg.exe first!"), _T("Warning"), MB_OK);				  
						DeleteFile(path.c_str());
						return CallService(MS_PROTO_CHAINRECV, w, l);
					}
				}
				out.clear();
				gpg_thread = mir_forkthread(pxEexcute_thread, (void*)&params);
				if(WaitForSingleObject(gpg_thread, 10000) == WAIT_TIMEOUT)
				{
					TerminateThread(gpg_thread, 0);
					MessageBox(0, _T("GPG execution timed out, aborted"), _T(""), MB_OK);
				}
				if(result == pxNotFound)
				{
					MessageBox(0, _T("Set path to gpg.exe first!"), _T("Warning"), MB_OK);				  
					DeleteFile(path.c_str());
					return CallService(MS_PROTO_CHAINRECV, w, l);
				}
				{
					wstring tmp = tmp2;
					tmp += _T("\\encrypted_data.asc");
					DeleteFile(tmp.c_str());
				}
				{
					wstring tmp = tmp2;
					tmp += _T("\\decrypted_data");
					if(_waccess(tmp.c_str(), 0) == -1)
					{
						if(errno == ENOENT)
						{
							string str = pre->szMessage;
							mir_free((void**)pre->szMessage);
							str.insert(0, "Failed to decrypt GPG encrypted message:\n");
							char *tmp = new char [str.length()+1];
							strcpy(tmp, str.c_str());
							pre->szMessage = tmp;
							return CallService(MS_PROTO_CHAINRECV, w, (LPARAM)ccs);
						}
					}
				}

				
				str.clear();
				{
					wstring path = tmp2;
					mir_free(tmp2);
					path += _T("\\decrypted_data");
					fstream f(path.c_str(), std::ios::in);
					while(!f.eof() && f.is_open())
					{
						char tmp[256];
						f.getline(tmp, 256);
						TCHAR *tmp2;
//						if(unicode)
							tmp2 = mir_utf8decodeW(tmp);
//						else
//							tmp2 = mir_a2t(tmp);
						str.append(tmp2).append(_T("\n"));
						mir_free(tmp2);
					}
					f.close();
					DeleteFile(path.c_str());
					str.erase(str.find_last_of(_T("\n")), 1);
					if(!str.length())
					{
						mir_free((void**)pre->szMessage);
						pre->szMessage = "Failed to decrypt GPG encrypted message";
						return CallService(MS_PROTO_CHAINRECV, w, (LPARAM)ccs);
					}
					else
					{
						mir_free((void**)pre->szMessage);
						if(bAppendTags)
						{
							str.insert(0, inopentag);
							str.append(inclosetag);
						}
						char *utf = mir_utf8encodeW(str.c_str());
						pre->szMessage = utf;
						return CallService(MS_PROTO_CHAINRECV, w, (LPARAM)ccs);
					}
				}
			}
		}
	}
	if(DBGetContactSettingByte(ccs->hContact, szGPGModuleName, "GPGEncryption", 0))
	{
		wchar_t *tmp = mir_utf8decodeW(msg);
		wstring str = tmp;
		mir_free(tmp);
		mir_free((void**)pre->szMessage);
		str.insert(0, _T("Received unencrypted message:\n"));
		char *utf = mir_utf8encodeW(str.c_str());
		pre->szMessage = utf;
		return CallService(MS_PROTO_CHAINRECV, w, (LPARAM)ccs);
	}
	return CallService(MS_PROTO_CHAINRECV, w, l);
}

int SendMsgSvc(WPARAM w, LPARAM l)
{
	CCSDATA *ccs = (CCSDATA*)l;
	if (!ccs)
		return CallService(MS_PROTO_CHAINSEND, w, l);
	if(!DBGetContactSettingByte(ccs->hContact, szGPGModuleName, "GPGEncryption", 0))
		return CallService(MS_PROTO_CHAINSEND, w, l);

	char *msg = (char*)(ccs->lParam);
	if (!msg)
		return CallService(MS_PROTO_CHAINSEND, w, l);
	BOOL unicode = (BOOL)(ccs->wParam&PREF_UNICODE);

	{ //encrypt data here
		wchar_t *tmp = mir_utf8decodeW(msg);
		wstring str = tmp;
		mir_free(tmp);
		{ //not xmpp, just replace whole message
			string out;
			DWORD code;
			wstring cmd;
			wstring path;
			extern bool bJabberAPI, bIsMiranda09;
			char *tmp = UniGetContactSettingUtf(ccs->hContact, szGPGModuleName, "KeyID", "");
			if(strlen(tmp) < 2)
			{
				mir_free(tmp);
				HistoryLog(ccs->hContact, "Failed to encrypt message with GPG", EVENTTYPE_MESSAGE, DBEF_SENT);
				return CallService(MS_PROTO_CHAINSEND, w, l);
			}
			if(!bJabberAPI || !bIsMiranda09)
				cmd += _T("--comment \"\" --no-version ");
			if(DBGetContactSettingByte(ccs->hContact, szGPGModuleName, "bAlwaysTrust", 0))
				cmd += _T("--trust-model always ");
			cmd += _T("--batch --yes -e -a -r ");
			TCHAR *tmp2 = mir_a2t(tmp);
			mir_free(tmp);
			cmd += tmp2;
			mir_free(tmp2);
			cmd += _T(" \"");
			tmp2 = UniGetContactSettingUtf(NULL, szGPGModuleName, "szHomePath", _T(""));
			path.append(tmp2);
			cmd += tmp2;
			mir_free(tmp2);
			cmd += _T("\\exported_data");
			path.append(_T("\\exported_data"));
			cmd += _T("\"");
			{
				char *tmp;
//				if(unicode)
					tmp = mir_utf8encodeW(str.c_str());
//				else
//					tmp = mir_t2a(str.c_str());
				wfstream f(path.c_str(), std::ios::out);
				f<<tmp;
				mir_free(tmp);
				f.close();
			}
			gpg_execution_params params;
			pxResult result;
			params.cmd = &cmd;
			params.useless = "";
			params.out = &out;
			params.code = &code;
			params.result = &result;
			HANDLE gpg_thread = mir_forkthread(pxEexcute_thread, (void*)&params);
			if(WaitForSingleObject(gpg_thread, 10000) == WAIT_TIMEOUT)
			{
				TerminateThread(gpg_thread, 0);
				MessageBox(0, _T("GPG execution timed out, aborted"), _T(""), MB_OK);
			}
			if(result == pxNotFound)
			{
				MessageBox(0, _T("Set path to gpg.exe first!"), _T("Warning"), MB_OK);
				return CallService(MS_PROTO_CHAINSEND, w, l);
			}
			if(out.find("There is no assurance this key belongs to the named user") != string::npos)
			{
				out.clear();
				if(MessageBox(0, _T("We trying to encrypt with untrusted key, do you want to trust this key permanently ?"), _T("Warning"), MB_YESNO) == IDYES)
				{
					DBWriteContactSettingByte(ccs->hContact, szGPGModuleName, "bAlwaysTrust", 1);
					cmd.insert(0, _T("--trust-model always "));
					gpg_execution_params params;
					pxResult result;
					params.cmd = &cmd;
					params.useless = "";
					params.out = &out;
					params.code = &code;
					params.result = &result;
					HANDLE gpg_thread = mir_forkthread(pxEexcute_thread, (void*)&params);
					if(WaitForSingleObject(gpg_thread, 10000) == WAIT_TIMEOUT)
					{
						TerminateThread(gpg_thread, 0);
						MessageBox(0, _T("GPG execution timed out, aborted"), _T(""), MB_OK);
					}
					if(result == pxNotFound)
					{
						MessageBox(0, _T("Set path to gpg.exe first!"), _T("Warning"), MB_OK);
						return CallService(MS_PROTO_CHAINSEND, w, l);
					}
				}
				else
					return 0;
			}
			DeleteFile(path.c_str());
			path.append(_T(".asc"));
			wfstream f(path.c_str(), std::ios::in);
			str.clear();
			while(!f.eof() && f.is_open())
			{
				TCHAR tmp[128];
				f.getline(tmp, 128);
				str.append(tmp);
				if(bJabberAPI && bIsMiranda09)
					str.append(_T("\n"));
				else
					str.append(_T("\r\n"));
			}
			f.close();
			DeleteFile(path.c_str());
			if(!str.length())
			{
				HistoryLog(ccs->hContact, "Failed to encrypt message with GPG", EVENTTYPE_MESSAGE, DBEF_SENT);
				return CallService(MS_PROTO_CHAINRECV, w, (LPARAM)ccs);
			}
			mir_free((void**)ccs->lParam);
			char *utf = mir_u2a(str.c_str());
			ccs->lParam = (LPARAM)utf;
			if(bAppendTags)
				DBWriteContactSettingByte(ccs->hContact, szGPGModuleName, "MsgsForTagging", DBGetContactSettingByte(ccs->hContact, szGPGModuleName, "MsgsForTagging", 0) + 1);
		}		
	}
	ccs->wParam&=~PREF_UNICODE;
	return CallService(MS_PROTO_CHAINSEND, w, l);
}

int HookSendMsg(WPARAM w, LPARAM l)
{
	HANDLE hContact = (HANDLE)w;
	if(!DBGetContactSettingByte(hContact, szGPGModuleName, "GPGEncryption", 0))
		return 0;

	if(bAppendTags)
	{
		if(!l)
			return 0;
		BYTE Msgs = DBGetContactSettingByte(hContact, szGPGModuleName, "MsgsForTagging", 0);
		if(!Msgs)
			return 0;
		DBEVENTINFO * dbei = (DBEVENTINFO*)l;
		if((dbei->eventType == EVENTTYPE_MESSAGE) && (dbei->flags & DBEF_SENT))
		{
			char *msg = (char*)dbei->pBlob;
			TCHAR *tmp = mir_utf8decodeW(msg);
			wstring str = tmp;
			mir_free(tmp);
			str.insert(0, outopentag);
			str.append(outclosetag);
			char *msg2 = mir_utf8encodeW(str.c_str());
			mir_free(dbei->pBlob);
			dbei->pBlob = (PBYTE)msg2;
			dbei->cbBlob = strlen(msg2)+1;
			DBWriteContactSettingByte(hContact, szGPGModuleName, "MsgsForTagging", Msgs - 1);
		}
	}
	return 0;
}

int TestHook(WPARAM w, LPARAM l)
{
	return 0;
}


static BOOL CALLBACK DlgProcKeyPassword(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
	TCHAR *tmp = NULL;
  switch (msg)
  {
  case WM_INITDIALOG:
    {
		TranslateDialogDefault(hwndDlg);
      return TRUE;
    }
    
 
  case WM_COMMAND:
    {
      switch (LOWORD(wParam))
      {
      case IDOK:
        {
			TCHAR tmp[64];
			GetDlgItemText(hwndDlg, IDC_KEY_PASSWORD, tmp, 64);
			if(_tcslen(tmp) > 0)
			{
				extern TCHAR *password;
				if(IsDlgButtonChecked(hwndDlg, IDC_SAVE_PASSWORD))
					DBWriteContactSettingTString(NULL, szGPGModuleName, "szKeyPassword", tmp);
				if(password)
					delete [] password;
				password = new TCHAR [_tcslen(tmp)+1];
				_tcscpy(password, tmp);
			}
			mir_free(tmp);
			DestroyWindow(hwndDlg);
          break;
        }
	  case IDCANCEL:
		  DestroyWindow(hwndDlg);
		  break;
	  default:
		break;
      }
      
      break;
    }
    
  case WM_NOTIFY:
    {
      switch (((LPNMHDR)lParam)->code)
      {
	  default:
		  break;
      }
	}
    break;
  case WM_CLOSE:
	  DestroyWindow(hwndDlg);
	  break;
  case WM_DESTROY:
	  break;

  }
  return FALSE;
}

void ShowLoadKeyPasswordWindow()
{
	extern HINSTANCE hInst;
	DialogBox(hInst, MAKEINTRESOURCE(IDD_KEY_PASSWD), NULL, DlgProcKeyPassword);
}