// for finding memory leaks in debug mode with Visual Studio
#if defined _DEBUG && defined _MSC_VER
#include <crtdbg.h>
#endif

#include <stdio.h>
#include <stdbool.h>
#include "ft2_header.h"
#include "ft2_audio.h"
#include "ft2_gui.h"
#include "ft2_mouse.h"
#include "ft2_sample_ed.h"
#include "ft2_module_loader.h"
#include "ft2_tables.h"
#include "ft2_structs.h"

static int8_t smpChunkBuf[1024];
static uint8_t packedPattData[65536], modPattData[64*32*4];
static SDL_Thread *thread;

static const char modIDs[32][5] =
{
	"1CHN", "2CHN", "3CHN", "4CHN", "5CHN", "6CHN", "7CHN", "8CHN",
	"9CHN", "10CH", "11CH", "12CH", "13CH", "14CH", "15CH", "16CH",
	"17CH", "18CH", "19CH", "20CH", "21CH", "22CH", "23CH", "24CH",
	"25CH", "26CH", "27CH", "28CH", "29CH", "30CH", "31CH", "32CH"
};

static uint16_t packPatt(uint8_t *writePtr, uint8_t *pattPtr, uint16_t numRows);

bool saveXM(UNICHAR *filenameU)
{
	int16_t i, j, k, a;
	size_t result;
	xmHdr_t h;
	xmPatHdr_t ph;
	instr_t *ins;
	xmInsHdr_t ih;
	sample_t *s;
	xmSmpHdr_t *dst;

	FILE *f = UNICHAR_FOPEN(filenameU, "wb");
	if (f == NULL)
	{
		okBoxThreadSafe(0, "System message", "Error opening file for saving, is it in use?");
		return false;
	}

	memcpy(h.ID, "Extended Module: ", 17);

	// song name
	int32_t nameLength = (int32_t)strlen(song.name);
	if (nameLength > 20)
		nameLength = 20;

	memset(h.name, ' ', 20); // yes, FT2 pads the name with spaces
	if (nameLength > 0)
		memcpy(h.name, song.name, nameLength);

	h.x1A = 0x1A;

	// program/tracker name
	nameLength = (int32_t)strlen(PROG_NAME_STR);
	if (nameLength > 20)
		nameLength = 20;

	memset(h.progName, ' ', 20); // yes, FT2 pads the name with spaces
	if (nameLength > 0)
		memcpy(h.progName, PROG_NAME_STR, nameLength);

	h.version = 0x0104;
	h.headerSize = 20 + 256;
	h.numOrders = song.songLength;
	h.songLoopStart = song.songLoopStart;
	h.numChannels = (uint16_t)song.numChannels;
	h.speed = song.speed;
	h.BPM = song.BPM;

	// count number of patterns
	i = MAX_PATTERNS;
	do
	{
		if (patternEmpty(i-1))
			i--;
		else
			break;
	}
	while (i > 0);
	h.numPatterns = i;

	// count number of instruments
	i = 128;
	while (i > 0 && getUsedSamples(i) == 0 && song.instrName[i][0] == '\0')
		i--;
	h.numInstr = i;

	h.flags = audio.linearPeriodsFlag;
	memcpy(h.orders, song.orders, 256);

	if (fwrite(&h, sizeof (h), 1, f) != 1)
	{
		fclose(f);
		okBoxThreadSafe(0, "System message", "Error saving module: general I/O error!");
		return false;
	}

	for (i = 0; i < h.numPatterns; i++)
	{
		if (patternEmpty(i))
		{
			if (pattern[i] != NULL)
			{
				free(pattern[i]);
				pattern[i] = NULL;
			}

			patternNumRows[i] = 64;
		}

		ph.headerSize = sizeof (xmPatHdr_t);
		ph.numRows = patternNumRows[i];
		ph.type = 0;

		if (pattern[i] == NULL)
		{
			ph.dataSize = 0;
			if (fwrite(&ph, ph.headerSize, 1, f) != 1)
			{
				fclose(f);
				okBoxThreadSafe(0, "System message", "Error saving module: general I/O error!");
				return false;
			}
		}
		else
		{
			ph.dataSize = packPatt(packedPattData, (uint8_t *)pattern[i], patternNumRows[i]);

			result = fwrite(&ph, ph.headerSize, 1, f);
			result += fwrite(packedPattData, ph.dataSize, 1, f);

			if (result != 2) // write was not OK
			{
				fclose(f);
				okBoxThreadSafe(0, "System message", "Error saving module: general I/O error!");
				return false;
			}
		}
	}

	memset(&ih, 0, sizeof (ih)); // important, clears reserved stuff

	for (i = 1; i <= h.numInstr; i++)
	{
		if (instr[i] == NULL)
			j = 0;
		else
			j = i;

		a = getUsedSamples(i);

		nameLength = (int32_t)strlen(song.instrName[i]);
		if (nameLength > 22)
			nameLength = 22;

		memset(ih.name, 0, 22); // pad with zero
		if (nameLength > 0)
			memcpy(ih.name, song.instrName[i], nameLength);

		ih.type = 0;
		ih.numSamples = a;
		ih.sampleSize = sizeof (xmSmpHdr_t);

		if (a > 0)
		{
			ins = instr[j];

			memcpy(ih.note2SampleLUT, ins->note2SampleLUT, 96);
			memcpy(ih.volEnvPoints, ins->volEnvPoints, 12*2*sizeof(int16_t));
			memcpy(ih.panEnvPoints, ins->panEnvPoints, 12*2*sizeof(int16_t));
			ih.volEnvLength = ins->volEnvLength;
			ih.panEnvLength = ins->panEnvLength;
			ih.volEnvSustain = ins->volEnvSustain;
			ih.volEnvLoopStart = ins->volEnvLoopStart;
			ih.volEnvLoopEnd = ins->volEnvLoopEnd;
			ih.panEnvSustain = ins->panEnvSustain;
			ih.panEnvLoopStart = ins->panEnvLoopStart;
			ih.panEnvLoopEnd = ins->panEnvLoopEnd;
			ih.volEnvFlags = ins->volEnvFlags;
			ih.panEnvFlags = ins->panEnvFlags;
			ih.vibType = ins->vibType;
			ih.vibSweep = ins->vibSweep;
			ih.vibDepth = ins->vibDepth;
			ih.vibRate = ins->vibRate;
			ih.fadeout = ins->fadeout;
			ih.midiOn = ins->midiOn ? 1 : 0;
			ih.midiChannel = ins->midiChannel;
			ih.midiProgram = ins->midiProgram;
			ih.midiBend = ins->midiBend;
			ih.mute = ins->mute ? 1 : 0;
			ih.instrSize = INSTR_HEADER_SIZE;
			
			for (k = 0; k < a; k++)
			{
				s = &instr[j]->smp[k];
				dst = &ih.smp[k];

				bool sample16Bit = !!(s->flags & SAMPLE_16BIT);

				dst->length = s->length;
				dst->loopStart = s->loopStart;
				dst->loopLength = s->loopLength;

				if (sample16Bit)
				{
					dst->length <<= 1;
					dst->loopStart <<= 1;
					dst->loopLength <<= 1;
				}

				dst->volume = s->volume;
				dst->finetune = s->finetune;
				dst->flags = s->flags;
				dst->panning = s->panning;
				dst->relativeNote = s->relativeNote;

				nameLength = (int32_t)strlen(s->name);
				if (nameLength > 22)
					nameLength = 22;

				dst->nameLength = (uint8_t)nameLength;

				memset(dst->name, ' ', 22); // yes, FT2 pads the name with spaces
				if (nameLength > 0)
					memcpy(dst->name, s->name, nameLength);

				if (s->dataPtr == NULL)
					dst->length = 0;
			}
		}
		else
		{
			ih.instrSize = 22 + 11;
		}

		if (fwrite(&ih, ih.instrSize + (a * sizeof (xmSmpHdr_t)), 1, f) != 1)
		{
			fclose(f);
			okBoxThreadSafe(0, "System message", "Error saving module: general I/O error!");
			return false;
		}

		for (k = 1; k <= a; k++)
		{
			s = &instr[j]->smp[k-1];
			if (s->dataPtr != NULL)
			{
				unfixSample(s);
				samp2Delta(s->dataPtr, s->length, s->flags);

				result = fwrite(s->dataPtr, 1, SAMPLE_LENGTH_BYTES(s), f);

				delta2Samp(s->dataPtr, s->length, s->flags);
				fixSample(s);

				if (result != (size_t)SAMPLE_LENGTH_BYTES(s)) // write not OK
				{
					fclose(f);
					okBoxThreadSafe(0, "System message", "Error saving module: general I/O error!");
					return false;
				}
			}
		}
	}

	removeSongModifiedFlag();

	fclose(f);

	editor.diskOpReadDir = true; // force diskop re-read

	setMouseBusy(false);
	return true;
}

static bool saveMOD(UNICHAR *filenameU)
{
	int16_t i;
	int32_t j, k;
	instr_t *ins;
	sample_t *smp;
	modHdr_t hdr;

	if (audio.linearPeriodsFlag)
		okBoxThreadSafe(0, "System message", "Warning: Amiga frequency table isn't used!");

	int32_t songLength = song.songLength;
	if (songLength > 128)
	{
		songLength = 128;
		okBoxThreadSafe(0, "System message", "Warning: Song length is above 128!");
	}
	
	// calculate number of patterns referenced (max 128 orders)
	int32_t numPatterns = 0;
	for (i = 0; i < songLength; i++)
	{
		if (song.orders[i] > numPatterns)
			numPatterns = song.orders[i];
	}
	numPatterns++;

	if (numPatterns > 100)
	{
		numPatterns = 100;
		okBoxThreadSafe(0, "System message", "Warning: Song has more than 100 patterns!");
	}

	// check if song has more than 31 instruments
	for (i = 32; i <= 128; i++)
	{
		if (getRealUsedSamples(i) > 0)
		{
			okBoxThreadSafe(0, "System message", "Warning: Song has more than 31 instruments!");
			break;
		}
	}

	// check if the first 31 samples have a length above 65534 samples
	bool test = false;
	bool test2 = false;
	for (i = 1; i <= 31; i++)
	{
		ins = instr[i];
		if (ins == NULL)
			continue;

		smp = &ins->smp[0];

		if (smp->length > 131070)
			test = true;
		else if (smp->length > 65534)
			test2 = true;
	}
	if (test) okBoxThreadSafe(0, "System message", "Warning: Song has sample lengths that are too long for the MOD format!");
	else if (test2) okBoxThreadSafe(0, "System message", "Warning: Song has sample lengths above 65534! Not all MOD players support this.");

	// check if XM instrument features are being used
	test = false;
	for (i = 1; i <= 31; i++)
	{
		ins = instr[i];
		if (ins == NULL)
			continue;

		smp = &ins->smp[0];

		j = getRealUsedSamples(i);
		if (j > 1)
		{
			test = true;
			break;
		}

		if (j == 1)
		{
			if (ins->fadeout != 0 || ins->volEnvFlags != 0 || ins->panEnvFlags != 0 || ins->vibRate > 0 ||
				GET_LOOPTYPE(smp->flags) == LOOP_BIDI || smp->relativeNote != 0 || ins->midiOn)
			{
				test = true;
				break;
			}
		}
	}
	if (test) okBoxThreadSafe(0, "System message", "Warning: Song is using XM instrument features!");

	bool tooLongPatterns = false;
	bool tooManyInstr = false;
	bool incompatEfx = false;
	bool noteUnderflow = false;

	for (i = 0; i < numPatterns; i++)
	{
		if (pattern[i] == NULL)
			continue;

		if (patternNumRows[i] < 64)
		{
			okBoxThreadSafe(0, "System message", "Error: Pattern lengths can't be below 64! Module wasn't saved.");
			return false;
		}

		if (patternNumRows[i] > 64)
			tooLongPatterns = true;

		for (j = 0; j < 64; j++)
		{
			for (k = 0; k < song.numChannels; k++)
			{
				note_t *p = &pattern[i][(j * MAX_CHANNELS) + k];

				if (p->instr > 31)
					tooManyInstr = true;

				if (p->efx > 0xF || p->vol != 0)
					incompatEfx = true;

				// added security that wasn't present in FT2
				if (p->note > 0 && p->note < 10)
					noteUnderflow = true;
			}
		}
	}

	if (tooLongPatterns) okBoxThreadSafe(0, "System message", "Warning: Song has pattern lengths above 64!");
	if (tooManyInstr) okBoxThreadSafe(0, "System message", "Warning: Patterns have instrument numbers above 31!");
	if (incompatEfx) okBoxThreadSafe(0, "System message", "Warning: Patterns have incompatible effects!");
	if (noteUnderflow) okBoxThreadSafe(0, "System message", "Warning: Patterns have notes below A-0!");

	// save module now

	memset(&hdr, 0, sizeof (hdr));

	// song name
	int32_t nameLength = (int32_t)strlen(song.name);
	if (nameLength > 20)
		nameLength = 20;

	memset(hdr.name, 0, 20); // pad with zeroes
	if (nameLength > 0)
		memcpy(hdr.name, song.name, nameLength);

	hdr.numOrders = (uint8_t)songLength; // pre-clamped to 0..128

	hdr.songLoopStart = (uint8_t)song.songLoopStart;
	if (hdr.songLoopStart >= hdr.numOrders) // repeat-point must be lower than the song length
		hdr.songLoopStart = 0;

	memcpy(hdr.orders, song.orders, hdr.numOrders);

	if (song.numChannels == 4)
		memcpy(hdr.ID, (numPatterns > 64) ? "M!K!" : "M.K.", 4);
	else
		memcpy(hdr.ID, modIDs[song.numChannels-1], 4);

	// fill MOD sample headers
	for (i = 1; i <= 31; i++)
	{
		modSmpHdr_t *modSmp = &hdr.smp[i-1];

		nameLength = (int32_t)strlen(song.instrName[i]);
		if (nameLength > 22)
			nameLength = 22;

		memset(modSmp->name, 0, 22); // pad with zeroes
		if (nameLength > 0)
			memcpy(modSmp->name, song.instrName[i], nameLength);

		if (instr[i] != NULL && getRealUsedSamples(i) != 0)
		{
			smp = &instr[i]->smp[0];

			int32_t length = smp->length >> 1;
			int32_t loopStart = smp->loopStart >> 1;
			int32_t loopLength = smp->loopLength >> 1;

			// length/loopStart/loopLength are now in units of words

			if (length > UINT16_MAX)
				length = UINT16_MAX;

			if (GET_LOOPTYPE(smp->flags) == LOOP_OFF)
			{
				loopStart = 0;
				loopLength = 1;
			}
			else // looped sample
			{
				if (loopLength == 0) // ProTracker hates loopLengths of zero
					loopLength = 1;

				if (loopStart+loopLength > length)
				{
					loopStart = 0;
					loopLength = 1;
				}
			}

			modSmp->length = (uint16_t)SWAP16(length);
			modSmp->finetune = FINETUNE_XM2MOD(smp->finetune);
			modSmp->volume = smp->volume;
			modSmp->loopStart = (uint16_t)SWAP16(loopStart);
			modSmp->loopLength = (uint16_t)SWAP16(loopLength);
		}
	}

	FILE *f = UNICHAR_FOPEN(filenameU, "wb");
	if (f == NULL)
	{
		okBoxThreadSafe(0, "System message", "Error opening file for saving, is it in use?");
		return false;
	}

	// write header
	if (fwrite(&hdr, 1, sizeof (hdr), f) != sizeof (hdr))
	{
		okBoxThreadSafe(0, "System message", "Error saving module: general I/O error!");
		goto modSaveError;
	}

	// write pattern data
	const int32_t patternBytes = song.numChannels * 64 * 4;
	for (i = 0; i < numPatterns; i++)
	{
		if (pattern[i] == NULL) // empty pattern
		{
			memset(modPattData, 0, patternBytes);
		}
		else
		{
			int32_t offs = 0;
			for (j = 0; j < 64; j++)
			{
				for (k = 0; k < song.numChannels; k++)
				{
					note_t *p = &pattern[i][(j * MAX_CHANNELS) + k];

					uint8_t inst = p->instr;
					uint8_t note = p->note;

					// FT2 bugfix: prevent overflow
					if (inst > 31)
						inst = 0;

					// FT2 bugfix: convert note-off into no note for MOD saving
					if (note == NOTE_OFF)
						note = 0;

					// FT2 bugfix: clamp notes below 10 (A-0) to prevent 12-bit period overflow
					if (note > 0 && note < 10)
						note = 10;

					if (note == 0)
					{
						modPattData[offs+0] = inst & 0xF0;
						modPattData[offs+1] = 0;
					}
					else
					{
						modPattData[offs+0] = (inst & 0xF0) | ((amigaPeriod[note-1] >> 8) & 0x0F);
						modPattData[offs+1] = amigaPeriod[note-1] & 0xFF;
					}

					// FT2 bugfix: if effect is overflowing (0xF in .MOD), set effect and param to 0
					if (p->efx > 0x0F)
					{
						modPattData[offs+2] = (inst & 0x0F) << 4;
						modPattData[offs+3] = 0;
					}
					else
					{
						modPattData[offs+2] = ((inst & 0x0F) << 4) | (p->efx & 0x0F);
						modPattData[offs+3] = p->efxData;
					}

					offs += 4;
				}
			}
		}

		if (fwrite(modPattData, 1, patternBytes, f) != (size_t)patternBytes)
		{
			okBoxThreadSafe(0, "System message", "Error saving module: general I/O error!");
			goto modSaveError;
		}
	}

	// write sample data
	for (i = 1; i <= 31; i++)
	{
		if (instr[i] == NULL || getRealUsedSamples(i) == 0)
			continue;

		smp = &instr[i]->smp[0];
		if (smp->dataPtr == NULL || smp->length <= 0)
			continue;

		modSmpHdr_t *modSmp = &hdr.smp[i-1];

		unfixSample(smp);

		int32_t sampleBytes = SWAP16(modSmp->length) * 2;

		if (smp->flags & SAMPLE_16BIT) // 16-bit sample (convert to 8-bit)
		{
			int8_t *dstPtr = (int8_t *)smpChunkBuf;
			int32_t writeLen = sampleBytes;
			int32_t samplesWritten = 0;

			while (samplesWritten < writeLen) // write in chunks
			{
	 			int32_t samplesToWrite = sizeof (smpChunkBuf);
				if (samplesWritten+samplesToWrite > writeLen)
					samplesToWrite = writeLen - samplesWritten;

				int16_t *srcPtr16 = (int16_t *)smp->dataPtr + samplesWritten;
				for (j = 0; j < samplesToWrite; j++)
					dstPtr[j] = srcPtr16[j] >> 8; // convert 16-bit to 8-bit

				if (fwrite(dstPtr, 1, samplesToWrite, f) != (size_t)samplesToWrite)
				{
					fixSample(smp);
					okBoxThreadSafe(0, "System message", "Error saving module: general I/O error!");
					goto modSaveError;
				}

				samplesWritten += samplesToWrite;
			}
		}
		else // 8-bit sample
		{
			if (fwrite(smp->dataPtr, 1, sampleBytes, f) != (size_t)sampleBytes)
			{
				fixSample(smp);
				okBoxThreadSafe(0, "System message", "Error saving module: general I/O error!");
				goto modSaveError;
			}
		}

		fixSample(smp);
	}

	fclose(f);
	removeSongModifiedFlag();

	editor.diskOpReadDir = true; // force diskop re-read

	setMouseBusy(false);
	return true;

modSaveError:
	fclose(f);
	return false;
}

static int32_t SDLCALL saveMusicThread(void *ptr)
{
	assert(editor.tmpFilenameU != NULL);
	if (editor.tmpFilenameU == NULL)
		return false;

	pauseAudio();

	if (editor.moduleSaveMode == 1)
		saveXM(editor.tmpFilenameU);
	else
		saveMOD(editor.tmpFilenameU);

	resumeAudio();
	return true;

	(void)ptr;
}

void saveMusic(UNICHAR *filenameU)
{
	UNICHAR_STRCPY(editor.tmpFilenameU, filenameU);

	mouseAnimOn();
	thread = SDL_CreateThread(saveMusicThread, NULL, NULL);
	if (thread == NULL)
	{
		okBoxThreadSafe(0, "System message", "Couldn't create thread!");
		return;
	}

	SDL_DetachThread(thread);
}

static uint16_t packPatt(uint8_t *writePtr, uint8_t *pattPtr, uint16_t numRows)
{
	uint8_t bytes[5];

	if (pattPtr == NULL)
		return 0;

	uint16_t totalPackLen = 0;

	const int32_t pitch = sizeof (note_t) * (MAX_CHANNELS - song.numChannels);
	for (int32_t row = 0; row < numRows; row++)
	{
		for (int32_t chn = 0; chn < song.numChannels; chn++)
		{
			bytes[0] = *pattPtr++;
			bytes[1] = *pattPtr++;
			bytes[2] = *pattPtr++;
			bytes[3] = *pattPtr++;
			bytes[4] = *pattPtr++;

			uint8_t *firstBytePtr = writePtr++;

			uint8_t packBits = 0;
			if (bytes[0] > 0) { packBits |= 1; *writePtr++ = bytes[0]; } // note
			if (bytes[1] > 0) { packBits |= 2; *writePtr++ = bytes[1]; } // instrument
			if (bytes[2] > 0) { packBits |= 4; *writePtr++ = bytes[2]; } // volume column
			if (bytes[3] > 0) { packBits |= 8; *writePtr++ = bytes[3]; } // effect

			if (packBits == 15) // first four bits set?
			{
				// no packing needed, write pattern data as is

				// point to first byte (and overwrite data)
				writePtr = firstBytePtr;

				*writePtr++ = bytes[0];
				*writePtr++ = bytes[1];
				*writePtr++ = bytes[2];
				*writePtr++ = bytes[3];
				*writePtr++ = bytes[4];

				totalPackLen += 5;
				continue;
			}

			if (bytes[4] > 0) { packBits |= 16; *writePtr++ = bytes[4]; } // effect parameter

			*firstBytePtr = packBits | 128; // write pack bits byte
			totalPackLen += (uint16_t)(writePtr - firstBytePtr); // bytes writen
		}

		// skip unused channels (unpacked patterns always have 32 channels)
		pattPtr += pitch;
	}

	return totalPackLen;
}
