/*
 *  Copyright (C) 2000-2002  Ryan Nunn
 *
 *  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.
 */

/*
 *  What is this?
 *
 *  EXCONFIG is a dll that is used by the InstallShield Wizard to get and set the
 *  Black Gate and Serpent Isle paths.
 *
 */

#include "stdafx.h"
#include "exconfig.h"
#include "Configuration.h"
#include <string>

#define MAX_STRLEN	512

#ifdef _DEBUF
#define MessageBoxDebug(a,b,c,d) MessageBox(a,b,c,d);
#else
#define MessageBoxDebug(a,b,c,d)
#endif

const std::string c_empty_string;

char *config_defaults[] =
{
	"config/disk/game/blackgate/keys",	"(default)",
	"config/disk/game/blackgate/waves",	"jmsfx.flx",
	"config/disk/game/serpentisle/keys",	"(default)",
	"config/disk/game/serpentisle/waves",	"jmsisfx.flx",
	"config/audio/enabled",			"yes",
	"config/audio/effects/enabled",		"yes",
	"config/audio/effects/convert",		"gs",
	"config/audio/midi/enabled",		"yes",
	"config/audio/midi/convert",		"gm",
	"config/audio/midi/reverb/enabled",	"no",
	"config/audio/midi/reverb/level",	"0",
	"config/audio/midi/chorus/enabled",	"no",
	"config/audio/midi/chorus/level",	"0",
	"config/audio/midi/volume_curve",	"1.000000",
	"config/audio/speech/enabled",		"yes",
	"config/gameplay/cheat",		"yes",
	"config/gameplay/skip_intro",		"no",
	"config/gameplay/skip_splash",		"no",
	"config/video/width",			"320",
	"config/video/height",			"200",
	"config/video/scale",			"2",
	"config/video/scale_method",		"2xSaI",
	"config/video/fullscreen",		"no",
	"config/video/disable_fades",		"no",
	"config/video/gamma/red",		"1.00",
	"config/video/gamma/green",		"1.00",
	"config/video/gamma/blue",		"1.00",
	0
};

class Path
{
	struct Directory
	{
		char		name[256];
		Directory	*next;

		Directory() : next(0) { name[0] = 0; }
	};

	bool		network;// Networked?
	char		drive;	// Drive letter (if set)
	Directory	*dirs;	// Directories

	void RemoveAll();
	int Addit(const char* p);
public:

	Path() : network(false), drive(0), dirs(0) { }
	Path(const char* p) : network(false), drive(0), dirs(0) { AddString(p); }
	~Path();

	void RemoveLast() { Addit(".."); }
	void AddString(const char* p);
	void GetString(char p[MAX_STRLEN]);

};

// Destructor
Path::~Path()
{
	RemoveAll();
	network = false;
	drive = 0;
}

void Path::RemoveAll()
{
	Directory *d = dirs;
	while (d)
	{
		Directory *next = d->next;
		delete d;
		d = next;
	}
	dirs = 0;
}

int Path::Addit(const char* p)
{
	Directory *d = dirs;
	Directory *prev = 0;
	Directory *prevprev = 0;

	// Check for . and ..

	// Create new
	if (!d)
	{
		dirs = d = new Directory;
	}
	else
	{
		while (d->next)
		{
			prevprev = d;
			d = d->next;
		}
		d->next = new Directory;
		prev = d;
		d = d->next;
	}

	for (int i = 0; p[i] != 0 && p[i] != '\\' && p[i] != '/'; i++)
		d->name[i] = p[i];

	d->name[i] = 0;

	// Skip all 'slashes'
	while (p[i] && (p[i] == '\\' || p[i] == '/')) i++;

	// Check for . and ..
	if (!std::strcmp(d->name, "."))
	{
		delete d;
		prev->next = 0;
	}
	else if (!std::strcmp(d->name, ".."))
	{
		delete d;
		delete prev;
		prevprev->next = 0;

	}

	return i;
}

// Add path
void Path::AddString(const char *p)
{
	int len = std::strlen (p);

	// Root dir of this drive
	if (*p == '\\' || *p == '/')
	{
		// Remove all the entires
		RemoveAll();

		p++;

		// Could be network drive
		if (*p == '\\')
		{
			network = true;
			p++;
		}

	}
	else if (p[0] && p[1] == ':')	// Drive
	{
		RemoveAll();
		drive = *p;
		network = false;
		p+= 2;
	}

	// Skip all slashes
	while (*p && (*p == '\\' || *p == '/')) p++;

	while (*p)
	{
		p+= Addit(p);
	}
}

void Path::GetString(char p[MAX_STRLEN])
{
	p[0] = 0;

	if (network) std::strncat(p, "\\\\", MAX_STRLEN);
	else if (drive) _snprintf (p, MAX_STRLEN, "%c:\\", drive);
	else std::strncat(p, "\\", MAX_STRLEN);

	Directory *d = dirs;
	while (d)
	{
		std::strncat (p, d->name, MAX_STRLEN);
		d = d->next;
		if (d) std::strncat(p, "\\", MAX_STRLEN);
	}

}
// The exports

#ifdef __cplusplus
extern "C" {
#endif

EXCONFIG_API LONG APIENTRY GetPaths(HWND hwnd, LPLONG lpIValue, LPSTR lpszValue)
{
	Path	path(lpszValue);

	char p[MAX_STRLEN];

	path.AddString("exult.cfg");
	path.GetString(p);

	char *si_pathdef = "";
	char *bg_pathdef = "";

	MessageBoxDebug (hwnd, lpszValue, p, MB_OK);

	try
	{
		//chdir (lpszValue);
		Configuration config;
		config.read_config_file(p);

		std::string data_directory;

		config.value("config/disk/game/serpentisle/path",data_directory,si_pathdef);
		if (data_directory != si_pathdef)
		{
			path.~Path();
			path.AddString(lpszValue);
			path.AddString(data_directory.c_str());
			path.GetString(p);
		}
		else
		{
			std::strncpy (p, si_pathdef, MAX_STRLEN);
		}

		config.value("config/disk/game/blackgate/path",data_directory,bg_pathdef);
		if (data_directory != bg_pathdef)
		{
			path.~Path();
			path.AddString(lpszValue);
			path.AddString(data_directory.c_str());
			path.GetString(lpszValue);
		}
		else
		{
			std::strncpy (lpszValue, bg_pathdef, MAX_STRLEN);
		}

		std::strncat(lpszValue, "\n", MAX_STRLEN);
		std::strncat(lpszValue, p, MAX_STRLEN);

		MessageBoxDebug (hwnd, lpszValue, data_directory.c_str(), MB_OK);
	}
	catch(...)
	{
		std::strncpy(lpszValue, bg_pathdef, MAX_STRLEN);
		std::strncat(lpszValue, "\n", MAX_STRLEN);
		std::strncat(lpszValue, si_pathdef, MAX_STRLEN);
	}
	return 0;
}

EXCONFIG_API LONG APIENTRY WriteConfig(HWND hwnd, LPLONG lpIValue, LPSTR lpszValue)
{
	MessageBoxDebug (hwnd, lpszValue, "WriteConfig", MB_OK);

	int len = std::strlen (lpszValue);
	char *p = new char [len+1];
	int i, j, bgstart, sistart;

	for (i = 0; i < len && lpszValue[i] != '\n'; i++) p[i] = lpszValue[i];
	p[i] = 0;
	bgstart = i+1;

	Path	path(p);

	path.AddString("exult.cfg");
	path.GetString(p);
	MessageBoxDebug (hwnd, p, "WriteConfig: p", MB_OK);

	try
	{
		//chdir (lpszValue);
		Configuration config;
		config.read_config_file(p);

		for (j = 0, i = bgstart; i < len && lpszValue[i] != '\n'; j++, i++) p[j] = lpszValue[i];
		p[j] = 0;
		sistart = i+1;
		if (j > 1 && p[j-1] == '\\') p[j-1] = 0;

		MessageBoxDebug (hwnd, p, "WriteConfig: BG", MB_OK);
		config.set("config/disk/game/blackgate/path", p, true);

		for (j = 0, i = sistart ; i < len && lpszValue[i]; j++, i++) p[j] = lpszValue[i];
		p[j] = 0;
		if (j > 1 && p[j-1] == '\\') p[j-1] = 0;

		MessageBoxDebug (hwnd, p, "WriteConfig: SI", MB_OK);
		config.set("config/disk/game/serpentisle/path", p, true);

		std::string s;
		for (i = 0; config_defaults[i]; i+=2)
		{
			config.value(config_defaults[i], s, "");
			if (s.empty()) config.set(config_defaults[i], config_defaults[i+1], true);
		}

		// Fix broken SI SFX stuff
		config.value("config/disk/game/serpentisle/waves", s, "");

		const char *si_sfx = s.c_str();
		int slen = std::strlen(si_sfx);
		slen -= std::strlen ("jmsfxsi.flx");

		if (slen >= 0 && !std::strcmp(si_sfx+slen, "jmsfxsi.flx"))
		{
			char *fixed = new char[slen+1];
			std::strncpy (fixed, si_sfx, slen);
			fixed[slen] = 0;
			s = fixed;
			s += "jmsisfx.flx";

			config.set("config/disk/game/serpentisle/waves", s, true);
		}

		config.write_back();
	}
	catch(...)
	{
	}

	delete [] p;
	return 0;
}

EXCONFIG_API LONG APIENTRY LaunchApp(HWND hwnd, LPLONG lpIValue, LPSTR lpszValue)
{
	Path			path(lpszValue);
	char			p[MAX_STRLEN];
	PROCESS_INFORMATION	pi;
	STARTUPINFO		si;

	path.RemoveLast();
	path.GetString(p);

	std::memset (&si, 0, sizeof(si));
	si.cb = sizeof(si);

	MessageBoxDebug(hwnd, lpszValue, "LaunchApp", MB_OK);

	CreateProcess (NULL, lpszValue, NULL, NULL, FALSE, NORMAL_PRIORITY_CLASS, NULL,
		*lpIValue==1?p:NULL, &si, &pi);

      	return 0;
}

#ifdef __cplusplus
}
#endif

BOOL APIENTRY DllMain( HANDLE hModule, 
                       DWORD  ul_reason_for_call, 
                       LPVOID lpReserved
					 )
{
    switch (ul_reason_for_call)
	{
		case DLL_PROCESS_ATTACH:
		case DLL_THREAD_ATTACH:
		case DLL_THREAD_DETACH:
		case DLL_PROCESS_DETACH:
			break;
    }
    return TRUE;
}