#include "legodxinfo.h"

#include <assert.h>
#include <stdio.h> // for vsprintf

// File name validated by BETA10 0x1011cba3; directory unknown

// FUNCTION: CONFIG 0x00402560
// FUNCTION: LEGO1 0x1009ce60
// FUNCTION: BETA10 0x1011c7e0
int LegoDeviceEnumerate::ParseDeviceName(const char* p_deviceId)
{
	if (!IsInitialized()) {
		return -1;
	}

	int unknown = -1;
	int num = -1;
	int hex[4];

	if (sscanf(p_deviceId, "%d 0x%x 0x%x 0x%x 0x%x", &num, &hex[0], &hex[1], &hex[2], &hex[3]) != 5) {
		return -1;
	}

	if (num < 0) {
		return -1;
	}

	GUID guid;
	memcpy(&guid, hex, sizeof(guid));

	int result = ProcessDeviceBytes(num, guid);

	if (result < 0) {
		result = ProcessDeviceBytes(-1, guid);
	}

	return result;
}

// FUNCTION: CONFIG 0x00402620
// FUNCTION: LEGO1 0x1009cf20
// FUNCTION: BETA10 0x1011c8b3
int LegoDeviceEnumerate::ProcessDeviceBytes(int p_deviceNum, GUID& p_guid)
{
	if (!IsInitialized()) {
		return -1;
	}

	int i = 0;
	int j = 0;

	static_assert(sizeof(GUID4) == sizeof(GUID), "Equal size");

	GUID4 deviceGuid;
	memcpy(&deviceGuid, &p_guid, sizeof(GUID4));

	for (list<MxDriver>::iterator it = m_ddInfo.begin(); it != m_ddInfo.end(); it++, i++) {
		if (p_deviceNum >= 0 && p_deviceNum < i) {
			return -1;
		}

		GUID4 compareGuid;
		MxDriver& driver = *it;
		for (list<Direct3DDeviceInfo>::iterator it2 = driver.m_devices.begin(); it2 != driver.m_devices.end(); it2++) {
			Direct3DDeviceInfo& md3d = *it2;
			assert(md3d.m_guid);

			memcpy(&compareGuid, md3d.m_guid, sizeof(GUID4));

			if (GUID4::Compare(compareGuid, deviceGuid) && i == p_deviceNum) {
				return j;
			}

			j++;
		}
	}

	return -1;
}

// FUNCTION: CONFIG 0x00402730
// FUNCTION: LEGO1 0x1009d030
// FUNCTION: BETA10 0x1011ca54
int LegoDeviceEnumerate::GetDevice(int p_deviceNum, MxDriver*& p_driver, Direct3DDeviceInfo*& p_device)
{
	if (p_deviceNum < 0 || !IsInitialized()) {
		return -1;
	}

	int i = 0;

	for (list<MxDriver>::iterator it = m_ddInfo.begin(); it != m_ddInfo.end(); it++) {
		p_driver = &*it;

		for (list<Direct3DDeviceInfo>::iterator it2 = p_driver->m_devices.begin(); it2 != p_driver->m_devices.end();
			 it2++) {
			if (i == p_deviceNum) {
				p_device = &*it2;
				return 0;
			}
			i++;
		}
	}

	return -1;
}

// FUNCTION: CONFIG 0x004027d0
// FUNCTION: BETA10 0x1011cb70
int LegoDeviceEnumerate::FormatDeviceName(char* p_buffer, const MxDriver* p_ddInfo, const Direct3DDeviceInfo* p_d3dInfo)
	const
{
	int number = 0;
	assert(p_ddInfo && p_d3dInfo);

	for (list<MxDriver>::const_iterator it = m_ddInfo.begin(); it != m_ddInfo.end(); it++, number++) {
		if (&(*it) == p_ddInfo) {
			GUID4 guid;
			memcpy(&guid, p_d3dInfo->m_guid, sizeof(GUID4));

			sprintf(p_buffer, "%d 0x%x 0x%x 0x%x 0x%x", number, guid.m_data1, guid.m_data2, guid.m_data3, guid.m_data4);
			return 0;
		}
	}

	return -1;
}

// FUNCTION: BETA10 0x1011cc65
int LegoDeviceEnumerate::BETA_1011cc65(int p_idx, char* p_buffer)
{
	if (p_idx < 0 || !IsInitialized()) {
		return -1;
	}

	int i = 0;
	int j = 0;

	for (list<MxDriver>::iterator it = m_ddInfo.begin(); it != m_ddInfo.end(); it++, i++) {
		MxDriver& driver = *it;
		for (list<Direct3DDeviceInfo>::iterator it2 = driver.m_devices.begin(); it2 != driver.m_devices.end(); it2++) {

			if (j == p_idx) {
				GUID4 guid;
				memcpy(&guid, &((Direct3DDeviceInfo&) *it2).m_guid, sizeof(GUID4));
				sprintf(p_buffer, "%d 0x%x 0x%x 0x%x 0x%x", i, guid.m_data1, guid.m_data2, guid.m_data3, guid.m_data4);
				return 0;
			}

			j++;
		}
	}

	return -1;
}

// FUNCTION: CONFIG 0x00402860
// FUNCTION: LEGO1 0x1009d0d0
// FUNCTION: BETA10 0x1011cdb4
int LegoDeviceEnumerate::GetBestDevice()
{
	if (!IsInitialized()) {
		return -1;
	}

	if (m_ddInfo.size() == 0) {
		return -1;
	}

	int i = 0;
	int j = 0;
	int k = -1;
	int cpu_mmx = SupportsMMX();

	for (list<MxDriver>::iterator it = m_ddInfo.begin(); it != m_ddInfo.end(); it++, i++) {

		MxDriver& driver = *it;
		for (list<Direct3DDeviceInfo>::iterator it2 = driver.m_devices.begin(); it2 != driver.m_devices.end(); it2++) {
			if ((*it2).m_HWDesc.dcmColorModel) {
				return j;
			}
			else {
				if (cpu_mmx && (*it2).m_HELDesc.dcmColorModel == D3DCOLOR_RGB && i == 0) {
					k = j;
				}
				else if ((*it2).m_HELDesc.dcmColorModel == D3DCOLOR_MONO && i == 0 && k < 0) {
					k = j;
				}
			}

			j++;
		}
	}

	return k;
}

// FUNCTION: CONFIG 0x00402930
// FUNCTION: LEGO1 0x1009d1a0
// FUNCTION: BETA10 0x1011cf54
int LegoDeviceEnumerate::SupportsMMX()
{
	int supports_mmx = SupportsCPUID();

	if (supports_mmx) {
#ifdef _MSC_VER
		__asm {
			push ebx
			mov eax, 0x0            ; EAX=0: Highest Function Parameter and Manufacturer ID
#if _MSC_VER > 1100
			cpuid                   ; Run CPUID
#else
			__emit 0x0f
			__emit 0xa2
#endif
			mov eax, 0x1            ; EAX=1: Processor Info and Feature Bits (unused)
#if _MSC_VER > 1100
			cpuid                   ; Run CPUID
#else
			__emit 0x0f
			__emit 0xa2
#endif
			xor eax, eax            ; Zero EAX register
			bt edx, 0x17            ; Test bit 0x17 (23): MMX instructions (64-bit SIMD) (Store in CF)
			adc eax, eax            ; Add with carry: EAX = EAX + EAX + CF = CF
			pop ebx
			mov supports_mmx, eax   ; Save eax into C variable
		}
#else
		__asm__("movl $0x0, %%eax\n\t"  // EAX=0: Highest Function Parameter and Manufacturer ID
				"cpuid\n\t"             // Run CPUID\n"
				"mov $0x1, %%eax\n\t"   // EAX=1: Processor Info and Feature Bits (unused)
				"cpuid\n\t"             // Run CPUID
				"xorl %%eax, %%eax\n\t" // Zero EAX register
				"btl $0x15, %%edx\n\t"  // Test bit 0x17 (23): MMX instructions (64-bit SIMD) (Store in CF)
				"adc %%eax, %%eax"      // Add with carry: EAX = EAX + EAX + CF = CF
				: "=a"(supports_mmx)    // supports_mmx == EAX
		);
#endif
	}

	return supports_mmx;
}

// FUNCTION: CONFIG 0x00402970
// FUNCTION: LEGO1 0x1009d1e0
// FUNCTION: BETA10 0x1011cf97
int LegoDeviceEnumerate::SupportsCPUID()
{
	int has_cpuid;
#ifdef _MSC_VER
#if defined(_M_IX86)
	__asm {
		xor eax, eax                    ; Zero EAX register
		pushfd                          ; Push EFLAGS register value on the stack
		or dword ptr[esp], 0x200000     ; Set bit 0x200000: Able to use CPUID instruction (Pentium+)
		popfd                           ; Write the updated value into the EFLAGS register
		pushfd                          ; Push EFLAGS register value on the stack (again)
		btr dword ptr[esp], 0x15        ; Test bit 0x15 (21) and reset (set CF)
		adc eax, eax                    ; Add with carry: EAX = EAX + EAX + CF = CF
		popfd                           ; Push EFLAGS register value on the stack (again, and makes sure the stack remains the same)
		mov has_cpuid, eax              ; Save eax into C variable
	}
#elif defined(_M_X64)
	has_cpuid = 1;
#else
	has_cpuid = 0;
#endif
#else
#if defined(__i386__)
	__asm__("xorl %%eax, %%eax\n\t"      // Zero EAX register
			"pushfl\n\t"                 // Push EFLAGS register value on the stack
			"orl $0x200000, (%%esp)\n\t" // Set bit 0x200000: Able to use CPUID instruction (Pentium+)
			"popfl\n\t"                  // Write the updated value into the EFLAGS register
			"pushfl\n\t"                 // Push EFLAGS register value on the stack (again)
			"btrl $0x15, (%%esp)\n\t"    // Test bit 0x15 (21) and reset (set CF)
			"adc %%eax, %%eax\n\t"       // Add with carry: EAX = EAX + EAX + CF = CF
			"popfl" // Push EFLAGS register value on the stack (again, and makes sure the stack remains the same)
			: "=a"(has_cpuid) // has_cpuid == EAX
	);
#elif defined(__x86_64__) || defined(__amd64__)
	has_cpuid = 1;
#else
	has_cpuid = 0;
#endif
#endif
	return has_cpuid;
}

// FUNCTION: CONFIG 0x004029a0
// FUNCTION: LEGO1 0x1009d210
// FUNCTION: BETA10 0x1011cfc4
int LegoDeviceEnumerate::FUN_1009d210()
{
	if (!IsInitialized()) {
		return -1;
	}

	for (list<MxDriver>::iterator it = m_ddInfo.begin(); it != m_ddInfo.end();) {
		if (!DriverSupportsRequiredDisplayMode(*it)) {
			m_ddInfo.erase(it++);
			continue;
		}

		MxDriver& driver = *it;

		for (list<Direct3DDeviceInfo>::iterator it2 = driver.m_devices.begin(); it2 != driver.m_devices.end();) {
			if (!FUN_1009d3d0(*it2)) {
				driver.m_devices.erase(it2++);
			}
			else {
				it2++;
			}
		}

		if (!driver.m_devices.size()) {
			m_ddInfo.erase(it++);
		}
		else {
			it++;
		}
	}

	if (!m_ddInfo.size()) {
		return -1;
	}

	return 0;
}

// FUNCTION: CONFIG 0x00402b00
// FUNCTION: LEGO1 0x1009d370
// FUNCTION: BETA10 0x1011d176
unsigned char LegoDeviceEnumerate::DriverSupportsRequiredDisplayMode(MxDriver& p_driver)
{
	for (list<MxDisplayMode>::iterator it = p_driver.m_displayModes.begin(); it != p_driver.m_displayModes.end();
		 it++) {
		if ((*it).m_width == 640 && (*it).m_height == 480) {
			if ((*it).m_bitsPerPixel == 8 || (*it).m_bitsPerPixel == 16) {
				return TRUE;
			}
		}
	}

	return FALSE;
}

// FUNCTION: CONFIG 0x00402b60
// FUNCTION: LEGO1 0x1009d3d0
// FUNCTION: BETA10 0x1011d235
unsigned char LegoDeviceEnumerate::FUN_1009d3d0(Direct3DDeviceInfo& p_device)
{
	if (m_ddInfo.size() <= 0) {
		return FALSE;
	}

	if (p_device.m_HWDesc.dcmColorModel) {
		if (p_device.m_HWDesc.dwDeviceZBufferBitDepth & DDBD_16 &&
			p_device.m_HWDesc.dpcTriCaps.dwTextureCaps & D3DPTEXTURECAPS_PERSPECTIVE) {
			return TRUE;
		}
		else {
			return FALSE;
		}
	}

	MxDriver& front = m_ddInfo.front();
	for (list<Direct3DDeviceInfo>::iterator it = front.m_devices.begin(); it != front.m_devices.end(); it++) {
		if ((&*it) == &p_device) {
			return TRUE;
		}
	}

	return FALSE;
}
