// Dash Interface
//
// Douglas Thrift
//
// $Id$

#include <iomanip>
#include <iostream>
#include <sstream>

#include <foreach.hpp>
#include <hash.hpp>
#include <regex.hpp>
#include <timing.hpp>

#include <Audacious.hpp>
#include <GPS.hpp>

#include <sys/types.h>
#include <sys/sysctl.h>
#include <sys/utsname.h>

#include <sqlite3.h>

#include "Display.hpp"

bool debug(false);

void Uname_(Display &display, time_t now = 0, bool change = false)
{
	if (!now || change)
	{
		utsname os;

		::uname(&os);

		static Pcre::RegEx version(_B("^(\\d+\\.\\d+)-([A-Z])[A-Z]*(-p\\d+)?.*$"));
		Pcre::RegEx::Match match(version(os.release));

		display.Set(0, 1, os.sysname + _B(" ") + match[1] + match[2] + match[3]);
	}

	int mib[] = { CTL_KERN, KERN_BOOTTIME };
	timeval boottime;
	size_t size(sizeof (boottime));

	if (now && ::sysctl(mib, 2, &boottime, &size, NULL, 0) != -1 && boottime.tv_sec != 0)
	{
		time_t uptime(now - boottime.tv_sec);

		if (uptime > 60)
			uptime += 30;

		char *when;
		int days(uptime / 86400);

		uptime %= 86400;

		int hours(uptime / 3600);

		uptime %= 3600;

		int minutes(uptime / 60), seconds(uptime % 60);

		::asprintf(&when, "%i+%02i:%02i:%02i", days, hours, minutes, seconds);

		std::string then(when);

		then.append(17 - std::strlen(when), ' ');

		std::free(when);

		if (change)
			display.Set(0, 2, _B("up ") + then);
		else
			display.Set(3, 2, then);
	}
	else
		display.Set(0, 2, _B("up -+--:--:--       "));

	double averages[3];

	if (::getloadavg(averages, 3) == -1 || !now)
		display.Set(0, 3, _B("-.--, -.--, -.--    "));
	else
	{
		char *load;

		::asprintf(&load, "%.2f, %.2f, %.2f", averages[0], averages[1] , averages[2]);

		display.Set(0, 3, load + std::string(20 - std::strlen(load), ' '));

		std::free(load);
	}
}

enum Mode { Uname, Music, English, Metric, Nautical, Menu };

Mode &operator ++(Mode &mode)
{
	return mode = Mode((mode + 1) % Menu);
}

Mode &operator --(Mode &mode)
{
	return mode = Mode((Menu + mode - 1) % Menu);
}

int main(int argc, char *argv[])
{
	std::string device;

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

		for (char **arg = argv + 1; *arg; ++arg)
		{
			Pcre::RegEx::Match match;

			if (*arg == _B("-debug"))
				debug = true;
			else if (match = devicePath(*arg))
				device = match[1];
			else if (match = deviceNumber(*arg))
				device = _B("/dev/cuaU") + match[1];
			else if (match = deviceName(*arg))
				device = _B("/dev/") + match[1];
			else
				goto usage;
		}
	}

	if (device.empty())
	{
usage:	std::cout << _B("Usage: ") << argv[0] << _B(" [-debug] [-device=device]") << std::endl;

		return 2;
	}

	try
	{
		Display display(device);

		display.Clear();
		display.SetBacklight(100);
		display.Set(2, 0, _B("--:--:-- -- ---"));

		enum { Running };

		display.Set(Running, Display::Green, 0);
		display.Set(Running, Display::Red, 100);

		{
			uint8_t mask(Display::Up | Display::Enter | Display::Cancel | Display::Left | Display::Right | Display::Down);

			display.KeyReporting(mask, mask);
		}

		Uname_(display);

		display.Store();
		display.Set(Running, Display::Green, 100);
		display.Set(Running, Display::Red, 0);

		Mode mode(Uname);
		//Audacious::Audacious audacious;
		//GPS::GPS gps;

		_forever
		{
			// XXX: I'm going to refactor this into callback functions, grr
			/*while (Display::KeyActivity activity = display.GetKeyActivity())
				if (mode != Menu)
					switch (activity)
					{
					case Display::UpPress:
						++mode;

						goto change;
					case Display::DownPress:
						--mode;

						goto change;
					case Display::LeftPress:
						std::cerr << _B("Previous") << std::endl;

						break;
					case Display::RightPress:
						std::cerr << _B("Next") << std::endl;

						break;
					case Display::EnterPress:
						std::cerr << _B("Menu") << std::endl;

						mode = Menu;

						goto change;
					case Display::ExitPress:
						std::cerr << _B("Play/Pause") << std::endl;

						break;
					default:
						break;
					}

			if (false)
change:			change = true;*/

			Timing::Time now(Timing::GetTimeOfDay());

			if (mode != Menu)
			{
				char when[16];

				std::strftime(when, sizeof (when), "%l:%M:%S %p %Z", std::localtime(now));

				display.Set(2, 0, when);
			}

			switch (mode)
			{
			case Uname:
				Uname_(display, now);

				break;
			case Music:
			case English:
			case Metric:
			case Nautical:
			case Menu:
				break;
			}

			Timing::NanoSleep(Timing::Time(1) -= Timing::GetTimeOfDay().GetNanoseconds());
		}
	}
	catch (const std::exception &exception)
	{
		std::cerr << argv[0] << _B(": ") << exception.what() << std::endl;

		return 1;
	}

	return 0;
}