module pixelperfectengine.system.file;
/*
 * Copyright (C) 2015-2017, by Laszlo Szeremi under the Boost license.
 *
 * Pixel Perfect Engine, file module
 */

import std.file;
import std.path;
import std.stdio;
import std.conv : to;
import core.stdc.string : memcpy;
import pixelperfectengine.system.etc;
import pixelperfectengine.system.exc;

import pixelperfectengine.graphics.bitmap;
import pixelperfectengine.graphics.raster;
import pixelperfectengine.graphics.fontsets;

//import pixelperfectengine.extbmp.extbmp;

public import dimage.base;
import dimage.tga;
import dimage.png;
import dimage.bmp;

//import bitleveld.reinterpret;

import vfile;

import mididi;

import sdl_mixer;
import std.utf;

/** 
 * Pads a scanline to be on size_t's bounds.
 * Params:
 *   scanline = The scanline to be padded.
 * Returns: the padded scanline
 */
package size_t[] padScanLine(ubyte[] scanline) @safe {
	const int extra = size_t.sizeof - (scanline.length % size_t.sizeof);
	if (extra)
		scanline.length = scanline.length + extra;
	return reinterpretCast!size_t(scanline);
}
/**
 * Loads a bitmap slice from an image.
 * Ideal for loading sprite sheets.
 */
public T loadBitmapSliceFromImage(T)(Image img, int x, int y, int w, int h) {
	synchronized{T src = loadBitmapFromImage!T(img), result;
	result = src.window(x, y, x + w - 1, y + h - 1);
	return result;}
}
/**
 * Loads an Image from a File or VFile.
 * Automatically detects format from file extension.
 */
public Image loadImage(F = File)(F file) @trusted{
	switch(extension(file.name)){
		case ".tga", ".TGA":
			TGA imageFile = TGA.load!(F, true, true)(file);
			if(!imageFile.getHeader.topOrigin){
				imageFile.flipVertical;
			}
			return imageFile;
		case ".png", ".PNG":
			PNG imageFile = PNG.load!F(file);
			return imageFile;
		case ".bmp", ".BMP":
			BMP imageFile = BMP.load!F(file);
			return imageFile;
		default:
			throw new Exception("Unsupported file format!");
	}
}
/**
 * Loads a bitmap from Image.
 */
public T loadBitmapFromImage(T)(Image img) @trusted
		if (is (T == Bitmap1Bit) || is(T == Bitmap2Bit) || is(T == Bitmap4Bit) || is(T == Bitmap8Bit) || 
		is(T == Bitmap16Bit) || is(T == Bitmap32Bit)) {
	// Later we might want to detect image type from classinfo, until then let's rely on similarities between types
	static if(is(T == Bitmap1Bit)){
		if (img.getBitdepth != 1)
			throw new BitmapFormatException("Bitdepth mismatch exception!");
		ubyte[] data = img.imageData.raw;
		size_t[] newData;
		const size_t pitch = data.length / img.imageData.height;
		for (int i ; i < img.imageData.height ; i++) {
			newData ~= padScanLine(data[pitch * i..pitch * (i + 1)]);
		}
		return new Bitmap1Bit(newData, img.imageData.width, img.imageData.height);
	} else static if(is(T == Bitmap2Bit)){
		if (img.getBitdepth == 2)
			return new Bitmap2Bit(img.imageData.raw, img.width, img.height);
		else if (img.getBitdepth < 2)
			return new Bitmap2Bit(img.imageData.convTo(PixelFormat.Indexed2Bit).raw, img.width, img.height);
		else
			throw new BitmapFormatException("Bitdepth mismatch exception!");	
	}else static if(is(T == Bitmap4Bit)){
		if (img.getBitdepth == 4)
			return new Bitmap4Bit(img.imageData.raw, img.width, img.height);
		else if (img.getBitdepth < 4)
			return new Bitmap4Bit(img.imageData.convTo(PixelFormat.Indexed4Bit).raw, img.width, img.height);
		else
			throw new BitmapFormatException("Bitdepth mismatch exception!");	

	}else static if(is(T == Bitmap8Bit)){
		if (img.getBitdepth == 8)
			return new Bitmap8Bit(img.imageData.raw, img.width, img.height);
		else if (img.getBitdepth < 8)
			return new Bitmap8Bit(img.imageData.convTo(PixelFormat.Indexed8Bit).raw, img.width, img.height);
		else
			throw new BitmapFormatException("Bitdepth mismatch exception!");

	}else static if(is(T == Bitmap16Bit)){
		if (img.getBitdepth == 16)
			return new Bitmap16Bit(reinterpretCast!ushort(img.imageData.raw), img.width, img.height);
		else if (img.getBitdepth < 16)
			return new Bitmap16Bit(reinterpretCast!ushort(img.imageData.convTo(PixelFormat.Indexed16Bit).raw), 
					img.width, img.height);
		else
			throw new BitmapFormatException("Bitdepth mismatch exception!");
		
	}else static if(is(T == Bitmap32Bit)){
		return new Bitmap32Bit(reinterpretCast!Color(img.imageData.convTo(PixelFormat.ARGB8888 | PixelFormat.BigEndian).raw), 
				img.width, img.height);

	}

}
//TODO: Make collision model loader for 1 bit bitmaps
/**
 * Loads a bitmap from disk.
 * Currently supported formats: *.tga, *.png, *.bmp
 */
public T loadBitmapFromFile(T)(string filename)
		if (is (T == Bitmap1Bit) || is(T == Bitmap2Bit) || is(T == Bitmap4Bit) || is(T == Bitmap8Bit) || 
		is(T == Bitmap16Bit) || is(T == Bitmap32Bit)) {
	File f = File(filename);
	return loadBitmapFromImage!T(loadImage(f));
}
/**
 * Loads a bitmap sheet from file.
 * This one doesn't require TGA devarea extensions.
 */
public T[] loadBitmapSheetFromFile(T)(string filename, int x, int y)
		if (is (T == Bitmap1Bit) || is(T == Bitmap2Bit) || is(T == Bitmap4Bit) || is(T == Bitmap8Bit) || 
		is(T == Bitmap16Bit) || is(T == Bitmap32Bit)) {
	//T source = loadBitmapFromFile!T(filename);
	return loadBitmapSheetFromImage!T(loadImage(File(filename)), x, y);
}
/**
 * Creates a bitmap sheet from an image file.
 * This one doesn't require embedded data.
 */
public T[] loadBitmapSheetFromImage(T)(Image img, int x, int y)
		if (is (T == Bitmap1Bit) || is(T == Bitmap2Bit) || is(T == Bitmap4Bit) || is(T == Bitmap8Bit) || 
		is(T == Bitmap16Bit) || is(T == Bitmap32Bit)) {
	T source = loadBitmapFromImage!T(img);
	if (source.width % x == 0 && source.height % y == 0) {
		T[] output;
		static if (is(T == Bitmap1Bit))
			const size_t length = x / 8, length0 = x / 8, pitch = source.width / 8;
		else static if (is(T == Bitmap2Bit))
			const size_t length = x / 4, length0 = x / 4, pitch = source.width / 4;
		else static if (is(T == Bitmap4Bit))
			const size_t length = x / 2, length0 = x / 2, pitch = source.width / 2;
		else static if (is(T == Bitmap8Bit))
			const size_t length = x, length0 = x, pitch = source.width;
		else static if (is(T == Bitmap16Bit))
			const size_t length = x, length0 = x * 2, pitch = source.width;
		else static if (is(T == Bitmap32Bit))
			const size_t length = x, length0 = x * 4, pitch = source.width;
		const size_t pitch0 = pitch * y;
		output.reserve(source.height / y * source.width / x);
		for (int mY ; mY < source.height / y ; mY++){
			for (int mX ; mX < source.width / x ; mX++){
				T next = new T(x, y);
				for (int lY ; lY < y ; lY++){
					memcpy(next.getPtr + (lY * length), source.getPtr + (pitch * lY) + (pitch0 * mY) + (length * mX), length0);
				}
				output ~= next;
			}
		}
		return output;
	} else throw new Exception("Requested size cannot be divided by input file's sizes!");
}
/**
 * Loads a palette from a file.
 */
public Color[] loadPaletteFromFile(string filename) {
	File f = File(filename);
	switch(extension(filename)){
		case ".tga", ".TGA":
			TGA imageFile = TGA.load(f);
			return loadPaletteFromImage(imageFile);
		case ".png", ".PNG":
			PNG imageFile = PNG.load(f);
			return loadPaletteFromImage(imageFile);
		case ".bmp", ".BMP":
			BMP imageFile = BMP.load(f);
			return loadPaletteFromImage(imageFile);
		default:
			throw new Exception("Unsupported file format!");
	}
}
/**
 * Loads a palette from image.
 */
public Color[] loadPaletteFromImage (Image img) {
	Color[] palette;
	IPalette sourcePalette = img.palette.convTo(PixelFormat.ARGB8888 | PixelFormat.BigEndian);
	palette = reinterpretCast!Color(sourcePalette.raw);

	assert(palette.length == sourcePalette.length, "Palette lenght import mismatch!");
	if(!(img.palette.paletteFormat & PixelFormat.ValidAlpha)){
		palette[0].a = 0x0;
		for(int i = 1; i < palette.length; i++) {
			palette[i].a = 0xFF;
		}
	}
	return palette;
}
package immutable string pathRoot;
shared static this () {
	import std.path;
	import std.file : exists;
	string path;
	version (Posix) {
		import core.sys.posix.unistd : getcwd;
		import std.string : fromStringz;
		{
			char[2048] _path;
			getcwd(_path.ptr, _path.length);
			path = fromStringz(_path).idup;
		}
	} else version (Windows) {
		import core.sys.windows.windows : GetCurrentDirectoryW, DWORD;
		import std.string : fromStringz;
		import std.utf : toUTF8;
		{
			wchar[2048] _path;
			GetCurrentDirectoryW(cast(DWORD)_path.length, _path.ptr);
			path = toUTF8(fromStringz(_path.ptr).idup);
		}
	} else static assert (0, "Please contact me about implementation!");
	if (exists(buildNormalizedPath(path, "../system/")))
		pathRoot = "..";
	else if (exists(buildNormalizedPath(path, "./system/")))
		pathRoot = ".";
	else {
		debug assert(0, "Folder /system/ does not exist! Check your development environment and the documentation for info.");
		else assert(0, "Folder /system/ does not exist! Please reinstall the software or contact the developer if that does 
				not solve the issue.");
		}
}
/** 
 * 
 * Params:
 *   country = 
 *   language = 
 *   filename = 
 * Returns: 
 */
public string getPathToLocalizationFile (string country, string language, string filename) @safe pure nothrow {
	if (filename[0] == '.') filename = filename[1..$];
	return pathRoot ~ "/local/" ~ country ~ "-" ~ language ~ "." ~ filename;
}
///NOTE: probably redo it for 1.0.0, or make a system that bypasses it.
public string getPathToAsset (string path) @safe pure nothrow {
	return pathRoot ~ "/" ~ path;
}
/**
 * Implements the RIFF serialization system
 */
public struct RIFFHeader{
	char[4] data;
	uint length;
}