// Steering Wheel Remote
//
// Douglas Thrift
//
// $Id$

#include <cxx/standard.hh>

#include <api/exename.hpp>
#include <api/pcre/regex.hpp>
#include <api/files.hpp>
#include <app/simple.hpp>
#include <ext/helpers.hpp>

#include "Audacious.hpp"

bool debug(false);

enum Button
{
	None		= 000,
	PlayPause	= 001,
	VolumeUp	= 002,
	VolumeDown	= 004,
	Next		= 010,
	Previous	= 020
};

const _V<Button> buttons(PlayPause, VolumeUp, VolumeDown, Next, Previous);

inline ios::PrintWriter &operator<<(ios::PrintWriter &output, Button button)
{
	switch (button)
	{
	case None:
		return output << _B("None");
	case PlayPause:
		return output << _B("PlayPause");
	case Previous:
		return output << _B("Previous");
	case Next:
		return output << _B("Next");
	case VolumeDown:
		return output << _B("VolumeDown");
	case VolumeUp:
		return output << _B("VolumeUp");
	default:
		return output << _B("Unknown");
	}
}

class Buttons
{
	byte_t current, previous;
	_L<Button> events;

	inline bool Pressed(Button button, bool current_ = true) const
	{
		return ((current_ ? current : previous) & button) == button;
	}

public:
	inline const _L<Button> &Events() const
	{
		return events;
	}

	inline const _L<Button> &Events(byte_t bytes[8])
	{
		if (debug)
		{
			_assert (bytes[0] == 3);
			_assert (bytes[1] == 2);
			_assert (bytes[2] == 0);
			_assert (bytes[3] == -(bytes[4] - 0373));
			_assert (bytes[5] == 0);
			_assert (bytes[6] == 0);
			_assert (bytes[7] == 0);
		}

		previous = current;
		current = bytes[3];

		events.Clear();

		_foreach (const _V<Button>, button, buttons)
			if (Pressed(*button, false) && !Pressed(*button))
				events.InsertLast(*button);

		return events;
	}

	template <Button button>
	inline bool Pressed()
	{
		return Pressed(button);
	}
};

int Main(const app::Options &options)
{
	cse::String device;

	{
		api::Pcre::RegEx devicePath(_B("^-device=(/.+)$"));
		api::Pcre::RegEx deviceNumber(_B("^-device=([0-9]+)$"));
		api::Pcre::RegEx deviceName(_B("^-device=(.+)$"));

		_foreach (const app::ArgumentList, arg, app::GetArguments())
		{
			api::Pcre::RegEx::Match match;

			if (*arg == _B("-debug"))
				debug = true;
			else if (match = devicePath(*arg))
				device = match[1];
			else if (match = deviceNumber(*arg))
				device = _S<ios::String>() << _B("/dev/uhid") << match[1];
			else if (match = deviceName(*arg))
				device = _S<ios::String>() << _B("/dev/") << match[1];
			else
				goto usage;
		}
	}

	if (device.IsEmpty())
	{
usage:	api::Cout << _B("Usage: ") << api::GetExecutablePath().GetName() << _B(" [-debug] [-device=device]") << ios::NewLine;

		return 1;
	}

	try
	{
		_S<api::FileReader> uhid(device);
		byte_t bytes[8];
		Buttons buttons;
		Audacious audacious;

		_forever
		{
			uhid.ReadFully(bytes, sizeof (bytes));

			_foreach (const _L<Button>, button, buttons.Events(bytes))
			{
				if (debug)
					api::Cerr << _B("button=") << *button << ios::NewLine;

				if (audacious.IsRunning())
					switch (*button)
					{
					default:
						break;

					case PlayPause:
						audacious.PlayPause();

						break;

					case Previous:
						audacious.PlaylistPrevious();

						break;

					case Next:
						audacious.PlaylistNext();

						break;

					case VolumeDown:
					case VolumeUp:
						int volume(audacious.GetMainVolume() + (*button == VolumeUp ? 1 : -1));

						audacious.SetMainVolume(volume);
					}
			}
		}
	}
	catch (const api::Error &error)
	{
		api::Cerr << api::GetExecutablePath().GetName() << _B(": ") << error.GetMessage() << ios::NewLine;

		return 1;
	}

	return 0;
}