/* -*- mode: C++; tab-width: 4 -*- */
/* ===================================================================== *\
	Copyright (c) 1999-2001 Palm, Inc. or its subsidiaries.
	All rights reserved.

	This file is part of the Palm OS Emulator.

	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.
\* ===================================================================== */

#include "EmCommon.h"
#include "Startup.h"

#include "EmDocument.h"			// EmDocument::AskNewSession
#include "EmPalmStructs.h"		// EmProxyDatabaseHdrType
#include "EmSession.h"			// gSession, EmSessionStopper
#include "EmStreamFile.h"		// EmStreamFile
#include "Hordes.h"				// Hordes::SetGremlinsHome
#include "Miscellaneous.h"		// IsExecutable, GetLoadableFileList
#include "Platform.h"			// ForceStartupScreen
#include "PreferenceMgr.h"		// Preference
#include "Strings.r.h"			// kStr_Autoload, etc.

#include <algorithm>			// find()
#include <string>
#include <utility>				// make_pair()
#include <vector>

// Startup actions.
//static Bool				gAskWhatToDo;
static Bool				gCreateSession;
static Bool				gOpenSession;
static Bool				gMinimize;

// Post-startup actions.
static Bool				gStartNewHorde;
static Bool				gHordeQuitWhenDone;
static Bool				gMinimizeQuitWhenDone;
// Quit actions.
static Bool				gQuitOnExit;

// Action-specific data.
static Configuration	gCfg;				// For CreateSession.
static EmFileRef		gSessionOpenRef;	// For OpenSession.
static EmFileRef		gMinimizeRef;		// For Minimize
static HordeInfo		gHorde;				// For StartNewGremlin
static StringList		gHordeApps;			// For StartNewGremlin

	// These are the files listed on the command line.
static string			gAutoRunApp;
static EmFileRefList	gAutoLoadFiles1;
//static EmFileRefList		gAutoRunFiles1;
//static EmFileRefList		gAutoRunAndQuitFiles1;

	// These are the files found in the Auto* directories.
static EmFileRefList	gAutoLoadFiles2;
static EmFileRefList	gAutoRunFiles2;
static EmFileRefList	gAutoRunAndQuitFiles2;


// These are the keys we use when tracking what the user has specified.

static const char		kOptPSF[]				= "psf";
static const char		kOptROM[]				= "rom";
static const char		kOptRAM[]				= "ram";
static const char		kOptDevice[]			= "device";
static const char		kOptSkin[]				= "skin";
static const char		kOptLoad[]				= "load";
static const char		kOptRun[]				= "run";
static const char		kOptMinimize[]			= "minimize";
static const char		kOptQuitOnExit[]		= "quit_on_exit";
static const char		kOptPreference[]		= "preference";
static const char		kOptHordeFirst[]		= "horde_first";
static const char		kOptHordeLast[]			= "horde_last";
static const char		kOptHordeApps[]			= "horde_apps";
static const char		kOptHordeSaveDir[]		= "horde_save_dir";
static const char		kOptHordeSaveFreq[]		= "horde_save_freq";
static const char		kOptHordeDepthMax[]		= "horde_depth_max";
static const char		kOptHordeDepthSwitch[]	= "horde_depth_switch";
static const char		kOptHordeQuitWhenDone[]	= "horde_quit_when_done";


// These are the options the user can specify on the command line.

static const struct
{
	const char*	option;
	const char*	optKey;
	int			optType;	// 0 == no parameter, 1 = has parameter
}
kOptionMap [] =
{
	{ "-psf",					kOptPSF,				1 },
	{ "-rom",					kOptROM,				1 },
	{ "-ram",					kOptRAM,				1 },
	{ "-ram_size",				kOptRAM,				1 },
	{ "-device",				kOptDevice,				1 },
	{ "-skin",					kOptSkin,				1 },
	{ "-silkscreen",			kOptSkin,				1 },
	{ "-load_apps",				kOptLoad,				1 },
	{ "-run_app",				kOptRun,				1 },
	{ "-minimize",				kOptMinimize,			1 },
	{ "-quit_on_exit",			kOptQuitOnExit,			0 },
	{ "-preference",			kOptPreference,			1 },
	{ "-pref",					kOptPreference,			1 },
	{ "-d",						kOptPreference,			1 },
	{ "-horde",					kOptHordeFirst,			1 },
	{ "-horde_first",			kOptHordeFirst,			1 },
	{ "-horde_last",			kOptHordeLast,			1 },
	{ "-horde_apps",			kOptHordeApps,			1 },
	{ "-horde_save_dir",		kOptHordeSaveDir,		1 },
	{ "-horde_save_freq",		kOptHordeSaveFreq,		1 },
	{ "-horde_depth_max",		kOptHordeDepthMax,		1 },
	{ "-horde_depth_switch",	kOptHordeDepthSwitch,	1 },
	{ "-horde_quit_when_done",	kOptHordeQuitWhenDone,	0 }
};




// Handy macro for helping us find and access options in the OptionList.
// For the option with the base name "name", this macro defines:
//
//		"iter<name>"	An iterator pointing to the named OptionList entry.
//		"have<name>"	A bool that says whether the iterator points to
//						something valid.
//		"opt<name>"		A string reference that refers to the option value
//						if "have<name>" is true.

#define DEFINE_VARS(name)												\
	OptionList::iterator	iter##name	= options.find(kOpt##name);		\
	Bool					have##name	= iter##name != options.end();	\
	string&					opt##name	= iter##name->second


/***********************************************************************
 *
 * FUNCTION:    PrvGetDatabaseInfosFromAppNames
 *
 * DESCRIPTION: Given a list of application names (as determined either
 *				by their 'tAIN' resources or their database names) and
 *				return AppInfos for all applications installed in the
 *				system with those names.
 *
 * PARAMETERS:  names - the StringList with the names of the applications
 *					to search for.  *All* executables are considered,
 *					includes .prc's and .pqa's.
 *
 *				results - the DatabaseInfoList to receive the DatabaseInfos of
 *					the executables with a name that appears in the
 *					"names" collection.
 *
 * RETURNED:    Nothing
 *
 ***********************************************************************/

void Startup::PrvGetDatabaseInfosFromAppNames (const StringList& names, DatabaseInfoList& results)
{
	StringList	namesCopy (names);

	if (!namesCopy.empty())
	{
		// If the string list begins with a "-", then the list is
		// a list of files to be *skipped*.

		Bool				mustBeFound = true;
		string				firstName = namesCopy[0];
		if (firstName[0] == '-')
		{
			mustBeFound = false;
			firstName.erase (firstName.begin ());
			namesCopy[0] = firstName;
		}

		// Get a list of installed applications.

		DatabaseInfoList	dbInfos;
		::GetDatabases (dbInfos, kApplicationsOnly);

		// For each application in the list we just got, see if it was
		// specified in the user's name list.

		DatabaseInfoList::iterator	infoIter = dbInfos.begin();
		while (infoIter != dbInfos.end())
		{
			string						appInfoName(infoIter->name);
			StringList::const_iterator	nameIter = find (namesCopy.begin(), namesCopy.end(), appInfoName);
			Bool						found = nameIter != namesCopy.end();

			// Check to see if one of two things are true:
			//
			//	* The installed application is on the include list.
			//	* The installed application in not on the exclude list.
			//
			// If either case is true, push it onto our "results" list.

			if (found == mustBeFound)
			{
				results.push_back (*infoIter);
			}

			++infoIter;
		}
	}
}


/***********************************************************************
 *
 * FUNCTION:    PrvDontUnderstand
 * FUNCTION:    PrvMissingArgument
 * FUNCTION:    PrvInvalidRAMSize
 * FUNCTION:    PrvInvalidSkin
 *
 * DESCRIPTION: Display error messages concerning poor, misunderstood
 *				switches and their parameters.
 *
 * PARAMETERS:  The switch ("-foo") guy who caused the problem.
 *
 * RETURNED:    Nothing
 *
 ***********************************************************************/

static string PrvWrap (const string& s, int chars_per_line)
{
	string result (s);
	int index = 0;
	int last_space = -1;
	int last_cr = -1;

	while (index < (int) result.size ())
	{
		char ch = result[index];

		if (ch == ' ')
		{
			last_space = index;
		}
		else if (ch == '\n')
		{
			last_cr = index;
			last_space = -1;
		}

		// Have we accumulated enough characters?

		if (index - last_cr >= chars_per_line)
		{
			EmAssert (last_space >= 0);

			result [last_space] = '\n';
			last_cr = last_space;
			last_space = -1;
		}

		++index;
	}

	return result;
}


void Startup::PrvError (const char* msg)
{
#if PLATFORM_UNIX
	printf ("%s\n", msg);
#else
	EmDlg::DoCommonDialog (msg, kDlgFlags_OK);
#endif
}

void Startup::PrvDontUnderstand (const char* arg)
{
	char	buffer[200];
	sprintf (buffer, "Don't understand the command line parameter \"%s\".", arg);
	Startup::PrvError (buffer);
}

void Startup::PrvMissingArgument (const char* arg)
{
	char	buffer[200];
	sprintf (buffer, "The command line parameter \"%s\" needs to be followed by an "
		"argument (\"No, it doesn't.\" \"Yes, it does.\" \"No, it doesn't...\").", arg);
	Startup::PrvError (buffer);
}

void Startup::PrvInvalidRAMSize (const char* arg)
{
	char	buffer[200];
	sprintf (buffer, "\"%s\" is an invalid RAM size. Specify 128, 256, 512, 1024, "
		"2048, 4096, 8192, or 16384.", arg);
	Startup::PrvError (buffer);
}

void Startup::PrvInvalidSkin (const char* argSkin, const char* argDevice)
{
	char	buffer[200];
	sprintf (buffer, "The skin \"%s\" cannot be used with the device \"%s\".", argSkin, argDevice);
	Startup::PrvError (buffer);
}

void Startup::PrvInvalidPreference (const char* pref)
{
	char	buffer[200];
	sprintf (buffer, "Don't understand the preference parameter \"%s\".", pref);
	Startup::PrvError (buffer);
}

void Startup::PrvPrintHelp (void)
{
	printf ("Options are:\n");
	printf (" -psf <file>          Session file to open at startup\n");
	printf (" -rom <file>          ROM file to use at startup\n");
	printf (" -ram_size <size>     Amount of RAM (in K) to emulate at startup\n");
	printf (" -device <name>       Device type to use at startup\n");
	printf (" -skin <name>         Name of skin to use for the device\n");
	printf (" -load_apps <name(s)> Comma-seperated list of names of .prc files to load at startup\n");
	printf (" -run_app <name>      Name of file to automatically run at startup\n");
	printf (" -quit_on_exit        Cause Poser to quit after -run application exits\n");
	printf (" -pref <key=value>    Change a preference setting\n");
	printf ("\n");

	Platform::PrintHelp ();

	string help (
		"\n"
		"Specifying the -psf option on the command line causes Poser to attempt "
		"to load and run the specified session file at startup.\n"
		"\n"
		"Specifying the -rom, -ram_size, and -device options on the command line "
		"causes Poser to create a new session based on those specifications.  If "
		"only some of those three options are specified, then Poser will present "
		"a New Session dialog with the specified items already filled in.\n"
		"\n"
		"The parameter passed with the -skin option is the name "
		"of the silkscreen as defined in the .skin file.\n"
		"\n"
		"The parameter passed with the -load_apps option is a comma-seperated list "
		"of file names.  The parameter passed with the -run_app option is the name "
		"of the Palm OS application itself, not the name of the file it came from.  "
		"This is generally the name that appears in the Palm OS Launcher.\n"
		"\n"
		"The -pref option can be used to change a preference setting.  The parameter "
		"passed with is is of the for key=value, where \"key\" is any of the keys "
		"displayed in the preference file, and value is the value you want it to be.  "
		"Note that using this option *changes* the preference.  It does not override "
		"the preference.  Thus, when the emulator exits, the value specified on the "
		"command line will be written to the preference file.\n"
		"\n"
		);

	help = ::PrvWrap (help, 78);
	printf ("%s", help.c_str ());
}


/***********************************************************************
 *
 * FUNCTION:    PrvCollectOptions
 *
 * DESCRIPTION: Breaks up the command line text into pairs of switches
 *				(the "-foo" part) and their optional parameters (anything
 *				that comes after the "-foo" part).  Switches are
 *				validated, and they and any parameter are added to
 *				the given OptionList.
 *
 * PARAMETERS:  argc, argv - standard C parameters describing the
 *					command line.
 *
 *				options - the OptionList to received the parsed and
 *					validated parameters.
 *
 * RETURNED:    True if everything went swimmingly.  If an error occurred
 *				(for instance, an invalid switch was specified or a
 *				switch that needed a parameter didn't have one), the
 *				error is reported and the function returns false.
 *
 ***********************************************************************/

static OptionList*		gOptions;
static PreferenceList*	gPreferences;

int Startup::PrvParseOneOption (int argc, char** argv, int& argIndex)
{
	const char*	arg = argv[argIndex];

	// For this argument, see if it is a recognized switch.

	for (size_t ii = 0; ii < countof (kOptionMap); ++ii)
	{
		if (_stricmp (arg, kOptionMap[ii].option) == 0)
		{
			// It's recognized; see if we need to also collect a parameter.

			if (kOptionMap[ii].optType == 0)
			{
				// No parameter, just add the switch to our collection.

				(*gOptions)[kOptionMap[ii].optKey] = "";
				argIndex += 1;
				return 1;
			}
			else if (kOptionMap[ii].optType == 1)
			{
				if ((argIndex + 1) < argc)
				{
					// Add the switch and parameter to our collection.
					// Put preferences on a seperate list -- a multimap
					// -- so that we can support more than one.  All others
					// go into a map collection so that we respond to just
					// the last specified option.

					if (kOptionMap[ii].optKey == kOptPreference)
						gPreferences->insert (make_pair (kOptionMap[ii].optKey, argv[argIndex + 1]));
					else
						(*gOptions)[kOptionMap[ii].optKey] = argv[argIndex + 1];

					argIndex += 2;
					return 2;
				}
				else
				{
					// Needed a parameter, but there wasn't one.
					Startup::PrvMissingArgument (arg);
					return 0;
				}
			}
		}
	}

	// If we got here, we didn't understand the argument.  Perhap someone
	// provided a file name without a preceding -psf or -rom (this can happen
	// in Windows when someone drops such a file on the application's icon).
	// See if that's the case and try to support it.

	EmFileRef	ref (arg);
	if (ref.Exists ())
	{
		if (ref.IsType (kFileTypeROM))
		{
			(*gOptions)[kOptROM] = arg;
			argIndex += 1;
			return 1;
		}

		if (ref.IsType (kFileTypeSession))
		{
			(*gOptions)[kOptPSF] = arg;
			argIndex += 1;
			return 1;
		}
	}

	// And if we got this far, return an error.

	return 0;
}


Bool Startup::PrvCollectOptions (int argc, char** argv,
							   OptionList& options,
							   PreferenceList& prefs)
{
	// Iterate over the command line arguments.

	gOptions = &options;
	gPreferences = &prefs;

	int errorArg;

	if (!Platform::CollectOptions (argc, argv, errorArg, &Startup::PrvParseOneOption))
	{
		Startup::PrvDontUnderstand (argv[errorArg]);
		Startup::PrvPrintHelp ();
		return false;
	}

	return true;
}


/***********************************************************************
 *
 * FUNCTION:    PrvConvertRAM
 *
 * DESCRIPTION: Convert a -ram parameter into a number and validate it.
 *
 * PARAMETERS:  str - the switch parameter.
 *
 *				ramSize - the RAMSizeType to receive the converted value.
 *
 * RETURNED:    True if everything went well.  If the resulting value
 *				was not a valid RAMSizeType value, then returns false.
 *
 ***********************************************************************/

Bool Startup::PrvConvertRAM (const string& str, RAMSizeType& ramSize)
{
	ramSize = atol (str.c_str ());

	MemoryTextList	sizes;
	::GetMemoryTextList (sizes);

	MemoryTextList::iterator	iter = sizes.begin ();
	while (iter != sizes.end ())
	{
		if (ramSize == iter->first)
		{
			return true;
		}

		++iter;
	}

	return false;
}


/***********************************************************************
 *
 * FUNCTION:    PrvParseFileList
 *
 * DESCRIPTION: Break up a comma-delimited list of files, returning the
 *				pieces in a EmFileRefList.
 *
 * PARAMETERS:  fileList - the EmFileRefList to receive the files from the
 *					comma-delimited list.  This collection is *not* first
 *					cleared out, so it's possible to add to the
 *					collection with this function.
 *
 *				option - the string containing the comma-delimited files.
 *
 * RETURNED:    Nothing
 *
 ***********************************************************************/

void Startup::PrvParseFileList (EmFileRefList& fileList, string option)
{
	StringList	items;
	::SeparateList (items, option, ',');

	StringList::iterator	iter = items.begin ();
	while (iter != items.end ())
	{
		fileList.push_back (EmFileRef (*iter));
		++iter;
	}
}


/***********************************************************************
 *
 * FUNCTION:    PrvHandleOpenSessionParameters
 *
 * DESCRIPTION: Handle the following command line options:
 *
 *					kOptPSF
 *					kOptMinimize
 *
 * PARAMETERS:  options - the OptionList containing the complete set
 *					of parsed switches and parameters.
 *
 * RETURNED:    True if everything when OK.  If there's something wrong
 *				with the specifications, this function displays an
 *				error message and return false.
 *
 ***********************************************************************/

Bool Startup::PrvHandleOpenSessionParameters (OptionList& options)
{
	DEFINE_VARS(PSF);
	DEFINE_VARS(Minimize);

	if (havePSF)
	{
		// Clear out any previous action

		Startup::ScheduleAskWhatToDo ();

		// Schedule the new action

		EmFileRef	psfRef = EmFileRef (optPSF);
		Startup::ScheduleOpenSession (psfRef);
	}

	if (haveMinimize)
	{
		// Clear out any previous action

		Startup::ScheduleAskWhatToDo ();

		// Schedule the new action

		EmFileRef	MinimizeRef = EmFileRef (optMinimize);
		Startup::ScheduleMinimize (MinimizeRef);
	}

	return true;
}


/***********************************************************************
 *
 * FUNCTION:    PrvHandleCreateSessionParameters
 *
 * DESCRIPTION: Handle the following command line options:
 *
 *					kOptROM
 *					kOptRAM
 *					kOptDevice
 *
 * PARAMETERS:  options - the OptionList containing the complete set
 *					of parsed switches and parameters.
 *
 * RETURNED:    True if everything when OK.  If there's something wrong
 *				with the specifications, this function displays an
 *				error message and return false.
 *
 ***********************************************************************/

Bool Startup::PrvHandleCreateSessionParameters (OptionList& options)
{
	DEFINE_VARS(ROM);
	DEFINE_VARS(RAM);
	DEFINE_VARS(Device);

	Bool					haveSome	= haveROM || haveRAM || haveDevice;
	Bool					haveAll		= haveROM && haveRAM && haveDevice;

	if (haveSome)
	{
		Preference<Configuration>	prefConfig (kPrefKeyLastConfiguration);
		Configuration				cfg = *prefConfig;

		// Check for a specified ROM file.

		if (haveROM)
		{
			cfg.fROMFile = EmFileRef (optROM);
		}

		// Check for a specified RAM size.

		if (haveRAM)
		{
			if (!Startup::PrvConvertRAM (optRAM, cfg.fRAMSize))
			{
				Startup::PrvInvalidRAMSize (optRAM.c_str ());
				return false;
			}
		}

		// Check for a specified device type.

		if (haveDevice)
		{
			EmDevice	device (optDevice);
			if (device.Supported ())
			{
				cfg.fDevice = device;
			}
			else
			{
				Startup::PrvDontUnderstand (optDevice.c_str ());
				return false;
			}
		}

		// Try to start up with the specified parameters.
		// If the command line didn't specify all the required values, ask for them.

		if (!haveAll && !EmDocument::AskNewSession (cfg))
		{
			// User cancelled the "New Configuration" dialog.
			// Bring up the dialog with the New/Open/Download/Exit buttons.

			Startup::ScheduleAskWhatToDo ();
		}
		else
		{
			// Clear out any previous action

			Startup::ScheduleAskWhatToDo ();

			// Schedule the new action

			Startup::ScheduleCreateSession (cfg);
		}
	}

	return true;
}


/***********************************************************************
 *
 * FUNCTION:    PrvHandleNewHordeParameters
 *
 * DESCRIPTION: Handle the following command line options:
 *
 *					kOptHordeFirst
 *					kOptHordeLast
 *					kOptHordeApps
 *					kOptHordeSaveDir
 *					kOptHordeSaveFreq
 *					kOptHordeDepthMax
 *					kOptHordeDepthSwitch
 *					kOptHordeQuitWhenDone
 *
 * PARAMETERS:  options - the OptionList containing the complete set
 *					of parsed switches and parameters.
 *
 * RETURNED:    True if everything when OK.  If there's something wrong
 *				with the specifications, this function displays an
 *				error message and return false.
 *
 ***********************************************************************/

Bool Startup::PrvHandleNewHordeParameters (OptionList& options)
{
	DEFINE_VARS(HordeFirst);
	DEFINE_VARS(HordeLast);
	DEFINE_VARS(HordeApps);
	DEFINE_VARS(HordeSaveDir);
	DEFINE_VARS(HordeSaveFreq);
	DEFINE_VARS(HordeDepthMax);
	DEFINE_VARS(HordeDepthSwitch);
	DEFINE_VARS(HordeQuitWhenDone);

	UNUSED_PARAM(optHordeQuitWhenDone);

	if (haveHordeFirst ||
		haveHordeLast ||
		haveHordeApps ||
		haveHordeSaveDir ||
		haveHordeSaveFreq ||
		haveHordeDepthMax ||
		haveHordeDepthSwitch)
	{
		HordeInfo	info;
		StringList	appNames;

		if (haveHordeFirst)
		{
			info.fStartNumber = atoi (optHordeFirst.c_str ());

			if (!haveHordeLast)
			{
				info.fStopNumber = info.fStartNumber;
			}
		}

		if (haveHordeLast)
		{
			info.fStopNumber = atoi (optHordeLast.c_str ());

			if (!haveHordeFirst)
			{
				info.fStartNumber = info.fStopNumber;
			}
		}

		if (!haveHordeFirst && !haveHordeLast)
		{
			info.fStartNumber = 0;
			info.fStopNumber = 0;
		}

		if (haveHordeApps)
		{
			// Get the list of user-specified names.
			// We can't do much more with them now -- like look up
			// the applications on the device -- as the device may
			// not be up and running at this time.  We have to defer
			// doing that until we're ready to start the Gremlin.

			::SeparateList (appNames, optHordeApps, ',');

		}

		if (haveHordeSaveDir)
		{
			Hordes::SetGremlinsHome (optHordeSaveDir);
		}
		else
		{
			Hordes::SetGremlinsHomeToDefault ();
		}

		if (haveHordeSaveFreq)
		{
			info.fSaveFrequency = atoi (optHordeSaveFreq.c_str ());
		}

		if (haveHordeDepthMax)
		{
			info.fMaxDepth = atoi (optHordeDepthMax.c_str ());
		}

		if (haveHordeDepthSwitch)
		{
			info.fSwitchDepth = atoi (optHordeDepthSwitch.c_str ());
		}

		if (haveHordeFirst || haveHordeLast)
		{
			info.OldToNew ();	// Transfer old fields to new.

			Startup::ScheduleNewHorde (info, appNames);
		}
	}

	gHordeQuitWhenDone = haveHordeQuitWhenDone;

	return true;
}


/***********************************************************************
 *
 * FUNCTION:    PrvHandleAutoLoadParameters
 *
 * DESCRIPTION: Handle the following command line options:
 *
 *					kOptLoad
 *					kOptRun
 *					kOptQuitOnExit
 *
 * PARAMETERS:  options - the OptionList containing the complete set
 *					of parsed switches and parameters.
 *
 * RETURNED:    True if everything when OK.  If there's something wrong
 *				with the specifications, this function displays an
 *				error message and return false.
 *
 ***********************************************************************/

Bool Startup::PrvHandleAutoLoadParameters (OptionList& options)
{
	DEFINE_VARS(Load);
	DEFINE_VARS(Run);
	DEFINE_VARS(QuitOnExit);

	UNUSED_PARAM (optQuitOnExit)

	if (haveLoad)
	{
		Startup::PrvParseFileList (gAutoLoadFiles1, optLoad);
	}

	if (haveRun)
	{
		gAutoRunApp = optRun;
	}

	if (haveQuitOnExit)
	{
		Startup::ScheduleQuitOnExit ();
	}

	return true;
}


/***********************************************************************
 *
 * FUNCTION:    PrvHandleSkinParameters
 *
 * DESCRIPTION: Handle the following command line options:
 *
 *					kOptDevice
 *					kOptSkin
 *
 * PARAMETERS:  options - the OptionList containing the complete set
 *					of parsed switches and parameters.
 *
 * RETURNED:    True if everything when OK.  If there's something wrong
 *				with the specifications, this function displays an
 *				error message and return false.
 *
 ***********************************************************************/

Bool Startup::PrvHandleSkinParameters (OptionList& options)
{
	DEFINE_VARS(Device);
	DEFINE_VARS(Skin);

	if (haveSkin && haveDevice)
	{
		EmDevice	device (optDevice);

		if (!device.Supported ())
		{
			Startup::PrvDontUnderstand (optDevice.c_str ());
			return false;
		}

		if (!::SkinValidSkin (device, optSkin))
		{
			Startup::PrvInvalidSkin (optSkin.c_str (), optDevice.c_str ());
			return false;
		}

		::SkinSetSkinName (device, optSkin);
	}

	return true;
}


/***********************************************************************
 *
 * FUNCTION:    PrvHandlePreferenceParameters
 *
 * DESCRIPTION: Handle the following command line options:
 *
 *					kOptPreference
 *
 * PARAMETERS:  prefs - the PreferenceList containing the complete set
 *					of parsed preference parameters.
 *
 * RETURNED:    True if everything when OK.  If there's something wrong
 *				with the specifications, this function displays an
 *				error message and return false.
 *
 ***********************************************************************/

Bool Startup::PrvHandlePreferenceParameters (PreferenceList& prefs)
{
	PreferenceList::iterator	iter = prefs.begin ();
	while (iter != prefs.end ())
	{
		string				fullPrefString	= iter->second;
		string::size_type	equalsPos		= fullPrefString.find ('=');

		if (equalsPos == string::npos)
		{
			Startup::PrvInvalidPreference (fullPrefString.c_str ());
			return false;
		}

		string	key = fullPrefString.substr (0, equalsPos);
		string	value = fullPrefString.substr (equalsPos + 1);

		Preference<string>	pref (key.c_str ());
		pref = value;

		++iter;
	}

	return true;
}


/***********************************************************************
 *
 * FUNCTION:    PrvParseCommandLine
 *
 * DESCRIPTION: Parse up the command line into its consituent parts,
 *				validate the parts, and act on the specifications.
 *
 * PARAMETERS:  argc, argv - standard C parameters describing the
 *					command line.
 *
 * RETURNED:    Nothing.  All actions to be taken based on the users
 *				specifications are recorded in global variables.
 *
 ***********************************************************************/

Bool Startup::PrvParseCommandLine (int argc, char** argv)
{
	OptionList		options;
	PreferenceList	prefs;

	// Convert the command line into a map of switch/parameter pairs.

	if (!Startup::PrvCollectOptions (argc, argv, options, prefs))
		goto BadParameter;

	// Handle kOptPSF.

	if (!Startup::PrvHandleOpenSessionParameters (options))
		goto BadParameter;

	// Handle kOptROM, kOptRAM, and kOptDevice.

	if (!Startup::PrvHandleCreateSessionParameters (options))
		goto BadParameter;

	// Handle kOptHordeFirst, kOptHordeLast, kOptHordeApps, kOptHordeSaveDir,
	// kOptHordeSaveFreq, kOptHordeDepthMax, kOptHordeDepthSwitch, and
	// kOptHordeQuitWhenDone.

	if (!Startup::PrvHandleNewHordeParameters (options))
		goto BadParameter;

	// Handle kOptLoad, kOptRun, and kOptQuitOnExit.

	if (!Startup::PrvHandleAutoLoadParameters (options))
		goto BadParameter;

	// Handle kOptSkin
	if (!Startup::PrvHandleSkinParameters (options))
		goto BadParameter;

	// Handle preference changes.
	if (!Startup::PrvHandlePreferenceParameters (prefs))
		goto BadParameter;

	return true;

BadParameter:
	// All bets are off.  Bring up the dialog with the
	// New/Open/Download/Exit buttons.

	Startup::ScheduleAskWhatToDo ();
	return false;
}


/***********************************************************************
 *
 * FUNCTION:    Startup::DetermineStartupActions
 *
 * DESCRIPTION: Determine what to do at startup time, based on any
 *				command-line options, what the user was doing when they
 *				last ran Poser, and whether or not the CapsLock key
 *				is toggled.
 *
 *				In general, the startup rules are as follows:
 *
 *			 	1 If the Caps Lock key is toggled in the ON position, always bring
 *				  up the New/Open/... dialog.
 *
 *				2 Scan the command line for startup parameters.  If an error occurs
 *				  trying to scan the command line, the error is reported and the user
 *				  is presented with the New/Open/... dialog.
 *
 *				3 Use the .psf file if one is specified.  If an error occurs trying
 *				  to load the file, the error is reported and the user is presented
 *				  with the New/Open/... dialog.
 *
 *				4 If any of -rom, -ram, -device, or -silkscreen are specified, try
 *				  to start a new session based on those values.  If all are specified,
 *				  the new session is automatically created.  If any of those four
 *				  values are missing, the "New Configuration" dialog is displayed.
 *				  If the user cancels the dialog, or if there is an error creating
 *				  the new session, any error is reported and the user is presented
 *				  with the New/Open/... dialog.
 *
 *				5 If no command line options are specified, try re-opening the last
 *				  saved .psf file (this step is skipped if the user last created a
 *				  new session, but did NOT save that session to a file).  If an error
 *				  occurs trying to load the file, the error is reported and the user
 *				  is presented with the New/Open/... dialog.
 *
 *				6 Try creating a new session based on the settings the user last
 *				  specified when creating a session.  If there is an error creating
 *				  the new session, the error is reported and the user is presented
 *				  with the New/Open/... dialog.
 *
 *				7 Finally, if all else fails, present the user with the New/Open/...
 *				  dialog.
 *
 * PARAMETERS:  argc, argv - standard C parameters describing the
 *					command line.
 *
 * RETURNED:    True if we were able to determine a startup course of
 *				action.  If false is returned, something horrible happened.
 *				The caller should assume that an error was reported,
 *				and that the application should quit.
 *
 ***********************************************************************/

Bool Startup::DetermineStartupActions (int argc, char** argv)
{
	// By default, throw up our hands.

	Startup::ScheduleAskWhatToDo ();

	// See if the user wants to force the appearance of the Startup
	// screen (by holding down the ShiftLock key) and skip the auto-
	// loading of the previous session file.

	if (!Platform::ForceStartupScreen ())
	{
		Preference<Configuration>	pref1 (kPrefKeyLastConfiguration);
		Preference<EmFileRef>		pref2 (kPrefKeyLastPSF);

		Configuration	cfg = *pref1;
		EmFileRef		ramFileRef = *pref2;

		// See if there was a previously saved RAM file.  If so, open it.

		if (ramFileRef.IsSpecified ())
		{
			Startup::ScheduleOpenSession (ramFileRef);
		}

		// Else, see if there was a previously created document.  If so,
		// create a new document based on its settings.

		else if (cfg.IsValid () )
		{
			Startup::ScheduleCreateSession (cfg);
		}

		// Now that default actions have been established, let's see if
		// there's anything interesting on the command line.

		if (!Startup::PrvParseCommandLine (argc, argv))
		{
			return false;
		}
	}

	return true;
}


/***********************************************************************
 *
 * FUNCTION:    Startup::GetAutoLoads
 *
 * DESCRIPTION: Return the list of applications that should automatically
 *				be loaded at startup time, regardless of whether a new
 *				session was created or an old one loaded.  The list of
 *				applications is collected from the command line and from
 *				the specially-named AutoLoad, AutoRun, and AutoRunAndQuit
 *				directories.
 *
 * PARAMETERS:  fileList - the EmFileRefList to receive the files to load.
 *					The collection is cleared out before the new items
 *					are added to it.
 *
 * RETURNED:    Nothing
 *
 ***********************************************************************/

void Startup::PrvLookForAutoloads (void)
{
	gAutoLoadFiles2.clear();
	gAutoRunFiles2.clear();
	gAutoRunAndQuitFiles2.clear();

	::GetLoadableFileList (Platform::GetString (kStr_Autoload), gAutoLoadFiles2);
	::GetLoadableFileList (Platform::GetString (kStr_Autorun), gAutoRunFiles2);
	::GetLoadableFileList (Platform::GetString (kStr_AutorunAndQuit), gAutoRunAndQuitFiles2);
}

void Startup::PrvAppendFiles (EmFileRefList& list1, const EmFileRefList& list2)
{
	list1.insert(list1.end(), list2.begin(), list2.end());
}

void Startup::GetAutoLoads (EmFileRefList& fileList)
{
	fileList.clear();

	Startup::PrvLookForAutoloads();

	Startup::PrvAppendFiles (fileList, gAutoLoadFiles1);
//	Startup::PrvAppendFiles (fileList, gAutoRunFiles1);
//	Startup::PrvAppendFiles (fileList, gAutoRunAndQuitFiles1);

	Startup::PrvAppendFiles (fileList, gAutoLoadFiles2);
	Startup::PrvAppendFiles (fileList, gAutoRunFiles2);
	Startup::PrvAppendFiles (fileList, gAutoRunAndQuitFiles2);

	if (/*gAutoRunAndQuitFiles1.size() +*/ gAutoRunAndQuitFiles2.size() > 0)
	{
		Startup::ScheduleQuitOnExit ();
	}
}


/***********************************************************************
 *
 * FUNCTION:    Startup::GetAutoRunApp
 *
 * DESCRIPTION: Returns the *database name* of the application to
 *				switch to at startup time.
 *
 * PARAMETERS:  None
 *
 * RETURNED:    The name of the database of the executable.
 *
 ***********************************************************************/

string Startup::PrvTryGetApp (const EmFileRefList& fileList)
{
	string	result;

	EmFileRefList::const_iterator	iter = fileList.begin();
	while (iter != fileList.end())
	{
		if ((*iter).IsType (kFileTypePalmApp))	// egcs can't handle iter->IsType()!!!
		{
			try
			{
				EmStreamFile	stream (*iter, kOpenExistingForRead);

				EmProxyDatabaseHdrType	header;
				stream.GetBytes (header.GetPtr (), header.GetSize ());

				if (::IsExecutable (header.type, header.creator, header.attributes))
				{
					result = (char*) header.name.GetPtr ();
					break;
				}
			}
			catch (...)
			{
			}
		}

		++iter;
	}

	return result;
}

string Startup::GetAutoRunApp (void)
{
	string	result;

	// Get the name the user specified on the command line (if any)
	// and get the DatabaseInfo for it, so that we can get the database name.

	if (!gAutoRunApp.empty())
	{
		StringList	appNames;
		appNames.push_back (gAutoRunApp);

		DatabaseInfoList	dbInfos;
		Startup::PrvGetDatabaseInfosFromAppNames (appNames, dbInfos);

		if (dbInfos.size() > 0)
		{
			result = dbInfos.begin()->dbName;
		}
	}

	// If the user didn't specify an executable, or we couldn't find
	// that executable, then work from the files found in the AutoRun
	// and AutoRunAndQuit directories.

//	if (result.empty())
//		result = Startup::PrvTryGetApp (gAutoRunFiles1);

	if (result.empty())
		result = Startup::PrvTryGetApp (gAutoRunFiles2);

//	if (result.empty())
//		result = Startup::PrvTryGetApp (gAutoRunAndQuitFiles1);

	if (result.empty())
		result = Startup::PrvTryGetApp (gAutoRunAndQuitFiles2);

	return result;
}


/***********************************************************************
 *
 * FUNCTION:    Startup::AskWhatToDo
 *
 * DESCRIPTION: Return whether or not we are supposed to ask the user
 *				what to do (that is, display the dialog box with the
 *				New, Open, Download, and Quit buttons).  In general,
 *				this function returns true if there's nothing else
 *				scheduled to be done (create a session, open a session,
 *				or quit the emulator).
 *
 * PARAMETERS:  None
 *
 * RETURNED:    True if so.
 *
 ***********************************************************************/

Bool Startup::AskWhatToDo (void)
{
//	Bool	result = gAskWhatToDo;
//	gAskWhatToDo = false;
//	return result;

	return !gCreateSession && !gOpenSession;
}


/***********************************************************************
 *
 * FUNCTION:    Startup::CreateSession
 *
 * DESCRIPTION: Return whether or not we are supposed to create a new
 *				session based on previously determined criteria.  This
 *				is a one-shot function: subsequent calls will return
 *				false until ScheduleCreateSession is called again.
 *
 * PARAMETERS:  cfg - the Configuration to receive the information to
 *					be used when creating the new session.
 *
 * RETURNED:    True if so.
 *
 ***********************************************************************/

Bool Startup::CreateSession (Configuration& cfg)
{
	Bool	result = gCreateSession;
	if (result)
		cfg = gCfg;
	gCreateSession = false;
	return result;
}


/***********************************************************************
 *
 * FUNCTION:    Startup::OpenSession
 *
 * DESCRIPTION: Return whether or not we are supposed to open an old
 *				session based on previously determined criteria.  This
 *				is a one-shot function: subsequent calls will return
 *				false until ScheduleOpenSession is called again.
 *
 * PARAMETERS:  ref - the EmFileRef to receive the reference to
 *					the .psf file to be opened.
 *
 * RETURNED:    True if so.
 *
 ***********************************************************************/

Bool Startup::OpenSession (EmFileRef& ref)
{
	Bool	result = gOpenSession;

	if (result)
	{
		ref = gSessionOpenRef;
	}

	gOpenSession = false;

	return result;
}


/***********************************************************************
 *
 * FUNCTION:    Startup::Minimize
 *
 * DESCRIPTION: Return whether or not we are supposed to open an old
 *				session based on previously determined criteria.  This
 *				is a one-shot function: subsequent calls will return
 *				false until ScheduleOpenSession is called again.
 *
 * PARAMETERS:  ref - the EmFileRef to receive the reference to
 *					the .psf file to be opened.
 *
 * RETURNED:    True if so.
 *
 ***********************************************************************/

Bool Startup::Minimize (EmFileRef& ref)
{
	Bool	result = gMinimize;

	if (result)
	{
		ref = gMinimizeRef;
	}

	gMinimize = false;

	return result;
}


/***********************************************************************
 *
 * FUNCTION:    Startup::NewHorde
 *
 * DESCRIPTION: Return whether or not we are supposed to start a horde
 *				session based on previously determined criteria.  This
 *				is a one-shot function: subsequent calls will return
 *				false until ScheduleNewHorde is called again.
 *
 * PARAMETERS:  info - the HordeInfo to receive the information used to
 *					create the new horde.
 *
 * RETURNED:    True if so.
 *
 ***********************************************************************/

Bool Startup::NewHorde (HordeInfo* info)
{
	Bool	result = gStartNewHorde;

	if (info != NULL)
	{
		if (result)
		{
			*info = gHorde;

			// Find the AppInfos for the user-specified applications.

			EmSessionStopper	stopper (gSession, kStopOnSysCall);

			Startup::PrvGetDatabaseInfosFromAppNames (gHordeApps, info->fAppList);
		}

		gStartNewHorde = false;
	}

	return result;
}


/***********************************************************************
 *
 * FUNCTION:    Startup::HordeQuitWhenDone
 *
 * DESCRIPTION: Return whether or not we are supposed to quit the
 *				emulator session when the Horde has completed.
 *
 * PARAMETERS:  none.
 *
 * RETURNED:    True if so.
 *
 ***********************************************************************/

Bool Startup::HordeQuitWhenDone (void)
{
	return gHordeQuitWhenDone;
}


/***********************************************************************
 *
 * FUNCTION:    Startup::MinimizeQuitWhenDone
 *
 * DESCRIPTION: Return whether or not we are supposed to quit the
 *				emulator session when the Horde has completed.
 *
 * PARAMETERS:  none.
 *
 * RETURNED:    True if so.
 *
 ***********************************************************************/

Bool Startup::MinimizeQuitWhenDone (void)
{
	return gMinimizeQuitWhenDone;
}


/***********************************************************************
 *
 * FUNCTION:    Startup::QuitOnExit
 *
 * DESCRIPTION: Return whether or not Poser is supposed to quit when
 *				a particular application exits.
 *
 * PARAMETERS:  None
 *
 * RETURNED:    True if so.
 *
 ***********************************************************************/

Bool Startup::QuitOnExit (void)
{
	Bool	result = gQuitOnExit;
//	gQuitOnExit = false;
	return result;
}


/***********************************************************************
 *
 * FUNCTION:    Startup::Clear
 *
 * DESCRIPTION: Clear all settings.
 *
 * PARAMETERS:  None
 *
 * RETURNED:    Nothing
 *
 ***********************************************************************/

void Startup::Clear (void)
{
	gCreateSession	= false;
	gOpenSession	= false;
	gStartNewHorde	= false;
	gQuitOnExit		= false;

	gAutoRunApp = "";
	gAutoLoadFiles1.clear();
	gAutoLoadFiles2.clear();
	gAutoRunFiles2.clear();
	gAutoRunAndQuitFiles2.clear();
}


/***********************************************************************
 *
 * FUNCTION:    Startup::ScheduleAskWhatToDo
 *
 * DESCRIPTION: Schedule our "state machine" so that AskWhatToDo will
 *				return True.
 *
 * PARAMETERS:  None
 *
 * RETURNED:    Nothing
 *
 ***********************************************************************/

void Startup::ScheduleAskWhatToDo (void)
{
	Startup::Clear ();
//	gAskWhatToDo = true;
}


/***********************************************************************
 *
 * FUNCTION:    Startup::ScheduleCreateSession
 *
 * DESCRIPTION: Schedule our "state machine" so that CreateSession will
 *				return True.
 *
 * PARAMETERS:  cfg - the Configuration returned to the caller of
 *					CreatSession.
 *
 * RETURNED:    Nothing
 *
 ***********************************************************************/

void Startup::ScheduleCreateSession (const Configuration& cfg)
{
	gCreateSession = true;
//	gAskWhatToDo = false;
	gCfg = cfg;
}


/***********************************************************************
 *
 * FUNCTION:    Startup::ScheduleOpenSession
 *
 * DESCRIPTION: Schedule our "state machine" so that OpenSession will
 *				return True.
 *
 * PARAMETERS:  ref - the EmFileRef returned to the caller of
 *					OpenSession.
 *
 * RETURNED:    Nothing
 *
 ***********************************************************************/

void Startup::ScheduleOpenSession (const EmFileRef& ref)
{
	gOpenSession = true;
//	gAskWhatToDo = false;
	gSessionOpenRef = ref;
}


/***********************************************************************
 *
 * FUNCTION:    Startup::ScheduleMinimize
 *
 * DESCRIPTION: Schedule our "state machine" so that OpenSession will
 *				return True.
 *
 * PARAMETERS:  ref - the EmFileRef returned to the caller of
 *					OpenSession.
 *
 * RETURNED:    Nothing
 *
 ***********************************************************************/

void Startup::ScheduleMinimize (const EmFileRef& ref)
{
	gMinimize = true;
	gMinimizeQuitWhenDone = true;
//	gAskWhatToDo = false;
	gMinimizeRef = ref;
}


/***********************************************************************
 *
 * FUNCTION:    Startup::ScheduleNewHorde
 *
 * DESCRIPTION: Schedule our "state machine" so that NewHorde will
 *				return True.
 *
 * PARAMETERS:  info - the HordeInfo returned to the caller of NewHorde.
 *
 *				appNames - names of the applications to inflict the
 *					Gremlins on.  Normally, this information is
 *					specified in the fAppList field of the HordeInfo.
 *					However, at the time this function is called,
 *					we may not be able to generate the DatabaseInfoList
 *					(the emulator may be just starting up and not
 *					emulating a Palm OS environment, yet).  So we
 *					remember the names here.  When NewHorde is called,
 *					the appNames list is converted into an DatabaseInfoList.
 *
 * RETURNED:    Nothing
 *
 ***********************************************************************/

void Startup::ScheduleNewHorde (const HordeInfo& info, const StringList& appNames)
{
	gStartNewHorde = true;
	gHorde = info;
	gHordeApps = appNames;
}


/***********************************************************************
 *
 * FUNCTION:    Startup::ScheduleQuitOnExit
 *
 * DESCRIPTION: Schedule our "state machine" so that QuitOnExit will
 *				return True.
 *
 * PARAMETERS:  None
 *
 * RETURNED:    Nothing
 *
 ***********************************************************************/

void Startup::ScheduleQuitOnExit (void)
{
	gQuitOnExit = true;
}