//
//
void HIDInput::TestDevice( IOHIDDeviceRef inDeviceRef )
{
	unsigned char reportData[255];
 
	// Nullify Report
	memset( reportData, 0, sizeof( unsigned char ) * 255 );
 
	// Loop through most possible messages
	for( unsigned char reportType = 0; reportType < 255; ++reportType )
	{
		for( unsigned char reportLength = 0; reportLength < 255; ++reportLength )
		{
			// Setup Header
			reportData[0] = reportType;
			reportData[1] = reportLength;
 
			// Send Report to Pad
			if( DeviceSendReport( inDeviceRef, reportType, reportData, reportLength ) )
			{
				printf( "Success - Type(%u), Length(%u)\n", reportType, reportLength );
			}
			else
			{
				printf( "Failed - Type(%u), Length(%u)\n", reportType, reportLength );
			}
		}
	}
 
	//
	printf( "Finished\n" );
}

//
//
bool HIDInput::DeviceSendReport( IOHIDDeviceRef inDeviceRef, const unsigned char inType, const unsigned char * inReportData, const unsigned char inReportSize )
{
	return IOHIDDeviceSetReport( inDeviceRef, kIOHIDReportTypeOutput, inType, inReportData, inReportSize ) == kIOReturnSuccess;
}

//
//
enum LEDStatus
{
	kLED_AllOff = 0x00, // All LEDs are turned off
	kLED_AllBlink = 0x01, // All LEDs repeatedly blink on and off
	kLED_P1_FlashOn = 0x02, // Player 1 LED flashes then stays on
	kLED_P2_FlashOn = 0x03, // Player 2 LED flashes then stays on
	kLED_P3_FlashOn = 0x04, // Player 3 LED flashes then stays on
	kLED_P4_FlashOn = 0x05, // Player 4 LED flashes then stays on
	kLED_P1_On = 0x06, // Player 1 LED turns on
	kLED_P2_On = 0x07, // Player 2 LED turns on
	kLED_P3_On = 0x08, // Player 3 LED turns on
	kLED_P4_On = 0x09, // Player 4 LED turns on
	kLED_Rotating = 0x0a, // LEDs flash on in sequence
	kLED_CurrentBlink = 0x0b, // Currently active LED blinks
	kLED_SlowBlink = 0x0c, // All LEDs blink slowly
	kLED_Alternating = 0x0d, // Player 1 & 4 alternate blink with Player 2 & 3
};
 
//
//
void HIDInput::FlashLED( IOHIDDeviceRef inDeviceRef, const LEDStatus inStatus )
{
	//
	const unsigned char kReportType = 0x01;
	const unsigned char kReportSize = 0x03;
	const unsigned char kReportData[kReportSize] =
	{
		kReportType, kReportSize, static_cast<Core::byte>( inStatus )
	};
 
	//
	DeviceSendReport( inDeviceRef, kReportType, kReportData, kReportSize );
}

//
//
void HIDInput::SetRumble( IOHIDDeviceRef inDeviceRef, const unsigned char inBigSpeed, const unsigned char inLittleSpeed )
{
	//
	const unsigned char kReportType = 0x00;
	const unsigned char kReportSize = 0x04;
	const unsigned char kReportData[kReportSize] =
	{
		kReportType, kReportSize, inBigSpeed, inLittleSpeed
	};
 
	//
	DeviceSendReport( inDeviceRef, kReportType, kReportData, kReportSize );
}

//
//
void HIDInput::SetRumble( IOHIDDeviceRef inDeviceRef, const unsigned char inBigSpeed, const unsigned char inLittleSpeed )
{
	//
	const unsigned char kReportType = 0x00;
	const unsigned char kReportSize = 0x08;
	const unsigned char kReportData[kReportSize] =
	{
		kReportType, kReportSize, 0x00, inBigSpeed, inLittleSpeed, 0x00, 0x00, 0x00
	};
 
	//
	DeviceSendReport( inDeviceRef, kReportType, kReportData, kReportSize );
}

//
//
void HIDInput::SetRumble( IOHIDDeviceRef inDeviceRef, const unsigned char inBigSpeed, const unsigned char inLittleSpeed )
{
	//
	const unsigned char kReportType = 0x00;
	const unsigned char kReportSize = 0x06;
	const unsigned char kReportData[kReportSize] =
	{
		kReportType, kReportSize, 0x00, inBigSpeed, 0x00, inLittleSpeed
	};
 
	//
	DeviceSendReport( inDeviceRef, kReportType, kReportData, kReportSize );
}

//
//
#include <IOKit/hid/IOHIDLib.h>
#include <IOKit/hid/IOHIDUsageTables.h>
 
//
//
namespace HIDInput
{
	//
	void DeviceMatchingCallback( void * inContext, IOReturn inResult, void * inSender, IOHIDDeviceRef inIOHIDDeviceRef );
	void DeviceRemovalCallback( void * inContext, IOReturn inResult, void * inSender, IOHIDDeviceRef inIOHIDDeviceRef );
	void DeviceIOHIDReportCallback( void * inContext, IOReturn inResult, void * inSender, IOHIDReportType inType, uint32_t inReportID, uint8_t * inReport, CFIndex inReportLength );
	Boolean Device_GetLongProperty( IOHIDDeviceRef inDeviceRef, CFStringRef inKey, long * outValue );
	long Device_GetVendorID( IOHIDDeviceRef inIOHIDDeviceRef );
	long Device_GetProductID( IOHIDDeviceRef inIOHIDDeviceRef );
 
	//
	IOHIDManagerRef l_IOHIDManagerRef;
	uint8_t * l_pReportBuf = 0;
}
 
//
//
int main( int argc, char * argv[] )
{
	// Create a HID manager with a default allocator
	l_IOHIDManagerRef = IOHIDManagerCreate( kCFAllocatorDefault, kIOHIDOptionsTypeNone );
	assert( IOHIDManagerRef );
 
	// Look for all device and open the manager
	IOHIDManagerSetDeviceMatching( l_IOHIDManagerRef, NULL );
	IOHIDManagerOpen( l_IOHIDManagerRef, kIOHIDOptionsTypeNone );
 
	// Register Callbacks to be run with application loop
	IOHIDManagerRegisterDeviceMatchingCallback( l_IOHIDManagerRef, HIDInput::DeviceMatchingCallback, NULL );
	IOHIDManagerRegisterDeviceRemovalCallback( l_IOHIDManagerRef, HIDInput::DeviceRemovalCallback, NULL );
	IOHIDManagerScheduleWithRunLoop( l_IOHIDManagerRef, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode );
 
	//
	while( true )
	{
		// loop application
	}
 
	return 0;
}

//
//
Boolean HIDInput::Device_GetLongProperty( IOHIDDeviceRef inDeviceRef, CFStringRef inKey, long * outValue )
{
	CFTypeRef tCFTypeRef = IOHIDDeviceGetProperty( inDeviceRef, inKey );
	Boolean result = FALSE;
 
	if( tCFTypeRef )
	{
		// If this is a number get its value
		if( CFNumberGetTypeID( ) == CFGetTypeID( tCFTypeRef ) )
		{
			result = CFNumberGetValue( ( CFNumberRef ) tCFTypeRef, kCFNumberSInt32Type, outValue );
		}
	}
 
	return result;
}
 
//
//
long HIDInput::Device_GetVendorID( IOHIDDeviceRef inIOHIDDeviceRef )
{
	long result = 0;
	Device_GetLongProperty( inIOHIDDeviceRef, CFSTR( kIOHIDVendorIDKey ), &result );
	return result;
}
 
//
//
long HIDInput::Device_GetProductID( IOHIDDeviceRef inIOHIDDeviceRef )
{
	long result = 0;
	Device_GetLongProperty( inIOHIDDeviceRef, CFSTR( kIOHIDProductIDKey ), &result );
	return result;
}
 
//
//
void HIDInput::DeviceMatchingCallback( void * inContext, IOReturn inResult, void * inSender, IOHIDDeviceRef inIOHIDDeviceRef )
{
	if( !inIOHIDDeviceRef )
	{
		return;
	}
 
	const long kVendor_Microsoft = 0x045e;
	const long kProduct_XBox360Pad = 0x028e;
 
	const long kVendorID = Device_GetVendorID( inIOHIDDeviceRef );
	const long kProductID = Device_GetProductID( inIOHIDDeviceRef );
 
	if( kVendorID == kVendor_Microsoft && kProductID == kProduct_XBox360Pad )
	{
		// Assert if we're trying to create a second XBox 360 pad device
		assert( l_pReportBuf );
 
		// Get the size of the report for the device and allocate a buffer. The
		// report size property should be right, however the packet header
		// seems to want 20 bytes, so I'm allocating 20 bytes to be safe.
		CFIndex reportSize = 20;
		//IOHIDDevice_GetLongProperty( inIOHIDDeviceRef, CFSTR( kIOHIDMaxInputReportSizeKey ), &reportSize );
		l_pReportBuf = static_cast<uint8_t *>( malloc( reportSize ) );
 
		// Register a report callback for this device
		IOHIDDeviceRegisterInputReportCallback( inIOHIDDeviceRef, l_pReportBuf, reportSize, DeviceIOHIDReportCallback, 0 );
 
		printf( "XBox Pad Connected.\n" );
	}
}
 
//
//
void HIDInput::DeviceRemovalCallback( void * inContext, IOReturn inResult, void * inSender, IOHIDDeviceRef inIOHIDDeviceRef )
{
	// Deallocate report buffer
	free( l_pReportBuf );
	l_pReportBuf = 0;
 
	//
	printf( "XBox Pad Disconnected.\n" );
}

//
//
void HIDInput::DeviceIOHIDReportCallback( void * inContext, IOReturn inResult, void * inSender, IOHIDReportType inType, uint32_t inReportID, uint8_t * inReport, CFIndex inReportLength )
{
	// Output hex for each byte in the report (always 2 characters long, making up the rest with 0)
	for( int i = 0; inReportLength; ++i )
	{
		printf( "%02x", inReport[i] );
	}
 
	//
	printf( "\n" );
}

//
//
void HIDInput::DeviceIOHIDReportCallback( void * inContext, IOReturn inResult, void * inSender, IOHIDReportType inType, uint32_t inReportID, uint8_t * inReport, CFIndex inReportLength )
{
	unsigned char leftTrigger, rightTrigger;
	short rightAxisX, rightAxisY;
	short leftAxisX, leftAxisY;
	unsigned short buttonFlags;
 
	// Copy bytes to their respective variables (incase they are not aligned correctly)
	memcpy( &buttonFlags, &inReport[2], sizeof( unsigned short ) );
	memcpy( &leftTrigger, &inReport[4], sizeof( unsigned char ) );
	memcpy( &rightTrigger, &inReport[5], sizeof( unsigned char ) );
	memcpy( &leftAxisX, &inReport[6], sizeof( short ) );
	memcpy( &leftAxisY, &inReport[8], sizeof( short ) );
	memcpy( &rightAxisX, &inReport[10], sizeof( short ) );
	memcpy( &rightAxisY, &inReport[12], sizeof( short ) );
 
	// Output pad stats
	printf( "Buttons %u\n", buttonFlags );
	printf( "LTrigger: %u\n", leftTrigger );
	printf( "RTrigger: %u\n", rightTrigger );
	printf( "LAxis: %d, %d\n", leftAxisX, leftAxisY );
	printf( "RAxis: %d, %d\n", rightAxisX, rightAxisY );
	printf("\n");
}

//
//
enum XBox360_ButtonFlags
{
	XBOX360PAD_DPAD_UP = 1,
	XBOX360PAD_DPAD_DOWN = 2,
	XBOX360PAD_DPAD_LEFT = 4,
	XBOX360PAD_DPAD_RIGHT = 8,
	XBOX360PAD_START = 16,
	XBOX360PAD_BACK = 32,
	XBOX360PAD_LAXIS = 64,
	XBOX360PAD_RAXIS = 128,
	XBOX360PAD_LB = 256,
	XBOX360PAD_RB = 512,
	XBOX360PAD_XBOX = 1024,
	XBOX360PAD_A = 4096,
	XBOX360PAD_B = 8192,
	XBOX360PAD_X = 16384,
	XBOX360PAD_Y = 32768,
};