// Plugin Template
//

#include "stdafx.h"
#include "PluginInterface.h"
#include "AboutDialog.h"
#include "MenuManager.h"

#include "Scintilla.h"
#include "WcharMbcsConverter.h"
#include "PythonHandler.h"
#include "PythonConsole.h"
#include "ShortcutDlg.h"
#include "Notepad_plus_msgs.h"
#include "HelpController.h"
#include "PythonScript/NppPythonScript.h"
#include "ReplacementContainer.h"
#include "GILManager.h"
#include "MainThread.h"
#include "ScintillaCallbackCounter.h"
#include "MutexHolder.h"

#define CHECK_INITIALISED()  if (!g_initialised) initialisePython()

/* Info for Notepad++ */
static FuncItem	*funcItem = NULL;

/* Global data */
static NppData		nppData;
static HANDLE		g_hModule = NULL;

/* Dialogs */
static AboutDialog		aboutDlg;
static ShortcutDlg     *g_shortcutDlg = NULL;

static boost::shared_ptr<NppPythonScript::PythonConsole> g_console(NULL);
static bool g_bToggleConsoleFlag = false;

// Paths
static char  g_pluginDir[MAX_PATH];
static char  g_configDir[MAX_PATH];
static TCHAR g_tPluginDir[MAX_PATH];
static TCHAR g_tConfigDir[MAX_PATH];
static tstring g_previousScript;

static bool g_infoSet = false;
static bool g_initialised = false;
static bool previousScript_clicked = false;

// Scripts on the menu
static std::vector<std::string*> g_menuScripts;

// Scripts on the toolbar
static std::vector< std::pair<std::string*, HICON>* > g_toolbarScripts;



static void doAbout();

static void newScript();
static void toggleConsole();
static void showShortcutDlg();
static void stopScript();
static void runScript(idx_t number);
static void runScript(const TCHAR *script, bool synchronous, HANDLE completedEvent = NULL, bool allowQueuing = false);
static void runStatement(const TCHAR *statement, bool synchronous, HANDLE completedEvent = NULL, bool allowQueuing = false);
static void shutdown(void *);
static void doHelp();
static void previousScript();

static FuncItem* getGeneratedFuncItemArray(int *nbF);

// Run script functions




// Main python handler/wrapper
static NppPythonScript::PythonHandler *pythonHandler;

BOOL APIENTRY DllMain( HMODULE hModule,
					   DWORD  ul_reason_for_call,
					   LPVOID /* lpReserved */
					 )
{
	g_hModule = hModule;
	switch (ul_reason_for_call)
	{
	case DLL_PROCESS_ATTACH:
		  break;

	case DLL_THREAD_ATTACH:
		break;

	case DLL_THREAD_DETACH:
		break;

	case DLL_PROCESS_DETACH:
		break;

	NO_DEFAULT_CASE;
	}
	return TRUE;
}



extern "C" __declspec(dllexport) void setInfo(NppData notepadPlusData)
{
	nppData = notepadPlusData;
#ifdef DEBUG_STARTUP
	MessageBox(NULL, _T("setInfo"), PLUGIN_NAME, 0);
#endif


	// Get the two key directories (plugins config and the Npp dir)
	::SendMessage(nppData._nppHandle, NPPM_GETPLUGINSCONFIGDIR, MAX_PATH, reinterpret_cast<LPARAM>(g_tConfigDir));
	strcpy_s(g_configDir, MAX_PATH, WcharMbcsConverter::tchar2char(g_tConfigDir).get());

	::SendMessage(nppData._nppHandle, NPPM_GETNPPDIRECTORY, MAX_PATH, reinterpret_cast<LPARAM>(g_tPluginDir));
	_tcscat_s(g_tPluginDir, MAX_PATH, _T("\\plugins"));
	strcpy_s(g_pluginDir, MAX_PATH, WcharMbcsConverter::tchar2char(g_tPluginDir).get());


	ConfigFile::create(g_tConfigDir, g_tPluginDir, reinterpret_cast<HINSTANCE>(g_hModule));
	MenuManager::create(nppData._nppHandle, reinterpret_cast<HINSTANCE>(g_hModule), runScript);
	g_infoSet = true;
}

extern "C" __declspec(dllexport) CONST TCHAR * getName()
{
	return PLUGIN_NAME;
}

extern "C" __declspec(dllexport) FuncItem * getFuncsArray(int *nbF)
{

	if (g_infoSet)
	{
#ifdef DEBUG_STARTUP
		MessageBox(NULL, _T("Python GetFuncsArray"), PLUGIN_NAME, 0);
#endif

		funcItem = getGeneratedFuncItemArray(nbF);
	}
	else
	{
		MessageBox(NULL, _T("A fatal error has occurred. Notepad++ has incorrectly called getFuncsArray() before setInfo().  No menu items will be available for PythonScript."), PLUGIN_NAME, 0);
		funcItem = (FuncItem*) malloc(sizeof(FuncItem));
		if(funcItem)
		{
			memset(funcItem, 0, sizeof(FuncItem));
			_tcscpy_s(funcItem[0]._itemName, 64, _T("About - Python Script Disabled"));
			funcItem[0]._pFunc = doAbout;
		}
		*nbF = 1;
	}

	return funcItem;
}

static FuncItem* getGeneratedFuncItemArray(int *nbF)
{

	MenuManager* menuManager = MenuManager::getInstance();

	MenuManager::ItemVectorTD items;
	items.reserve(8);
	idx_t stopScriptIndex;
	idx_t dynamicStartIndex;
	idx_t scriptsMenuIndex;
	idx_t runPreviousIndex;

	items.push_back(std::pair<tstring, void(*)()>(_T("New Script"), newScript));
	items.push_back(std::pair<tstring, void(*)()>(_T("Show Console"), toggleConsole));

	items.push_back(std::pair<tstring, void(*)()>(_T("--"), reinterpret_cast<void(*)()>(NULL)));

	items.push_back(std::pair<tstring, void(*)()>(_T("Stop Script"), stopScript));
	stopScriptIndex = items.size() - 1;

	items.push_back(std::pair<tstring, void(*)()>(_T("--"), reinterpret_cast<void(*)()>(NULL)));



	items.push_back(std::pair<tstring, void(*)()>(_T("Run Previous Script"), previousScript));
	runPreviousIndex = items.size() - 1;

	items.push_back(std::pair<tstring, void(*)()>(_T("--"), reinterpret_cast<void(*)()>(NULL)));
	scriptsMenuIndex = items.size() - 1;



	items.push_back(std::pair<tstring, void(*)()>(_T("Configuration..."), showShortcutDlg));
	// Add dynamic scripts above the Configuration option - an extra separator will automatically
	// be added to the end of the list, if there are items in the dynamic menu
	dynamicStartIndex = items.size() - 1;

	items.push_back(std::pair<tstring, void(*)()>(_T("--"), reinterpret_cast<void(*)()>(NULL)));
	items.push_back(std::pair<tstring, void(*)()>(_T("Context-Help"), doHelp));
	items.push_back(std::pair<tstring, void(*)()>(_T("About"), doAbout));



	FuncItem* funcItems = menuManager->getFuncItemArray(nbF, items, runScript, dynamicStartIndex, scriptsMenuIndex, stopScriptIndex, runPreviousIndex);


	return funcItems;

}


static void initialise()
{
    g_mainThreadID = ::GetCurrentThreadId();
	g_console.reset(new NppPythonScript::PythonConsole(nppData._nppHandle));

	pythonHandler = new NppPythonScript::PythonHandler(g_tPluginDir, g_tConfigDir, (HINSTANCE)g_hModule, nppData._nppHandle, nppData._scintillaMainHandle, nppData._scintillaSecondHandle, g_console);

	aboutDlg.initDialog((HINSTANCE)g_hModule, nppData);

	g_shortcutDlg = new ShortcutDlg((HINSTANCE)g_hModule, nppData, _T("\\PythonScript\\scripts"));


	g_console->init((HINSTANCE)g_hModule, nppData);



	MenuManager* menuManager = MenuManager::getInstance();
	//menuManager->idsInitialised();
	menuManager->populateScriptsMenu();
	menuManager->stopScriptEnabled(false);
	menuManager->initPreviousScript();



}

static void initialisePython()
{
	g_initialised = true;
	DWORD startTicks = GetTickCount();

    DEBUG_TRACE_S(("starting python at %ld", startTicks));

	pythonHandler->initPython();

	g_console->initPython(pythonHandler);

	pythonHandler->runStartupScripts();


	DWORD endTicks = GetTickCount();
	g_console->message("Python ");
	g_console->message(Py_GetVersion());

	char result[200];

	sprintf_s(result, 200, "\nInitialisation took %ldms\nReady.\n", endTicks-startTicks);
	g_console->message(result);

}

static void registerToolbarIcons()
{
#ifdef DEBUG_STARTUP
	MessageBox(NULL, _T("Register toolbar icons"), PLUGIN_NAME, 0);
#endif
	MenuManager* menuManager = MenuManager::getInstance();
	menuManager->idsInitialised();
	menuManager->configureToolbarIcons();
}

extern "C" __declspec(dllexport) void beNotified(SCNotification *notifyCode)
{
	/* This switch is split into two
	 * 1. Notifications that must be run BEFORE any registered Python callbacks, and
	 * 2. Notifications that must be run AFTER any registered Python callbacks
	 */

	// Note: The callback isn't actually complete until after this method returns, and
    // scintilla has finished through it's iterator of watchers. However, under "normal" circumstances, this stops a synchronous
	// callback from calling a function that changes the watchers on the internal Scintilla document.
	// Async callbacks aren't an issue, as they may call into scintilla whilst a callback is ongoing, but as scintilla is running
    // on a single thread, it waits until the callback code is complete for continuing (ie. processing the next message in the message loop).

    NppPythonScript::DepthLevel callbackCount;
    if (notifyCode->nmhdr.code >= SCN_FIRST_NOTIFICATION)
	{
        callbackCount = NppPythonScript::ScintillaCallbackCounter::inCallback();
	}


	switch(notifyCode->nmhdr.code)
	{
		case NPPN_READY:
			{
#ifdef DEBUG_STARTUP
				MessageBox(NULL, _T("NPPN_READY"), PLUGIN_NAME, 0);
#endif
				initialise();

				if (g_bToggleConsoleFlag)
					toggleConsole(); // fix possible missing PS console (Notepad++ DockingManager-init calls the PS toggleConsole() published func before the PS init...)

				ConfigFile *config = ConfigFile::getInstance();
				if (config->getSetting(_T("STARTUP")) == _T("ATSTARTUP"))
				{
					CHECK_INITIALISED();
				}
			}
			break;

		case NPPN_FILESAVED:
			{
				TCHAR filename[MAX_PATH]{};
				::SendMessage(nppData._nppHandle, NPPM_GETFULLPATHFROMBUFFERID, notifyCode->nmhdr.idFrom, reinterpret_cast<LPARAM>(filename));
				ConfigFile *configFile = ConfigFile::getInstance();
				const tstring machineScripts = configFile->getMachineScriptsDir().c_str();
				const tstring userScripts = configFile->getUserScriptsDir().c_str();

				if (_tcsnicmp(filename, machineScripts.c_str(), machineScripts.size()) == 0
					|| _tcsnicmp(filename, userScripts.c_str(), userScripts.size()) == 0)
				{
					MenuManager::getInstance()->refreshScriptsMenu();
				}
			}
			break;

		case NPPN_TBMODIFICATION:
			registerToolbarIcons();
			break;

		case NPPN_SHORTCUTREMAPPED:
			{
				MenuManager *menuManager = MenuManager::getInstance();
				menuManager->updateShortcut(notifyCode->nmhdr.idFrom, reinterpret_cast<ShortcutKey*>(notifyCode->nmhdr.hwndFrom));
			}
			break;

		default:
			// Other messages can just be ignored
			break;

	}

	// Notify the scripts
	if (pythonHandler)
		pythonHandler->notify(notifyCode);

	// Post notifications handlers
	switch(notifyCode->nmhdr.code)
	{
		case NPPN_SHUTDOWN:
			{
				DWORD shutdownThreadID;
				CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)shutdown, NULL, NULL, &shutdownThreadID);
			}
			break;
		default:
			// Ignore all other messages
			break;
	}

}



extern "C" __declspec(dllexport) LRESULT messageProc(UINT message, WPARAM wParam, LPARAM lParam)
{
	switch(message)
	{
		case NPPM_MSGTOPLUGIN:
			{

				CommunicationInfo* ci = reinterpret_cast<CommunicationInfo*>(lParam);
				switch(ci->internalMsg)
				{
					case PYSCR_EXECSCRIPT:
					case PYSCR_EXECSTATEMENT:
					{
						CHECK_INITIALISED();
						PythonScript_Exec* pse = reinterpret_cast<PythonScript_Exec*>(ci->info);
						if (pse->structVersion != 1)
						{
							return TRUE;
						}

						std::shared_ptr<TCHAR> script = WcharMbcsConverter::tchar2tchar(pse->script);

						bool synchronous = (pse->flags & PYSCRF_SYNC) == PYSCRF_SYNC;

						if (PYSCR_EXECSCRIPT == ci->internalMsg)
						{
							runScript(script.get(), synchronous, pse->completedEvent, true);
						}
						else
						{
							runStatement(script.get(), synchronous, pse->completedEvent, true);
						}

						pse->deliverySuccess = TRUE;

						return FALSE;
					}

					case PYSCR_SHOWCONSOLE:
						if (g_console)
						{
							g_console->showDialog();
						}
						return FALSE;

					case PYSCR_RUNREPLACE:
						{
                            NppPythonScript::ReplacementContainer *replacementContainer = reinterpret_cast<NppPythonScript::ReplacementContainer*>(ci->info);
                            replacementContainer->runReplacements();
                            return FALSE;
						}
					default:
						// Other messages are unknown, hence ignore
						break;
				}
			}
			break;

		case WM_COMMAND:
			MenuManager::getInstance()->processWmCommand(wParam, lParam);
			break;

		default:
			// Other messages can just be ignored
			break;

	}
	return TRUE;
}


#ifdef _UNICODE
extern "C" __declspec(dllexport) BOOL isUnicode()
{
	return TRUE;
}
#endif


static void doAbout()
{
	aboutDlg.doDialog();
}





static void stopScript()
{
	if (pythonHandler)
	{
		pythonHandler->stopScript();
	}
}


static bool shortcutKeyHasCtrl(idx_t number)
{
	bool retVal = false;
	idx_t cmdID = MenuManager::getInstance()->getOriginalCommandID(number);
	if (cmdID)
	{
		ShortcutKey key;
		BOOL hasShortcut = ::SendMessage(nppData._nppHandle, NPPM_GETSHORTCUTBYCMDID, cmdID, reinterpret_cast<LPARAM>(&key));
		if (hasShortcut && 0 != key._key && key._isCtrl && !key._isAlt && !key._isShift)
		{
			retVal = true;
		}
	}
	return retVal;
}


static void runScript(idx_t number)
{
	/*  If the shortcut for the given script number does not have a control in it,
	 *  (or no shortcut key is assigned), then we can pretend the user clicked the menu option.
	 *  runScript() will then check if Ctrl is held down, if it is, it will edit the script.
	 *  Obviously if this menu item's key DOES have Ctrl in it, (and we're on N++ 5.8 or upwards)
	 *  then we can't tell the difference (as we haven't subclassed N++).
	 *  If that's the case, then ctrl-click won't work.  That's just tough, I think.
	 */
	if (!shortcutKeyHasCtrl(number))
	{
		MenuManager::s_menuItemClicked = true;
	}

	runScript(ConfigFile::getInstance()->getMenuScript(number).c_str(), false);
}




static void runStatement(const TCHAR *statement, bool synchronous, HANDLE completedEvent /* = NULL */, bool allowQueuing /* = false */)
{
	CHECK_INITIALISED();
	MenuManager::getInstance()->stopScriptEnabled(true);
	if (!pythonHandler->runScript(statement, synchronous, allowQueuing, completedEvent, true))
	{
		if (ConfigFile::getInstance()->getSetting(_T("DISABLEPOPUPWARNING")) == _T("0"))
		{
			MessageBox(NULL, _T("Another script is currently running.  Running two scripts at the same time could produce unpredicable results, and is therefore disabled."), PLUGIN_NAME, 0);
		}	
	}

}

static void updatePreviousScript(const TCHAR *filename)
{
	if (g_previousScript == filename)
		return;

	g_previousScript = filename;

	MenuManager *menuManager = MenuManager::getInstance();
	menuManager->updatePreviousScript(filename);
}

static void runScript(const TCHAR *filename, bool synchronous, HANDLE completedEvent /* = NULL */, bool allowQueuing /* = false */)
{

	BYTE keyState[256];

	// If the filename is empty, then just ignore it
	if (!filename || (*filename) == _T('\0'))
	{
		// Reset the menuItemClicked, just in case (highly unlikely, but still)
		MenuManager::s_menuItemClicked = false;
		return;
	}

	::GetKeyboardState(keyState);

	// If a menu item was clicked (or assumed to be, see runScript(int))
	// and either control held down, and shift + alt are not, then edit the file
	if ((MenuManager::s_menuItemClicked || previousScript_clicked)
		&& (keyState[VK_CONTROL] & 0x80)
		&& ((keyState[VK_SHIFT] & 0x80) == 0)
		&& ((keyState[VK_MENU] & 0x80) == 0))
	{
		if (!SendMessage(nppData._nppHandle, NPPM_SWITCHTOFILE, 0, reinterpret_cast<LPARAM>(WcharMbcsConverter::tchar2tchar(filename).get())))
		{
			SendMessage(nppData._nppHandle, NPPM_DOOPEN, 0, reinterpret_cast<LPARAM>(WcharMbcsConverter::tchar2tchar(filename).get()));
		}
	}
	else
	{
		CHECK_INITIALISED();
		MenuManager::getInstance()->stopScriptEnabled(true);

		// TODO: Really need to not change this if it's a MSGTOPLUGIN run
		updatePreviousScript(filename);

		if (!pythonHandler->runScript(filename, synchronous, allowQueuing, completedEvent))
		{
			if (ConfigFile::getInstance()->getSetting(_T("DISABLEPOPUPWARNING")) == _T("0"))
			{
				MessageBox(NULL, _T("Another script is currently running.  Running two scripts at the same time could produce unpredicable results, and is therefore disabled."), PLUGIN_NAME, 0);
			}
		}
	}

	MenuManager::s_menuItemClicked = false;

}

static void showShortcutDlg()
{
	if (g_shortcutDlg)
	{
		g_shortcutDlg->doDialog();
	}
}

static void toggleConsole()
{
	if (g_console)
	{
		CHECK_INITIALISED();
		if (MenuManager::getInstance()->s_menuItemConsoleChecked)
		{
			g_console->hideDialog();
			g_bToggleConsoleFlag = false; // this is not necessary but maybe for a future use...
		}
		else
		{
			g_console->showDialog();
			g_bToggleConsoleFlag = true; // this is not necessary but maybe for a future use...
		}
	}
	else
	{
		// track the PS console showing/hiding requests even without the full PS initialization
		// - this fixes the Notepad++ DockingManager-init as it calls this func even before the PS plugin full init at its NPPN_READY
		g_bToggleConsoleFlag = !g_bToggleConsoleFlag;
	}
}

static void ensurePathExists(const tstring& path)
{
	BOOL created = FALSE;
	tstring createPath(path);
	if (!::CreateDirectory(createPath.c_str(), NULL))
	{
		std::list<tstring> pathsToCreate;

		// Add the deepest directory to the top of the list, so it will be created last
		pathsToCreate.push_back(createPath);

		do {

			createPath.erase(createPath.find_last_of(_T('\\')));
			if (!::CreateDirectory(createPath.c_str(), NULL))
			{
				pathsToCreate.push_back(createPath);
			}
			else
			{
				created = TRUE;
			}

		} while (createPath.find(_T('\\')) != tstring::npos
			&& !created);

		if (created)
		{
			for(std::list<tstring>::reverse_iterator iter = pathsToCreate.rbegin(); iter != pathsToCreate.rend(); iter++)
			{
				::CreateDirectory(iter->c_str(), NULL);
			}
		}
	}
	else
	{
		created = TRUE;
	}
}

static void newScript()
{

	OPENFILENAME ofn;
	memset(&ofn, 0, sizeof(OPENFILENAME));

	ofn.lStructSize = sizeof(OPENFILENAME);
	ofn.hwndOwner = nppData._nppHandle;
	ensurePathExists(ConfigFile::getInstance()->getUserScriptsDir());
	ofn.lpstrInitialDir = ConfigFile::getInstance()->getUserScriptsDir().c_str();
	//ofn.lpstrFileTitle = "Choose filename for new script";
	ofn.lpstrFile = new TCHAR[MAX_PATH];
	ofn.lpstrFile[0] = _T('\0');
	ofn.nMaxFile = MAX_PATH;
	ofn.lpstrDefExt = _T("py");
	//lint -e840 Use of nul character in a string literal
	// This is how it's meant to be used.
	ofn.lpstrFilter = _T("Python Source Files (*.py)\0*.py\0All Files (*.*)\0*.*\0");
	//lint +e840
	ofn.nFilterIndex = 1;

	ofn.Flags = OFN_OVERWRITEPROMPT;


	if (GetSaveFileName(&ofn))
	{

		HANDLE hFile = CreateFile(ofn.lpstrFile, GENERIC_WRITE, 0, NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL);
		CloseHandle(hFile);
		SendMessage(nppData._nppHandle, NPPM_DOOPEN, 0, reinterpret_cast<LPARAM>(ofn.lpstrFile));
		intptr_t bufferID = SendMessage(nppData._nppHandle, NPPM_GETCURRENTBUFFERID, 0, 0);
		SendMessage(nppData._nppHandle, NPPM_SETBUFFERLANGTYPE, L_PYTHON, bufferID);
	}


	delete [] ofn.lpstrFile;


}



static void shutdown(void* /* dummy */)
{
	if (pythonHandler)
	{
		delete pythonHandler;
		pythonHandler = NULL;
	}

	if (g_console.get())
	{
		g_console.reset();
	}

	for(std::vector<std::string*>::iterator it = g_menuScripts.begin(); it != g_menuScripts.end(); ++it)
	{
		delete *it;
	}

	for(std::vector< std::pair<std::string*, HICON>* >::iterator it = g_toolbarScripts.begin(); it != g_toolbarScripts.end(); ++it)
	{
		// Delete the string
		delete (*(*it)).first;

		// Destroy the HICON
		DestroyIcon((*(*it)).second);

		// Delete the pair
		delete *it;
	}

	MenuManager::deleteInstance();

}


static void doHelp()
{
	int which = 0;

	SendMessage(nppData._nppHandle, NPPM_GETCURRENTSCINTILLA, 0, reinterpret_cast<LPARAM>(&which));

	HelpController help(nppData._nppHandle, which ? nppData._scintillaSecondHandle : nppData._scintillaMainHandle);
	help.callHelp();
}

static void previousScript()
{
	previousScript_clicked = true;
	runScript(g_previousScript.c_str(), false);
	previousScript_clicked = false;
}

HWND getCurrScintilla()
{
    int which = -1;
    ::SendMessage( nppData._nppHandle, NPPM_GETCURRENTSCINTILLA, 0, ( LPARAM )&which );
    return ( which == 0 ) ? nppData._scintillaMainHandle : nppData._scintillaSecondHandle;
}
