/*
 * Copyright 2007-2009 Haiku.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Oliver Ruiz Dorantes	oliver.ruiz.dorantes_at_gmail.com
 *		Ryan Leavengood			leavengood@gmail.com
 *		Fredrik Modéen 			fredrik@modeen.se
 */

#include "JoyWin.h"
#include "MessageWin.h"
#include "CalibWin.h"
#include "Global.h"
#include "PortItem.h"
//#include "FileReadWrite.h"

#include <stdio.h>
#include <stdlib.h>

#include <Box.h>
#include <Button.h>
#include <CheckBox.h>
#include <ListView.h>
#include <ListItem.h>
#include <ScrollView.h>
#include <String.h>
#include <StringView.h>
#include <Application.h>
#include <View.h>
#include <Path.h>
#include <Entry.h>
#include <Directory.h>
#include <Alert.h>
#include <File.h>
#include <SymLink.h>
#include <Messenger.h>
#include <Directory.h>
#include <Joystick.h>
#include <FindDirectory.h>
#include <Joystick.h>

#define JOYSTICKPATH "/dev/joystick/"
#define JOYSTICKFILEPATH "/boot/system/data/joysticks/"
#define JOYSTICKFILESETTINGS "/boot/home/config/settings/joysticks/"
#define SELECTGAMEPORTFIRST "Select a game port first"

static int
ShowMessage(char* string)
{
	BAlert *alert = new BAlert("Message", string, "OK");
	alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
	return alert->Go();
}

JoyWin::JoyWin(BRect frame, const char *title)
	: BWindow(frame, title, B_DOCUMENT_WINDOW_LOOK, B_NORMAL_WINDOW_FEEL,
		B_NOT_ZOOMABLE), fSystemUsedSelect(false),
		fJoystick(new BJoystick)
{
	fProbeButton = new BButton(BRect(15.00, 260.00, 115.00, 285.00),
		"ProbeButton", "Probe", new BMessage(PROBE));

	fCalibrateButton = new BButton(BRect(270.00, 260.00, 370.00, 285.00),
		"CalibrateButton", "Calibrate", new BMessage(CALIBRATE));

	fGamePortL = new BListView(BRect(15.00, 30.00, 145.00, 250.00),
		"gamePort");
	fGamePortL->SetSelectionMessage(new BMessage(PORT_SELECTED));
	fGamePortL->SetInvocationMessage(new BMessage(PORT_INVOKE));

	fConControllerL = new BListView(BRect(175.00,30.00,370.00,250.00),
		"conController");
	fConControllerL->SetSelectionMessage(new BMessage(JOY_SELECTED));
	fConControllerL->SetInvocationMessage(new BMessage(JOY_INVOKE));

	fGamePortS = new BStringView(BRect(15, 5, 160, 25), "gpString",
		"Game port");
	fGamePortS->SetFont(be_bold_font);
	fConControllerS = new BStringView(BRect(170, 5, 330, 25), "ccString",
		"Connected controller");

	fConControllerS->SetFont(be_bold_font);

	fCheckbox = new BCheckBox(BRect(131.00, 260.00, 227.00, 280.00),
		"Disabled", "Disabled", new BMessage(DISABLEPORT));
	BBox *box = new BBox( Bounds(),"box", B_FOLLOW_ALL,
		B_WILL_DRAW | B_FRAME_EVENTS | B_FULL_UPDATE_ON_RESIZE,
		B_PLAIN_BORDER);

	box->SetViewUIColor(B_PANEL_BACKGROUND_COLOR);

	// Add listViews with their scrolls
	box->AddChild(new BScrollView("PortScroll", fGamePortL,
		B_FOLLOW_LEFT | B_FOLLOW_TOP_BOTTOM, B_WILL_DRAW, false, true));

	box->AddChild(new BScrollView("ConScroll", fConControllerL, B_FOLLOW_ALL,
		B_WILL_DRAW, false, true));

	// Adding object
	box->AddChild(fCheckbox);
	box->AddChild(fGamePortS);
	box->AddChild(fConControllerS);
	box->AddChild(fProbeButton);
	box->AddChild(fCalibrateButton);
	AddChild(box);

	SetSizeLimits(400, 600, Bounds().Height(), Bounds().Height());

	/* Add all the devices */
	int32 nr = fJoystick->CountDevices();
	for (int32 i = 0; i < nr;i++) {
		//BString str(path.Path());
		char buf[B_OS_NAME_LENGTH];
		fJoystick->GetDeviceName(i, buf, B_OS_NAME_LENGTH);
		fGamePortL->AddItem(new PortItem(buf));
	}
	fGamePortL->Select(0);

	/* Add the joysticks specifications */
	_AddToList(fConControllerL, JOY_SELECTED, JOYSTICKFILEPATH);

	_GetSettings();
}


JoyWin::~JoyWin()
{
	//delete fFileTempProbeJoystick;
	be_app_messenger.SendMessage(B_QUIT_REQUESTED);
}


void
JoyWin::MessageReceived(BMessage *message)
{
//	message->PrintToStream();
	switch(message->what)
	{
		case DISABLEPORT:
		break;
		{
			PortItem *item = _GetSelectedItem(fGamePortL);
			if (item != NULL) {
				//ToDo: item->SetEnabled(true);
				//don't work as you can't select a item that are disabled
				if(fCheckbox->Value()) {
					item->SetEnabled(false);
					_SelectDeselectJoystick(fConControllerL, false);
				} else {
					item->SetEnabled(true);
					_SelectDeselectJoystick(fConControllerL, true);
					_PerformProbe(item->Text());
				}
			} //else
				//printf("We have a null value\n");
		break;
		}

		case PORT_SELECTED:
		{
			PortItem *item = _GetSelectedItem(fGamePortL);
			if (item != NULL) {
				fSystemUsedSelect = true;
				if (item->IsEnabled()) {
					//printf("SetEnabled = false\n");
					fCheckbox->SetValue(false);
					_SelectDeselectJoystick(fConControllerL, true);
				} else {
					//printf("SetEnabled = true\n");
					fCheckbox->SetValue(true);
					_SelectDeselectJoystick(fConControllerL, false);
				}

				if (_CheckJoystickExist(item->Text()) == B_ERROR) {
					if (_ShowCantFindFileMessage(item->Text()) == B_OK) {
						_PerformProbe(item->Text());
					}
				} else {
					BString str(_FindFilePathForSymLink(JOYSTICKFILESETTINGS,
						item));
					if (str != NULL) {
						BString str(_FixPathToName(str.String()));
						int32 id = _FindStringItemInList(fConControllerL,
									new PortItem(str.String()));
						if (id > -1) {
							fConControllerL->Select(id);
							item->SetJoystickName(BString(str.String()));
						}
					}
				}
			} else {
				fConControllerL->DeselectAll();
				ShowMessage((char*)SELECTGAMEPORTFIRST);
			}
		break;
		}

		case PROBE:
		case PORT_INVOKE:
		{
			PortItem *item = _GetSelectedItem(fGamePortL);
			if (item != NULL) {
				//printf("invoke.. inte null\n");
				_PerformProbe(item->Text());
			} else
				ShowMessage((char*)SELECTGAMEPORTFIRST);
		break;
		}

		case JOY_SELECTED:
		{
			if (!fSystemUsedSelect) {
				PortItem *controllerName = _GetSelectedItem(fConControllerL);
				PortItem *portname = _GetSelectedItem(fGamePortL);
				if (portname != NULL && controllerName != NULL) {
					portname->SetJoystickName(BString(controllerName->Text()));

					BString str = portname->GetOldJoystickName();
					if (str != NULL) {
						BString strOldFile(JOYSTICKFILESETTINGS);
						strOldFile.Append(portname->Text());
						BEntry entry(strOldFile.String());
						entry.Remove();
					}
					BString strLinkPlace(JOYSTICKFILESETTINGS);
					strLinkPlace.Append(portname->Text());

					BString strLinkTo(JOYSTICKFILEPATH);
					strLinkTo.Append(controllerName->Text());

					BDirectory *dir = new BDirectory();
					dir->CreateSymLink(strLinkPlace.String(),
						strLinkTo.String(), NULL);
				} else
					ShowMessage((char*)SELECTGAMEPORTFIRST);
			}

			fSystemUsedSelect = false;
		break;
		}

		case CALIBRATE:
		case JOY_INVOKE:
		{
			PortItem *controllerName = _GetSelectedItem(fConControllerL);
			PortItem *portname = _GetSelectedItem(fGamePortL);
			if (portname != NULL) {
				if (controllerName == NULL)
					_ShowNoDeviceConnectedMessage("known", portname->Text());
				else {
					_ShowNoDeviceConnectedMessage(controllerName->Text(), portname->Text());
					/*
					ToDo:
					Check for a device, and show calibrate window if so
					*/
				}
			} else
				ShowMessage((char*)SELECTGAMEPORTFIRST);
		break;
		}
		default:
			BWindow::MessageReceived(message);
			break;
	}
}


bool
JoyWin::QuitRequested()
{
	_ApplyChanges();
	return BWindow::QuitRequested();
}


//---------------------- Private ---------------------------------//
status_t
JoyWin::_AddToList(BListView *list, uint32 command, const char* rootPath,
	BEntry *rootEntry)
{
	BDirectory root;

	if ( rootEntry != NULL )
		root.SetTo( rootEntry );
	else if ( rootPath != NULL )
		root.SetTo( rootPath );
	else
		return B_ERROR;

	BEntry entry;
	while ((root.GetNextEntry(&entry)) > B_ERROR ) {
		if (entry.IsDirectory()) {
			_AddToList(list, command, rootPath, &entry);
		} else {
			BPath path;
			entry.GetPath(&path);
			BString str(path.Path());
			str.RemoveFirst(rootPath);
			list->AddItem(new PortItem(str.String()));
		}
	}
	return B_OK;
}


status_t
JoyWin::_Calibrate()
{
	CalibWin* calibw;
	BRect rect(100, 100, 500, 400);
	calibw = new CalibWin(rect, "Calibrate", B_DOCUMENT_WINDOW_LOOK,
		B_NORMAL_WINDOW_FEEL, B_NOT_RESIZABLE | B_NOT_ZOOMABLE);
	calibw->Show();
	return B_OK;
}


status_t
JoyWin::_PerformProbe(const char* path)
{
	status_t err = B_ERROR;
	err = _ShowProbeMesage(path);
	if (err != B_OK) {
		return err;
	}

	MessageWin* mesgw = new MessageWin(Frame(),"Probing", B_MODAL_WINDOW_LOOK,
		B_MODAL_APP_WINDOW_FEEL, B_NOT_RESIZABLE | B_NOT_ZOOMABLE);

	mesgw->Show();
	int32 number = fConControllerL->CountItems();
	PortItem *item;
	for (int i = 0; i < number; i++) {
		// Do a search in JOYSTICKFILEPATH with item->Text() find the string
		// that starts with "gadget" (tex gadget = "GamePad Pro") remove
		// spacing and the "=" ty to open this one, if failed move to next and
		// try to open.. list those that suxesfully work
		fConControllerL->Select(i);
		int32 selected = fConControllerL->CurrentSelection();
		item = dynamic_cast<PortItem*>(fConControllerL->ItemAt(selected));
		BString str("Looking for: ");
		str << item->Text() << " in port " << path;
		mesgw->SetText(str.String());
		_FindSettingString(item->Text(), JOYSTICKFILEPATH);
		//Need a check to find joysticks (don't know how right now so show a
		// don't find message)
	}
	mesgw->Hide();

	//Need a if !found then show this message. else list joysticks.
	_ShowNoCompatibleJoystickMessage();
	return B_OK;
}


status_t
JoyWin::_ApplyChanges()
{
	BString str = _BuildDisabledJoysticksFile();
	//ToDo; Save the string as the file "disabled_joysticks" under settings
	//   (/boot/home/config/settings/disabled_joysticks)
	return B_OK;
}


status_t
JoyWin::_GetSettings()
{
	// ToDo; Read the file "disabled_joysticks" and make the port with the
	// same name disabled (/boot/home/config/settings/disabled_joysticks)
	return B_OK;
}


status_t
JoyWin::_CheckJoystickExist(const char* path)
{
	BString str(JOYSTICKFILESETTINGS);
	str << path;

	BFile file;
	status_t status = file.SetTo(str.String(), B_READ_ONLY | B_FAIL_IF_EXISTS);

	if (status == B_FILE_EXISTS || status == B_OK)
		return B_OK;
	else
		return B_ERROR;
}


status_t
JoyWin::_ShowProbeMesage(const char* device)
{
	BString str("An attempt will be made to probe the port '");
	str << device << "' to try to figure out what kind of joystick (if any) ";
	str << "are attached. There is a small chance this process might cause ";
	str << "your machine to lock up and require a reboot. Make sure you have ";
	str << "saved changes in all open applications before you start probing.";

	BAlert *alert = new BAlert("test1", str.String(), "Probe", "Cancel");
	alert->SetShortcut(1, B_ESCAPE);
	int32 bindex = alert->Go();

	if (bindex == 0)
		return B_OK;
	else
		return B_ERROR;
}


//Used when a files/joysticks are no were to be found
status_t
JoyWin::_ShowCantFindFileMessage(const char* port)
{
	BString str("The file '");
	str <<  _FixPathToName(port).String() << "' used by '" << port;
	str << "' cannot be found.\n Do you want to ";
	str << "try auto-detecting a joystick for this port?";

	BAlert *alert = new BAlert("test1", str.String(), "Stop", "Probe");
	alert->SetShortcut(1, B_ENTER);
	int32 bindex = alert->Go();

	if (bindex == 1)
		return B_OK;
	else
		return B_ERROR;
}


void
JoyWin::_ShowNoCompatibleJoystickMessage()
{
	BString str("There were no compatible joysticks detected on this game");
	str << " port. Try another port, or ask the manufacturer of your joystick";
	str << " for a driver designed for Haiku or BeOS.";

	BAlert *alert = new BAlert("test1", str.String(), "OK");
	alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
	alert->Go();
}

void
JoyWin::_ShowNoDeviceConnectedMessage(const char* joy, const char* port)
{
	BString str("There does not appear to be a ");
	str << joy << " device connected to the port '" << port << "'.";

	BAlert *alert = new BAlert("test1", str.String(), "Stop");
	alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
	alert->Go();
}


// Use this function to get a string of disabled ports
BString
JoyWin::_BuildDisabledJoysticksFile()
{
	BString temp("# This is a list of disabled joystick devices.");
	temp << "# Do not include the /dev/joystick/ part of the device name.";

	int32 number = fGamePortL->CountItems();
	PortItem *item;
	for (int i = 0; i < number; i++) {
		item = dynamic_cast<PortItem*>(fGamePortL->ItemAt(i));
		if (!item->IsEnabled())
			temp << "disable = \"" <<  item->Text() << "\"";
	}
	return temp;
}


PortItem*
JoyWin::_GetSelectedItem(BListView* list)
{
	int32 id = list->CurrentSelection();
	if (id > -1) {
		//PortItem *item = dynamic_cast<PortItem*>(list->ItemAt(id));
		return dynamic_cast<PortItem*>(list->ItemAt(id));
	} else {
		return NULL;
	}
}


BString
JoyWin::_FixPathToName(const char* port)
{
	BString temp(port);
	temp = temp.Remove(0, temp.FindLast('/') + 1) ;
	return temp;
}


void
JoyWin::_SelectDeselectJoystick(BListView* list, bool enable)
{
	list->DeselectAll();
	int32 number = fGamePortL->CountItems();
	PortItem *item;
	for (int i = 0; i < number; i++) {
		item = dynamic_cast<PortItem*>(list->ItemAt(i));
		if (!item) {
			printf("%s: PortItem at %d is null!\n", __func__, i);
			continue;
		}
		item->SetEnabled(enable);
	}
}


int32
JoyWin::_FindStringItemInList(BListView *view, PortItem *item)
{
	PortItem *strItem = NULL;
	int32 number = view->CountItems();
	for (int32 i = 0; i < number; i++) {
		strItem = dynamic_cast<PortItem*>(view->ItemAt(i));
		if (!strcmp(strItem->Text(), item->Text())) {
			return i;
		}
	}
	delete strItem;
	return -1;
}


BString
JoyWin::_FindFilePathForSymLink(const char* symLinkPath, PortItem *item)
{
	BPath path(symLinkPath);
	path.Append(item->Text());
	BEntry entry(path.Path());
	if (entry.IsSymLink()) {
		BSymLink symLink(&entry);
		BDirectory parent;
		entry.GetParent(&parent);
		symLink.MakeLinkedPath(&parent, &path);
		BString str(path.Path());
		return str;
	}
	return NULL;
}


status_t
JoyWin::_FindStick(const char* name)
{
	BJoystick *stick = new BJoystick();
	return stick->Open(name);
}


const char*
JoyWin::_FindSettingString(const char* name, const char* strPath)
{
	//Make a BJoystick try open it
	BString str;

	BPath path(strPath);
	path.Append(name);
	fFileTempProbeJoystick = new BFile(path.Path(), B_READ_ONLY);

	//status_t err = find_directory(B_SYSTEM_ETC_DIRECTORY, &path);
//	if (err == B_OK) {
		//BString str(path.Path());
		//str << "/joysticks/" << name;
		//printf("path'%s'\n", str.String());
		//err = file->SetTo(strPath, B_READ_ONLY);
		status_t err = fFileTempProbeJoystick->InitCheck();
		if (err == B_OK) {
			//FileReadWrite frw(fFileTempProbeJoystick);
			//printf("Get going\n");
			//printf("Opening file = %s\n", path.Path());
			//while (frw.Next(str)) {
				//printf("In While loop\n");
			//	printf("getline %s \n", str.String());
				//Test to open joystick with x number
			//}
			/*while (_GetLine(str)) {
				//printf("In While loop\n");
				printf("getline %s \n", str.String());
				//Test to open joystick with x number
			}*/
			return "";
		} else
			printf("BFile.SetTo error: %s, Path = %s\n", strerror(err), str.String());
//	} else
//		printf("find_directory error: %s\n", strerror(err));

//	delete file;
	return "";
}

/*
//Function to get a line from a file
bool
JoyWin::_GetLine(BString& string)
{
	// Fill up the buffer with the first chunk of code
	if (fPositionInBuffer == 0)
		fAmtRead = fFileTempProbeJoystick->Read(&fBuffer, sizeof(fBuffer));
	while (fAmtRead > 0) {
		while (fPositionInBuffer < fAmtRead) {
			// Return true if we hit a newline or the end of the file
			if (fBuffer[fPositionInBuffer] == '\n') {
				fPositionInBuffer++;
				//Convert begin
				int32 state = 0;
				int32 bufferLen = string.Length();
				int32 destBufferLen = bufferLen;
				char destination[destBufferLen];
//				if (fSourceEncoding)
//					convert_to_utf8(fSourceEncoding, string.String(), &bufferLen, destination, &destBufferLen, &state);
				string = destination;
				return true;
			}
			string += fBuffer[fPositionInBuffer];
			fPositionInBuffer++;
		}

		// Once the buffer runs out, grab some more and start again
		fAmtRead = fFileTempProbeJoystick->Read(&fBuffer, sizeof(fBuffer));
		fPositionInBuffer = 0;
	}
	return false;
}
*/