/*****************************************************************************\
	 Snes9x - Portable Super Nintendo Entertainment System (TM) emulator.
				This file is licensed under the Snes9x License.
   For further information, consult the LICENSE file in the root directory.
\*****************************************************************************/

/***********************************************************************************
  SNES9X for Mac OS (c) Copyright John Stiles

  Snes9x for Mac OS X

  (c) Copyright 2001 - 2011  zones
  (c) Copyright 2002 - 2005  107
  (c) Copyright 2002		 PB1400c
  (c) Copyright 2004		 Alexander and Sander
  (c) Copyright 2004 - 2005  Steven Seeger
  (c) Copyright 2005		 Ryan Vogt
 ***********************************************************************************/

#import <Cocoa/Cocoa.h>

#include "snes9x.h"
#include "memmap.h"
#include "movie.h"
#include "display.h"

#include <libgen.h>

#include "mac-prefix.h"
#include "mac-dialog.h"
#include "mac-os.h"
#include "mac-stringtools.h"
#include "mac-file.h"

static void AddFolderIcon (NSURL *, const char *);
static NSURL *FindSNESFolder (const char *);
static NSURL *FindApplicationSupportFolder (NSURL *, const char *);
static NSURL *FindCustomFolder (NSURL *, const char *);


void CheckSaveFolder (NSURL *cartURL)
{
	NSString *folderPath = nil;

	switch (saveInROMFolder)
	{
		case 1: // ROM folder
			folderPath = cartURL.URLByDeletingLastPathComponent.path;
			break;

		case 2: // Application Support folder
			return;

		case 4: // Custom folder
			if (saveFolderPath == NULL)
			{
				saveInROMFolder = 2;
				return;
			}

			BOOL isDirectory = NO;
			BOOL exists = [[NSFileManager defaultManager] fileExistsAtPath:saveFolderPath isDirectory:&isDirectory];

			if (exists && isDirectory)
			{
				folderPath = saveFolderPath;
			}
			else
			{
				//AppearanceAlert(kAlertCautionAlert, kS9xMacAlertFolderNotFound, kS9xMacAlertFolderNotFoundHint);
				saveInROMFolder = 2;
				return;
			}

			break;
	}

	BOOL writable = [[NSFileManager defaultManager] isWritableFileAtPath:folderPath];

	if (!writable)
	{
		//AppearanceAlert(kAlertCautionAlert, kS9xMacAlertFolderNotWritable, kS9xMacAlertFolderNotWritableHint);
		saveInROMFolder = 2;
		return;
	}
}

static NSURL *FindSNESFolder (const char *folderName)
{
	NSURL		*purl = nil;
	NSString	*fstr = [NSString stringWithUTF8String:folderName];

	purl = [[[NSBundle mainBundle] bundleURL].URLByDeletingLastPathComponent URLByAppendingPathComponent:fstr];

	if (![NSFileManager.defaultManager fileExistsAtPath:purl.path])
	{
		NSError *error = nil;
		if ( [NSFileManager.defaultManager createDirectoryAtURL:purl withIntermediateDirectories:YES attributes:nil error:&error] )
		{
			AddFolderIcon(purl, folderName);
		}
		else
		{
			[[NSAlert alertWithError:error] runModal];
		}
	}

	return purl;
}

static NSURL *FindApplicationSupportFolder (const char *folderName)
{
	NSURL		*purl = nil;
	NSURL		*baseURL = nil;
	NSURL		*s9xURL = nil;
	NSURL		*oldURL = nil;
	NSString	*fstr = [NSString stringWithUTF8String:folderName];

	baseURL = [[NSFileManager.defaultManager URLsForDirectory:NSApplicationSupportDirectory inDomains:NSUserDomainMask].firstObject URLByAppendingPathComponent:fstr];

	if (!baseURL)
	{
		return nil;
	}

	s9xURL = [baseURL URLByAppendingPathComponent:@"Snes9x"];
	oldURL = [baseURL URLByAppendingPathComponent:@"SNES9X"];

	if ([NSFileManager.defaultManager fileExistsAtPath:s9xURL.path])
	{
		purl = s9xURL;
	}
	else
	{
		if ([NSFileManager.defaultManager fileExistsAtPath:oldURL.path])
		{
			purl = oldURL;
		}
		else
		{
			NSError *error = nil;
			if ([NSFileManager.defaultManager createDirectoryAtURL:s9xURL withIntermediateDirectories:YES attributes:nil error:&error])
			{
				purl = s9xURL;
				AddFolderIcon(purl, folderName);
			}
		}
	}

	return purl;
}

static NSURL *FindCustomFolder (const char *folderName)
{
	NSURL *purl = nil;

	if (saveFolderPath == NULL)
		return nil;

	purl = [NSURL fileURLWithPath:saveFolderPath];

	if (![NSFileManager.defaultManager fileExistsAtPath:saveFolderPath])
	{
		NSError *error = nil;
		if (![NSFileManager.defaultManager createDirectoryAtPath:saveFolderPath withIntermediateDirectories:YES attributes:nil error:&error])
		{
			[[NSAlert alertWithError:error] runModal];
			return nil;
		}
	}

	purl = [purl URLByAppendingPathComponent:[NSString stringWithUTF8String:folderName]];

	if (![NSFileManager.defaultManager fileExistsAtPath:purl.path])
	{
		NSError *error = nil;
		if ([NSFileManager.defaultManager createDirectoryAtPath:saveFolderPath withIntermediateDirectories:YES attributes:nil error:&error])
		{
			AddFolderIcon(purl, folderName);
		}
		{
			[[NSAlert alertWithError:error] runModal];
			return nil;
		}
	}

	return purl;
}

void ChangeTypeAndCreator (const char *path, OSType type, OSType creator)
{
	NSError *error = nil;
	if (![NSFileManager.defaultManager setAttributes:@{NSFileHFSCreatorCode: @(creator), NSFileHFSTypeCode: @(type)} ofItemAtPath:[NSString stringWithUTF8String:path] error:&error])
	{
		[[NSAlert alertWithError:error] runModal];
	}
}

static void AddFolderIcon (NSURL *fref, const char *folderName)
{
	NSBundle *bundle = [NSBundle bundleWithIdentifier:@"com.snes9x.macos.snes9x-framework"];
	NSString *filename = [@"folder_" stringByAppendingString:[NSString stringWithUTF8String:folderName]];
	NSURL *imageURL = [bundle URLForResource:filename withExtension:@"icns"];
	NSImage *image = [[NSImage alloc] initWithContentsOfURL:imageURL];

	if ( image != nil )
	{
		[NSWorkspace.sharedWorkspace setIcon:image forFile:fref.path options:0];
	}
}

const char * S9xGetFilename (const char *inExt, enum s9x_getdirtype dirtype)
{
	static int	index = 0;
	static char	filePath[4][PATH_MAX + 1];

	uint32		type;
	char		folderName[16];
	char		drive[_MAX_DRIVE + 1], dir[_MAX_DIR + 1], fname[_MAX_FNAME + 1], ext[_MAX_EXT + 1];
	const char	*p;

	index++;
	if (index > 3)
		index = 0;

	folderName[0] = filePath[index][0] = 0;

	if (strlen(inExt) < 4)
		return (filePath[index]);

	p = inExt + strlen(inExt) - 4;
	type = ((uint32) p[0] << 24) + ((uint32) p[1] << 16) + ((uint32) p[2] << 8) + (uint32) p[3];

	switch (type)
	{
		case '.srm':
		case '.rtc':
			strcpy(folderName, "SRAMs");
			break;

		case '.frz':
			strcpy(folderName, "Freezes");
			break;

		case '.spc':
			strcpy(folderName, "SPCs");
			break;

		case '.cht':
			strcpy(folderName, "Cheats");
			break;

		case '.ups':
		case '.ips':
			strcpy(folderName, "Patches");
			break;

		case '.png':
			strcpy(folderName, "Screenshots");
			break;

		case '.dat':
		case '.out':
		case '.log':
			strcpy(folderName, "Logs");
			break;

		case '.bio':	// dummy
			strcpy(folderName, "BIOSes");
			break;
	}

	if (folderName[0] && (saveInROMFolder != 1))
	{
		NSURL *folderURL = nil;
		if (saveInROMFolder == 0)
		{
			folderURL = FindSNESFolder(folderName);
			if (folderURL == nil)
				saveInROMFolder = 2;
		}

		if (saveInROMFolder == 4)
		{
			folderURL = FindCustomFolder(folderName);
			if (folderURL == nil)
				saveInROMFolder = 2;
		
		}

		if (saveInROMFolder == 2)
			folderURL = FindApplicationSupportFolder(folderName);

		if (folderURL != nil)
		{
			_splitpath(Memory.ROMFilename, drive, dir, fname, ext);
			snprintf(filePath[index], PATH_MAX + 1, "%s%s%s%s", folderURL.path.UTF8String, MAC_PATH_SEPARATOR, fname, inExt);
		}
		else
		{
			_splitpath(Memory.ROMFilename, drive, dir, fname, ext);
			_makepath(filePath[index], drive, dir, fname, inExt);
		}
	}
	else
	{
		_splitpath(Memory.ROMFilename, drive, dir, fname, ext);
		_makepath(filePath[index], drive, dir, fname, inExt);
	}

	return (filePath[index]);
}

const char * S9xGetSPCFilename (void)
{
	char	spcExt[16];

	sprintf(spcExt, ".%03d.spc", (int) spcFileCount);

	spcFileCount++;
	if (spcFileCount == 1000)
		spcFileCount = 0;

	return (S9xGetFilename(spcExt, SPC_DIR));
}

const char * S9xGetPNGFilename (void)
{
	char	pngExt[16];

	sprintf(pngExt, ".%03d.png", (int) pngFileCount);

	pngFileCount++;
	if (pngFileCount == 1000)
		pngFileCount = 0;

	return (S9xGetFilename(pngExt, SCREENSHOT_DIR));
}

const char * S9xGetFreezeFilename (int which)
{
	char	frzExt[16];

	sprintf(frzExt, ".%03d.frz", which);

	return (S9xGetFilename(frzExt, SNAPSHOT_DIR));
}

const char * S9xGetFilenameInc (const char *inExt, enum s9x_getdirtype dirtype)
{
	uint32		type;
	const char	*p;

	if (strlen(inExt) < 4)
		return (NULL);

	p = inExt + strlen(inExt) - 4;
	type = ((uint32) p[0] << 24) + ((uint32) p[1] << 16) + ((uint32) p[2] << 8) + (uint32) p[3];

	switch (type)
	{
		case '.spc':
			return (S9xGetSPCFilename());

		case '.png':
			return (S9xGetPNGFilename());
	}

	return (NULL);
}

const char * S9xChooseFilename (bool8 read_only)
{
	return (NULL);
}

const char * S9xChooseMovieFilename (bool8 read_only)
{
	return (NULL);
}

bool8 S9xOpenSnapshotFile (const char *fname, bool8 read_only, STREAM *file)
{
	if (read_only)
	{
		if (0 != (*file = OPEN_STREAM(fname, "rb")))
			return (true);
	}
	else
	{
		if (0 != (*file = OPEN_STREAM(fname, "wb")))
			return (true);
	}

	return (false);
}

void S9xCloseSnapshotFile (STREAM file)
{
	CLOSE_STREAM(file);
}

const char * S9xBasename (const char *in)
{
	static char	s[PATH_MAX + 1];

	strncpy(s, in, PATH_MAX + 1);
	s[PATH_MAX] = 0;

	size_t	l = strlen(s);

	for (unsigned int i = 0; i < l; i++)
	{
		if (s[i] < 32 || s[i] >= 127)
			s[i] = '_';
	}

	return (basename(s));
}

const char * S9xGetDirectory (enum s9x_getdirtype dirtype)
{
	static int	index = 0;
	static char	path[4][PATH_MAX + 1];

	char	inExt[16];
	char	drive[_MAX_DRIVE + 1], dir[_MAX_DIR + 1], fname[_MAX_FNAME + 1], ext[_MAX_EXT + 1];

	index++;
	if (index > 3)
		index = 0;

	switch (dirtype)
	{
		case SNAPSHOT_DIR:		strcpy(inExt, ".frz");	break;
		case SRAM_DIR:			strcpy(inExt, ".srm");	break;
		case SCREENSHOT_DIR:	strcpy(inExt, ".png");	break;
		case SPC_DIR:			strcpy(inExt, ".spc");	break;
		case CHEAT_DIR:			strcpy(inExt, ".cht");	break;
		case BIOS_DIR:			strcpy(inExt, ".bio");	break;
		case LOG_DIR:			strcpy(inExt, ".log");	break;
		default:				strcpy(inExt, ".xxx");	break;
	}

	_splitpath(S9xGetFilename(inExt, dirtype), drive, dir, fname, ext);
	_makepath(path[index], drive, dir, "", "");

	size_t	l = strlen(path[index]);
	if (l > 1)
		path[index][l - 1] = 0;

	return (path[index]);
}

void _splitpath (const char *path, char *drive, char *dir, char *fname, char *ext)
{
	drive[0] = 0;
	fname[0] = 0;
	ext[0]   = 0;
	dir[0]   = 0;

	size_t	x;

	x = strlen(path) - 1;
	if (x < 0)
		return;

	while (x && (path[x] != MAC_PATH_SEP_CHAR))
		x--;

	if (x)
	{
		strcpy(dir, path);
		dir[x + 1] = 0;

		strcpy(fname, path + x + 1);
	}
	else
		strcpy(fname, path);

	x = strlen(fname);
	while (x && (fname[x] != '.'))
		x--;

	if (x)
	{
		strcpy(ext, fname + x);
		fname[x] = 0;
	}
}

void _makepath (char *path, const char *drive, const char *dir, const char *fname, const char *ext)
{
	static const char	emp[] = "", dot[] = ".";

	const char	*d, *f, *e, *p;

	d = dir ? dir : emp;
	f = fname ? fname : emp;
	e = ext ? ext : emp;
	p = (e[0] && e[0] != '.') ? dot : emp;

	snprintf(path, PATH_MAX + 1, "%s%s%s%s", d, f, p, e);
}