#include "internal.h"
#include <c3d/renderqueue.h>

// Return bits per pixel
static inline size_t fmtSize(GPU_TEXCOLOR fmt)
{
	switch (fmt)
	{
		case GPU_RGBA8:
			return 32;
		case GPU_RGB8:
			return 24;
		case GPU_RGBA5551:
		case GPU_RGB565:
		case GPU_RGBA4:
		case GPU_LA8:
		case GPU_HILO8:
			return 16;
		case GPU_L8:
		case GPU_A8:
		case GPU_LA4:
		case GPU_ETC1A4:
			return 8;
		case GPU_L4:
		case GPU_A4:
		case GPU_ETC1:
			return 4;
		default:
			return 0;
	}
}

static inline bool checkTexSize(u32 size)
{
	if (size < 8 || size > 1024)
		return false;
	if (size & (size-1))
		return false;
	return true;
}

static inline void allocFree(void* addr)
{
	if (addrIsVRAM(addr))
		vramFree(addr);
	else
		linearFree(addr);
}

static void C3Di_TexCubeDelete(C3D_TexCube* cube)
{
	int i;
	for (i = 0; i < 6; i ++)
	{
		if (cube->data[i])
		{
			allocFree(cube->data[i]);
			cube->data[i] = NULL;
		}
	}
}

bool C3D_TexInitWithParams(C3D_Tex* tex, C3D_TexCube* cube, C3D_TexInitParams p)
{
	if (!checkTexSize(p.width) || !checkTexSize(p.height)) return false;

	bool isCube = typeIsCube(p.type);
	if (isCube && !cube) return false;

	u32 size = fmtSize(p.format);
	if (!size) return false;
	size *= (u32)p.width * p.height / 8;
	u32 total_size = C3D_TexCalcTotalSize(size, p.maxLevel);

	if (!isCube)
	{
		tex->data = p.onVram ? vramAlloc(total_size) : linearAlloc(total_size);
		if (!tex->data) return false;
	} else
	{
		memset(cube, 0, sizeof(*cube));
		int i;
		for (i = 0; i < 6; i ++)
		{
			cube->data[i] = p.onVram ? vramAlloc(total_size) : linearAlloc(total_size);
			if (!cube->data[i] ||
				(i>0 && (((u32)cube->data[0] ^ (u32)cube->data[i])>>(3+22)))) // Check upper 6bits match with first face
			{
				C3Di_TexCubeDelete(cube);
				return false;
			}
		}
		tex->cube = cube;
	}

	tex->width = p.width;
	tex->height = p.height;
	tex->param = GPU_TEXTURE_MODE(p.type);
	if (p.format == GPU_ETC1)
		tex->param |= GPU_TEXTURE_ETC1_PARAM;
	if (p.type == GPU_TEX_SHADOW_2D || p.type == GPU_TEX_SHADOW_CUBE)
		tex->param |= GPU_TEXTURE_SHADOW_PARAM;
	tex->fmt = p.format;
	tex->size = size;
	tex->border = 0;
	tex->lodBias = 0;
	tex->maxLevel = p.maxLevel;
	tex->minLevel = 0;
	return true;
}

void C3D_TexLoadImage(C3D_Tex* tex, const void* data, GPU_TEXFACE face, int level)
{
	u32 size = 0;
	void* out = C3D_TexGetImagePtr(tex,
		C3Di_TexIs2D(tex) ? tex->data : tex->cube->data[face],
		level, &size);

	if (!addrIsVRAM(out))
		memcpy(out, data, size);
	else
		C3D_SyncTextureCopy((u32*)data, 0, (u32*)out, 0, size, 8);
}

static void C3Di_DownscaleRGBA8(u32* dst, const u32* src[4])
{
	u32 i, j;
	for (i = 0; i < 64; i ++)
	{
		const u32* a = src[i>>4] + (i<<2 & 0x3F);
		u32 dest = 0;
		for (j = 0; j < 32; j += 8)
		{
			u32 val = (((a[0]>>j)&0xFF)+((a[1]>>j)&0xFF)+((a[2]>>j)&0xFF)+((a[3]>>j)&0xFF))>>2;
			dest |= val<<j;
		}
		*dst++ = dest;
	}
}

static void C3Di_DownscaleRGB8(u8* dst, const u8* src[4])
{
	u32 i, j;
	for (i = 0; i < 64; i ++)
	{
		const u8* a = src[i>>4] + 3*(i<<2 & 0x3F);
		for (j = 0; j < 3; j ++)
		{
			*dst++ = ((u32)a[0] + a[3] + a[6] + a[9])>>2;
			a++;
		}
	}
}

void C3D_TexGenerateMipmap(C3D_Tex* tex, GPU_TEXFACE face)
{
	int fmt = tex->fmt;
	size_t block_size = (8*8*fmtSize(fmt))/8;

	/*
	const u32 transfer_flags =
		GX_TRANSFER_SCALING(GX_TRANSFER_SCALE_XY) | BIT(5) |
		GX_TRANSFER_IN_FORMAT(tex->fmt) | GX_TRANSFER_OUT_FORMAT(tex->fmt);
	*/

	void* src = C3Di_TexIs2D(tex) ? tex->data : tex->cube->data[face];
	if (addrIsVRAM(src))
		return; // CPU can't write to VRAM

	int i;
	u32 level_size = tex->size;
	u32 src_width = tex->width;
	u32 src_height = tex->height;
	for (i = 0; i < tex->maxLevel; i ++)
	{
		void* dst = (u8*)src + level_size;
		u32 dst_width = src_width>>1;
		u32 dst_height = src_height>>1;

		/* Doesn't work due to size restriction bullshit
		C3D_SyncDisplayTransfer(
			(u32*)src, GX_BUFFER_DIM(src_width,src_height),
			(u32*)dst, GX_BUFFER_DIM(dst_width,dst_height),
			transfer_flags);
		*/

		u32 i,j;
		u32 src_stride = src_width/8;
		u32 dst_stride = dst_width/8;
		for (j = 0; j < (dst_height/8); j ++)
		{
			for (i = 0; i < dst_stride; i ++)
			{
				void* dst_block = (u8*)dst + block_size*(i + j*dst_stride);
				const void* src_blocks[4] =
				{
					(u8*)src + block_size*(2*i+0 + (2*j+0)*src_stride),
					(u8*)src + block_size*(2*i+1 + (2*j+0)*src_stride),
					(u8*)src + block_size*(2*i+0 + (2*j+1)*src_stride),
					(u8*)src + block_size*(2*i+1 + (2*j+1)*src_stride),
				};
				switch (fmt)
				{
					case GPU_RGBA8:
						C3Di_DownscaleRGBA8(dst_block, (const u32**)src_blocks);
						break;
					case GPU_RGB8:
						C3Di_DownscaleRGB8(dst_block, (const u8**)src_blocks);
					default:
						break;
				}
			}
		}

		level_size >>= 2;
		src = dst;
		src_width = dst_width;
		src_height = dst_height;
	}
}

void C3D_TexBind(int unitId, C3D_Tex* tex)
{
	C3D_Context* ctx = C3Di_GetContext();

	if (!(ctx->flags & C3DiF_Active))
		return;

	if (unitId > 0 && C3D_TexGetType(tex) != GPU_TEX_2D)
		return;

	ctx->flags |= C3DiF_Tex(unitId);
	ctx->tex[unitId] = tex;
}

void C3D_TexFlush(C3D_Tex* tex)
{
	if (!addrIsVRAM(tex->data))
		GSPGPU_FlushDataCache(tex->data, C3D_TexCalcTotalSize(tex->size, tex->maxLevel));
}

void C3D_TexDelete(C3D_Tex* tex)
{
	if (C3Di_TexIs2D(tex))
		allocFree(tex->data);
	else
		C3Di_TexCubeDelete(tex->cube);
}

void C3D_TexShadowParams(bool perspective, float bias)
{
	C3D_Context* ctx = C3Di_GetContext();

	if (!(ctx->flags & C3DiF_Active))
		return;

	u32 iBias = (u32)(fabs(bias) * BIT(24));
	if (iBias >= BIT(24))
		iBias = BIT(24)-1;

	ctx->texShadow = (iBias &~ 1) | (perspective ? 0 : 1);
	ctx->flags |= C3DiF_TexStatus;
}

void C3Di_SetTex(int unit, C3D_Tex* tex)
{
	u32 reg[10];
	u32 regcount = 5;
	reg[0] = tex->border;
	reg[1] = tex->dim;
	reg[2] = tex->param;
	reg[3] = tex->lodParam;
	if (C3Di_TexIs2D(tex))
		reg[4] = osConvertVirtToPhys(tex->data) >> 3;
	else
	{
		int i;
		C3D_TexCube* cube = tex->cube;
		regcount = 10;
		reg[4] = osConvertVirtToPhys(cube->data[0]) >> 3;
		for (i = 1; i < 6; i ++)
			reg[4+i] = (osConvertVirtToPhys(cube->data[i]) >> 3) & 0x3FFFFF;
	}

	switch (unit)
	{
		case 0:
			GPUCMD_AddIncrementalWrites(GPUREG_TEXUNIT0_BORDER_COLOR, reg, regcount);
			GPUCMD_AddWrite(GPUREG_TEXUNIT0_TYPE, tex->fmt);
			break;
		case 1:
			GPUCMD_AddIncrementalWrites(GPUREG_TEXUNIT1_BORDER_COLOR, reg, 5);
			GPUCMD_AddWrite(GPUREG_TEXUNIT1_TYPE, tex->fmt);
			break;
		case 2:
			GPUCMD_AddIncrementalWrites(GPUREG_TEXUNIT2_BORDER_COLOR, reg, 5);
			GPUCMD_AddWrite(GPUREG_TEXUNIT2_TYPE, tex->fmt);
			break;
	}
}