/*  V2MemTest - A CLI Tool to test & fix Voodoo² TMU System
*   Copyright (C) 2026  ChaCha
*
*   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 3 of the License, or
*   (at your option) any later version.
*
*   This program is distributed in the hope that it will be useful,
*   but WITHOUT ANY WARRANTY; without even the implied warranty of
*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*   GNU General Public License for more details.
*
*   You should have received a copy of the GNU General Public License
*   along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/

#include <stdio.h> 
#include <string.h> 
#include <time.h> 
#include <unistd.h> 

#include "cvg.h" 
#include <glide.h>
#include "sst1init.h"
#include "fxpci.h"

#include "FaultSources.h"
#include "Utils.h"
#include "Draw.h"

#include "Test_Data_Huge.h"

#define _DEF_NB_PIXEL_ROW 256
#define _DEF_NB_PIXEL_COL 256
#define _NB_CHECK_LOOP 3

//#define _PROFILING

#define _DEF_PREHEAT_TIME_S 10
static void
HeatMemAndTMU(	sst1DeviceInfoStruct* devInfo,
			FxU32* sst,
			SstRegs *sstregs,
			const char ucNumTMU,
			const FxU32 mem)
{
	
	ISET(sstregs->texBaseAddr, (mem>>3));	/* set to mem addr */
	
	volatile FxU32 *texRowAddr
			= (ucNumTMU<<(21-2)) + (((FxU32)0/*LOD0*/)<<(17-2)) 
			+ (FxU32 *)SST_TEX_ADDRESS(sst);
			
	for(unsigned short iter_row = 0; iter_row < _DEF_NB_PIXEL_ROW; iter_row++)
	{
		for(unsigned short iter_col = 0; iter_col < _DEF_NB_PIXEL_COL; iter_col+=2)
		{
			ISET(texRowAddr[iter_col/2], get_notnull_random_balanced_mByte());
		}
		texRowAddr += (1<<(9-2)); //jump to next line
	}
	
	clock_t begin = clock();
	do
	{
		if(((sst1InitReturnStatus(sst) & SST_FIFOLEVEL)) >= 0x20)
		{
			/* draw a 252x256 square */
			drawSquare(sstregs, 0, 0, 256);
		}
	}
	while(((double)(clock() - begin)/CLOCKS_PER_SEC) < _DEF_PREHEAT_TIME_S );
	
	sst1InitIdle(sst);
}

static unsigned long long
RenderTest(	sst1DeviceInfoStruct* devInfo,
			FxU32* sst,
			SstRegs *sstregs,
			const char ucNumTMU,
			const FxU32 mem)
{
	unsigned long NbErr = 0;
#ifdef _PROFILING
	clock_t begin = clock();
#endif
	ISET(sstregs->texBaseAddr, (mem>>3));	/* set to mem addr */
	
	static uint16_t 
	ar_u16Pixels[_DEF_NB_PIXEL_ROW][_DEF_NB_PIXEL_COL];
	static uint32_t
	ar_u16PixelsRaw[_DEF_NB_PIXEL_ROW][_DEF_NB_PIXEL_COL/2];
	static uint16_t
	ar_u16PixelsReRead[_DEF_NB_PIXEL_ROW][_DEF_NB_PIXEL_COL];
	
	for(unsigned short iter_row = 0; iter_row < _DEF_NB_PIXEL_ROW; iter_row++)
	{
		for(unsigned short iter_col = 0; iter_col < _DEF_NB_PIXEL_COL; iter_col+=2)
		{
			const uint32_t NewData = get_notnull_random_balanced_mByte();
			ar_u16PixelsRaw[iter_row][iter_col/2] = NewData;
			ar_u16Pixels[iter_row][iter_col] = NewData >>16;
			ar_u16Pixels[iter_row][iter_col+1] = NewData & 0xFFFF;
		}
	}
	
#ifdef _PROFILING
	clock_t after_create = clock();
#endif
	
	volatile FxU32 *texRowAddr
			= (ucNumTMU<<(21-2)) + (((FxU32)0/*LOD0*/)<<(17-2)) 
			+ (FxU32 *)SST_TEX_ADDRESS(sst);
	
	for(unsigned short iter_row = 0; iter_row < _DEF_NB_PIXEL_ROW; iter_row++)
	{
		for(unsigned short iter_col = 0; iter_col < _DEF_NB_PIXEL_COL/2; iter_col++)
		{
			//printf("writing %d\n",ar_u16PixelsRaw[iter_row][iter_col]);
			ISET(texRowAddr[iter_col], ar_u16PixelsRaw[iter_row][iter_col]);
		}
		texRowAddr += (1<<(9-2)); //jump to next line
	}
	
#ifdef _PROFILING
	clock_t after_write = clock();
	clock_t before_draw[_NB_CHECK_LOOP];
	clock_t after_draw[_NB_CHECK_LOOP];
	clock_t after_read[_NB_CHECK_LOOP];
	clock_t after_check[_NB_CHECK_LOOP];
#endif

	for(unsigned int i = 0; i<_NB_CHECK_LOOP; i++)
	{
		//printf("draw/checking\n");
#ifdef _PROFILING
		before_draw[i] = clock(); 
#endif
		/* draw a 252x256 square */
		drawSquare(sstregs, 0, 0, 256);
		sst1InitIdle(sst);
		
#ifdef _PROFILING
		after_draw[i] = clock(); 
#endif
		volatile FxU32* pLFB = sst + (SST_LFB_ADDR>>2);
		for(unsigned short iter_row = 0; iter_row < _DEF_NB_PIXEL_ROW; iter_row++)
		{
			//printf("reading row %d\n",iter_row);
			for(unsigned short iter_col = 0; iter_col < _DEF_NB_PIXEL_COL; iter_col+=2)
			{
				const uint32_t u32Data = *pLFB++;
				ar_u16PixelsReRead[iter_row][iter_col] = u32Data >> 16;
				ar_u16PixelsReRead[iter_row][iter_col+1] = u32Data & 0xFFFF;
				
				//printf("read: %d\n",u32Data);
			}
			
			pLFB += ((2048)>>2) - ((_DEF_NB_PIXEL_COL*2) >>2) ;
			
		}
#ifdef _PROFILING
		after_read[i] = clock(); 
#endif
		for(unsigned short iter_row = 0; iter_row < _DEF_NB_PIXEL_ROW; iter_row++)
		{
			//printf("checking row %d\n",iter_row);
			for(unsigned short iter_col = 0; iter_col < _DEF_NB_PIXEL_COL; iter_col+=2)
			{
				if(ar_u16PixelsReRead[iter_row][iter_col] != ar_u16Pixels[iter_row][iter_col])
				{/*
					printf("Error pix1 on row %d, col %d: expected %04x, got %04x\n",
							iter_row, iter_col,
							ar_u16Pixels[iter_row][iter_col],
							ar_u16PixelsReRead[iter_row][iter_col]);*/
					NbErr++;
				}
				if(ar_u16PixelsReRead[iter_row][iter_col+1] != ar_u16Pixels[iter_row][iter_col+1])
				{/*
					printf("Error pix2 on row %d, col %d: expected %04x, got %04x\n",
							iter_row, iter_col,
							ar_u16Pixels[iter_row][iter_col+1],
							ar_u16PixelsReRead[iter_row][iter_col+1]);*/
					NbErr++;
				}
			}
		}
#ifdef _PROFILING
		after_check[i] = clock(); 
#endif
	}
#ifdef _PROFILING
	clock_t end = clock();
	printf("time to create: %f\n",(double)(after_create-begin)/CLOCKS_PER_SEC);
	printf("time to write: %f\n",(double)(after_write-after_create)/CLOCKS_PER_SEC);
	for(unsigned int i = 0; i<_NB_CHECK_LOOP; i++)
	{
		printf("time to draw [%d]: %f\n",i,(double)(after_draw[i]-before_draw[i])/CLOCKS_PER_SEC);
		printf("time to read [%d]: %f\n",i,(double)(after_read[i]-after_draw[i])/CLOCKS_PER_SEC);
		printf("time to check [%d]: %f\n",i,(double)(after_check[i]-after_read[i])/CLOCKS_PER_SEC);
	}
	printf("overall: %f\n",(double)(end-begin)/CLOCKS_PER_SEC);
#endif

	return NbErr;
}

unsigned long long
test_TMU_datalines_Huge(	sst1DeviceInfoStruct* devInfo,
							FxU32* sst,
							SstRegs *sstregs,
							const unsigned char ucNumTMU,
							const unsigned char RamSizeMB)
{
	typedef struct _def_sMemBlock{
		uint32_t ulAddStart;
		uint32_t ulAddEnd;
		uint32_t ulAddLength;
	}def_sMemBlock;
	
	const def_sMemBlock ar_memBlocks[] = {
		{	.ulAddStart 	= 0x000000,
			.ulAddLength 	= 0x100000
		},
		{	.ulAddStart 	= 0x100000,
			.ulAddLength 	= 0x100000
		},
		{	.ulAddStart 	= 0x200000,
			.ulAddLength 	= 0x100000
		},
		{	.ulAddStart 	= 0x300000,
			.ulAddLength 	= 0x100000
		},
	};
	
	unsigned long long ullNbErrorAll = 0;

	devInfo->tmuInit0[(int)ucNumTMU] = SST_TREXINIT0_DEFAULT ; 

	sst1InitIdle(sst);
	ISET(SST_TREX(sstregs,ucNumTMU)->trexInit0, devInfo->tmuInit0[(int)ucNumTMU]);
	sst1InitIdle(sst);
	
	// set downstream TMUs to passthrough
	for (int i=0; i<ucNumTMU; i++)
		ISET(SST_TREX(sstregs,i)->textureMode, SST_TC_PASS | SST_TCA_PASS);
		
	for(	int iMemBlock = 0;
			iMemBlock <= sizeof(ar_memBlocks)/sizeof(def_sMemBlock);
			iMemBlock++)
	{
		const def_sMemBlock* pMemBlk = &ar_memBlocks[iMemBlock];
		if(RamSizeMB<4 && pMemBlk->ulAddStart >= 0x300000) continue;
		if(RamSizeMB<3 && pMemBlk->ulAddStart >= 0x200000) continue;
		if(RamSizeMB<2 && pMemBlk->ulAddStart >= 0x100000) continue;
		//printf("RamSizeMB= %d, ulAddStart=%08x\n", RamSizeMB,pMemBlk->ulAddStart);
		
		for(	FxU32 addrTest = pMemBlk->ulAddStart ;
				addrTest < (pMemBlk->ulAddStart + pMemBlk->ulAddLength);
				addrTest += 65536) //256x256x2 (16bit pixels texture)
		{
			//printf("Testing memory block 0x%08x ...\n", addrTest);
			ullNbErrorAll += RenderTest( devInfo,
									sst,
									sstregs,
									ucNumTMU,
									addrTest);
		}
	}
	
	/* reset the Init0 register back to its previous value */
	sst1InitIdle(sst);
	ISET(SST_TREX(sst,ucNumTMU)->trexInit0, devInfo->tmuInit0[(int)ucNumTMU]);
	sst1InitIdle(sst);
	
	return ullNbErrorAll;
}