/*
The zlib/libpng License

Copyright (c) 2005-2007 Phillip Castaneda (pjcast -- www.wreckedgames.com)

This software is provided 'as-is', without any express or implied warranty. In no event will
the authors be held liable for any damages arising from the use of this software.

Permission is granted to anyone to use this software for any purpose, including commercial
applications, and to alter it and redistribute it freely, subject to the following
restrictions:

    1. The origin of this software must not be misrepresented; you must not claim that
		you wrote the original software. If you use this software in a product,
		an acknowledgment in the product documentation would be appreciated but is
		not required.

    2. Altered source versions must be plainly marked as such, and must not be
		misrepresented as being the original software.

    3. This notice may not be removed or altered from any source distribution.
*/
#include "linux/EventHelpers.h"
#include "linux/LinuxPrereqs.h"
#include "linux/LinuxForceFeedback.h"
#include "OISException.h"
#include "OISJoyStick.h"

#include <linux/input.h>
#include <cstring>

//#define OIS_LINUX_JOY_DEBUG

#ifdef OIS_LINUX_JOY_DEBUG
# include <iostream>
#endif

// Fixes for missing macros in input.h
#ifndef FF_EFFECT_MIN
#define FF_EFFECT_MIN FF_RUMBLE
#endif
#ifndef FF_EFFECT_MAX
#define FF_EFFECT_MAX FF_RAMP
#endif
#ifndef FF_WAVEFORM_MIN
#define FF_WAVEFORM_MIN FF_SQUARE
#endif
#ifndef FF_WAVEFORM_MAX
#define FF_WAVEFORM_MAX FF_CUSTOM
#endif

using namespace std;
using namespace OIS;

class DeviceComponentInfo
{
public:
	vector<int> buttons, relAxes, absAxes, hats;
};

bool inline isBitSet(unsigned char bits[], unsigned int bit)
{
  return (bits[(bit)/(sizeof(unsigned char)*8)] >> ((bit)%(sizeof(unsigned char)*8))) & 1;
}

//-----------------------------------------------------------------------------//
DeviceComponentInfo getComponentInfo( int deviceID )
{
	unsigned char ev_bits[1 + EV_MAX/8/sizeof(unsigned char)];
	memset( ev_bits, 0, sizeof(ev_bits) );

	//Read "all" (hence 0) components of the device
#ifdef OIS_LINUX_JOY_DEBUG
	cout << "EventUtils::getComponentInfo(" << deviceID 
		 << ") : Reading device events features" << endl;
#endif
	if (ioctl(deviceID, EVIOCGBIT(0, sizeof(ev_bits)), ev_bits) == -1)
		OIS_EXCEPT( E_General, "Could not read device events features");

	DeviceComponentInfo components;

	for (int i = 0; i < EV_MAX; i++)
	{
		if( isBitSet(ev_bits, i) )
		{
		    // Absolute axis.
		    if(i == EV_ABS)
			{
			    unsigned char abs_bits[1 + ABS_MAX/8/sizeof(unsigned char)];
			    memset( abs_bits, 0, sizeof(abs_bits) );

#ifdef OIS_LINUX_JOY_DEBUG
				cout << "EventUtils::getComponentInfo(" << deviceID 
					 << ") : Reading device absolute axis features" << endl;
#endif

				if (ioctl(deviceID, EVIOCGBIT(i, sizeof(abs_bits)), abs_bits) == -1)
				    OIS_EXCEPT( E_General, "Could not read device absolute axis features");

				for (int j = 0; j < ABS_MAX; j++)
				{
				    if( isBitSet(abs_bits, j) )
					{
						//input_absinfo abInfo;
						//ioctl( fd, EVIOCGABS(j), abInfo );
						if( j >= ABS_HAT0X && j <= ABS_HAT3Y )
						{
							components.hats.push_back(j);
						}
						else
						{
							components.absAxes.push_back(j);
							//input_absinfo absinfo;
							//ioctl(deviceID, EVIOCGABS(j), &absinfo);
							//We cannot actually change these values :|
							//absinfo.minimum = JoyStick::MIN_AXIS;
							//absinfo.maximum = JoyStick::MAX_AXIS;
							//ioctl(deviceID, EVIOCSABS(j), &absinfo);
						}
					}
				}
			}
			else if(i == EV_REL)
			{
			    unsigned char rel_bits[1 + REL_MAX/8/sizeof(unsigned char)];
				memset( rel_bits, 0, sizeof(rel_bits) );
				
#ifdef OIS_LINUX_JOY_DEBUG
				cout << "EventUtils::getComponentInfo(" << deviceID 
					 << ") : Reading device relative axis features" << endl;
#endif

				if (ioctl(deviceID, EVIOCGBIT(i, sizeof(rel_bits)), rel_bits) == -1)
				    OIS_EXCEPT( E_General, "Could not read device relative axis features");
				
				for (int j = 0; j < REL_MAX; j++)
				{
				    if( isBitSet(rel_bits, j) )
					{
					    components.relAxes.push_back(j);
					}
				}
			}
			else if(i == EV_KEY)
			{
			    unsigned char key_bits[1 + KEY_MAX/8/sizeof(unsigned char)];
				memset( key_bits, 0, sizeof(key_bits) );
				
#ifdef OIS_LINUX_JOY_DEBUG
				cout << "EventUtils::getComponentInfo(" << deviceID 
					 << ") : Reading device buttons features" << endl;
#endif

				if (ioctl(deviceID, EVIOCGBIT(i, sizeof(key_bits)), key_bits) == -1)
				    OIS_EXCEPT( E_General, "Could not read device buttons features");
				
				for (int j = 0; j < KEY_MAX; j++)
				{
				    if( isBitSet(key_bits, j) )
					{
					    components.buttons.push_back(j);
					}
				}
			}
		}
	}

	return components;
}

//-----------------------------------------------------------------------------//
bool EventUtils::isJoyStick( int deviceID, JoyStickInfo &js )
{
	if( deviceID == -1 ) 
		OIS_EXCEPT( E_General, "Error with File Descriptor" );

	DeviceComponentInfo info = getComponentInfo( deviceID );

	int buttons = 0;
	bool joyButtonFound = false;
	js.button_map.clear();

	#ifdef OIS_LINUX_JOY_DEBUG
	cout << endl << "Displaying ButtonMapping Status:" << endl;
	#endif
	for(vector<int>::iterator i = info.buttons.begin(), e = info.buttons.end(); i != e; ++i )
	{
		//Check to ensure we find at least one joy only button
		if( (*i >= BTN_JOYSTICK && *i < BTN_GAMEPAD)  
			|| (*i >= BTN_GAMEPAD && *i < BTN_DIGI)
			|| (*i >= BTN_WHEEL && *i < KEY_OK) )
			joyButtonFound = true;

		js.button_map[*i] = buttons++;

		#ifdef OIS_LINUX_JOY_DEBUG
		  cout << "Button Mapping ID (hex): " << hex << *i 
			   << " OIS Button Num: " << dec << buttons-1 << endl;
		#endif
	}
	#ifdef OIS_LINUX_JOY_DEBUG
	cout << endl;
	#endif

	//Joy Buttons found, so it must be a joystick or pad
	if( joyButtonFound )
	{
		js.joyFileD = deviceID;
		js.vendor = getName(deviceID);
		js.buttons = buttons;
		js.axes = info.relAxes.size() + info.absAxes.size();
		js.hats = info.hats.size();
		#ifdef OIS_LINUX_JOY_DEBUG
		  cout << endl << "Device name:" << js.vendor << endl;
		  cout << "Device unique Id:" << getUniqueId(deviceID) << endl;
		  cout << "Device physical location:" << getPhysicalLocation(deviceID) << endl;
		#endif

		//Map the Axes
		#ifdef OIS_LINUX_JOY_DEBUG
		  cout << endl << "Displaying AxisMapping Status:" << endl;
		#endif
		int axes = 0;
		for(vector<int>::iterator i = info.absAxes.begin(), e = info.absAxes.end(); i != e; ++i )
		{
			js.axis_map[*i] = axes;

#ifdef OIS_LINUX_JOY_DEBUG
			cout << "EventUtils::isJoyStick(" << deviceID 
					  << ") : Reading device absolute axis #" << *i << " features" << endl;
#endif

			input_absinfo absinfo;
			if (ioctl(deviceID, EVIOCGABS(*i), &absinfo) == -1)
				OIS_EXCEPT( E_General, "Could not read device absolute axis features");
			js.axis_range[axes] = Range(absinfo.minimum, absinfo.maximum);

			#ifdef OIS_LINUX_JOY_DEBUG
			  cout << "Axis Mapping ID (hex): " << hex << *i 
				   << " OIS Axis Num: " << dec << axes << endl;
			#endif

			++axes;
		}
	}

	return joyButtonFound;
}

//-----------------------------------------------------------------------------//
string EventUtils::getName( int deviceID )
{
#ifdef OIS_LINUX_JOY_DEBUG
	cout << "EventUtils::getName(" << deviceID 
		 << ") : Reading device name" << endl;
#endif

	char name[OIS_DEVICE_NAME];
	if (ioctl(deviceID, EVIOCGNAME(OIS_DEVICE_NAME), name) == -1)
		OIS_EXCEPT( E_General, "Could not read device name");
	return string(name);
}

//-----------------------------------------------------------------------------//
string EventUtils::getUniqueId( int deviceID )
{
#ifdef OIS_LINUX_JOY_DEBUG
	cout << "EventUtils::getUniqueId(" << deviceID 
		 << ") : Reading device unique Id" << endl;
#endif

#define OIS_DEVICE_UNIQUE_ID 128
	char uId[OIS_DEVICE_UNIQUE_ID];
	if (ioctl(deviceID, EVIOCGUNIQ(OIS_DEVICE_UNIQUE_ID), uId) == -1)
		OIS_EXCEPT( E_General, "Could not read device unique Id");
	return string(uId);
}

//-----------------------------------------------------------------------------//
string EventUtils::getPhysicalLocation( int deviceID )
{
#ifdef OIS_LINUX_JOY_DEBUG
	cout << "EventUtils::getPhysicalLocation(" << deviceID 
		 << ") : Reading device physical location" << endl;
#endif

#define OIS_DEVICE_PHYSICAL_LOCATION 128
	char physLoc[OIS_DEVICE_PHYSICAL_LOCATION];
	if (ioctl(deviceID, EVIOCGPHYS(OIS_DEVICE_PHYSICAL_LOCATION), physLoc) == -1)
		OIS_EXCEPT( E_General, "Could not read device physical location");
	return string(physLoc);
}

//-----------------------------------------------------------------------------//
void EventUtils::enumerateForceFeedback( int deviceID, LinuxForceFeedback** ff )
{
	//Linux Event to OIS Event Mappings
	map<int, Effect::EType> typeMap;
	typeMap[FF_CONSTANT] = Effect::Constant;
	typeMap[FF_RAMP]     = Effect::Ramp;
	typeMap[FF_SPRING]   = Effect::Spring;
	typeMap[FF_FRICTION] = Effect::Friction;
	typeMap[FF_SQUARE]   = Effect::Square;
	typeMap[FF_TRIANGLE] = Effect::Triangle;
	typeMap[FF_SINE]     = Effect::Sine;
	typeMap[FF_SAW_UP]   = Effect::SawToothUp;
	typeMap[FF_SAW_DOWN] = Effect::SawToothDown;
	typeMap[FF_DAMPER]   = Effect::Damper;
	typeMap[FF_INERTIA]  = Effect::Inertia;
	typeMap[FF_CUSTOM]   = Effect::Custom;

	map<int, Effect::EForce> forceMap;
	forceMap[FF_CONSTANT] = Effect::ConstantForce;
	forceMap[FF_RAMP]     = Effect::RampForce;
	forceMap[FF_SPRING]   = Effect::ConditionalForce;
	forceMap[FF_FRICTION] = Effect::ConditionalForce;
	forceMap[FF_SQUARE]   = Effect::PeriodicForce;
	forceMap[FF_TRIANGLE] = Effect::PeriodicForce;
	forceMap[FF_SINE]     = Effect::PeriodicForce;
	forceMap[FF_SAW_UP]   = Effect::PeriodicForce;
	forceMap[FF_SAW_DOWN] = Effect::PeriodicForce;
	forceMap[FF_DAMPER]   = Effect::ConditionalForce;
	forceMap[FF_INERTIA]  = Effect::ConditionalForce;
	forceMap[FF_CUSTOM]   = Effect::CustomForce;

	//Remove any previously existing memory and create fresh
	removeForceFeedback( ff );
	*ff = new LinuxForceFeedback(deviceID);

	//Read overall force feedback features
	unsigned char ff_bits[1 + FF_MAX/8/sizeof(unsigned char)];
	memset(ff_bits, 0, sizeof(ff_bits));

#ifdef OIS_LINUX_JOY_DEBUG
	cout << "EventUtils::enumerateForceFeedback(" << deviceID 
		 << ") : Reading device force feedback features" << endl;
#endif

	if (ioctl(deviceID, EVIOCGBIT(EV_FF, sizeof(ff_bits)), ff_bits) == -1)
		OIS_EXCEPT( E_General, "Could not read device force feedback features");


    #ifdef OIS_LINUX_JOY_DEBUG
	cout << "FF bits: " << hex;
	for (int i = 0; i < sizeof(ff_bits); i++)
		cout << (int)ff_bits[i];
	cout << endl << dec;
    #endif

	//FF Axes
	//if( isBitSet(ff_bits, ABS_X) ) //X Axis
	//if( isBitSet(ff_bits, ABS_Y) ) //Y Axis
	//if( isBitSet(ff_bits, ABS_WHEEL) ) //Wheel

	//FF Effects
	for( int effect = FF_EFFECT_MIN; effect <= FF_WAVEFORM_MAX; effect++ )
	{
		// The RUMBLE force type is ignored, as periodic force one is more powerfull.
		// The PERIODIC force type is processed later, for each associated periodic effect type.
		if (effect == FF_RUMBLE || effect == FF_PERIODIC)
			continue;

		if(isBitSet(ff_bits, effect))
		{
			#ifdef OIS_LINUX_JOY_DEBUG
		    cout << "  Effect Type: " << Effect::getEffectTypeName(typeMap[effect]) << endl;
			#endif

			(*ff)->_addEffectTypes( forceMap[effect], typeMap[effect] );
		}
	}

	//FF device properties
	if (isBitSet(ff_bits, FF_GAIN))
		(*ff)->_setGainSupport(true);
		
	if (isBitSet(ff_bits, FF_AUTOCENTER))
		(*ff)->_setAutoCenterSupport(true);

	//Check to see if any effects were added, else destroy the pointer
	const ForceFeedback::SupportedEffectList &list = (*ff)->getSupportedEffects();
	if( list.size() == 0 )
		removeForceFeedback( ff );
}

//-----------------------------------------------------------------------------//
void EventUtils::removeForceFeedback( LinuxForceFeedback** ff )
{
	delete *ff;
	*ff = 0;
}
