/*
 * Copyright 2021, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 */
#ifndef _VIRTIOINPUTDEVICE_H_
#define _VIRTIOINPUTDEVICE_H_


#include <add-ons/input_server/InputServerDevice.h>
#include <AutoDeleter.h>
#include <Handler.h>
#include <InterfaceDefs.h>
#include <MessageRunner.h>


struct VirtioInputPacket;


struct KeyboardState {
	bigtime_t when;
	uint8 keys[256 / 8];
	uint32 modifiers;
};

struct TabletState {
	bigtime_t when;
	float x, y;
	float pressure;
	uint32 buttons;
	int32 clicks;
	int32 wheelX, wheelY;
};


class VirtioInputDevice : public BInputServerDevice
{
public:
							VirtioInputDevice();
	virtual					~VirtioInputDevice();

	virtual	status_t		InitCheck();

	virtual	status_t		Start(const char* name, void* cookie);
	virtual	status_t		Stop(const char* name, void* cookie);

	virtual	status_t		Control(const char* name, void* cookie,
								uint32 command, BMessage* message);
};


class VirtioInputHandler
{
public:
							VirtioInputHandler(VirtioInputDevice* dev,
								const char* name, input_device_type type);
	virtual					~VirtioInputHandler();
	inline	VirtioInputDevice*
							Device()
								{return fDev;}
	inline input_device_ref*
							Ref()
								{return &fRef;}
			void			SetFd(int fd);

			status_t		Start();
			status_t		Stop();

	static	status_t		Watcher(void* arg);

	virtual	void			Reset() = 0;
	virtual	status_t		Control(uint32 command, BMessage* message);
	virtual	void			PacketReceived(const VirtioInputPacket &pkt) = 0;

private:
			VirtioInputDevice*
							fDev;
			input_device_ref
							fRef;
			FileDescriptorCloser
							fDeviceFd;
			thread_id		fWatcherThread;
			bool			fRun;
};


class KeyboardHandler : public VirtioInputHandler
{
public:
							KeyboardHandler(VirtioInputDevice* dev,
								const char* name);
	virtual					~KeyboardHandler();

	virtual	void			Reset();
	virtual	status_t		Control(uint32 command, BMessage* message);
	virtual	void			PacketReceived(const VirtioInputPacket &pkt);

private:
	static	bool			_IsKeyPressed(const KeyboardState& state,
								uint32 key);
			void			_KeyString(uint32 code, char* str, size_t len);
			void			_StartRepeating(BMessage* msg);
			void			_StopRepeating();
	static	status_t		_RepeatThread(void* arg);
			void			_StateChanged();

private:
			KeyboardState	fState;
			KeyboardState	fNewState;
			BPrivate::AutoDeleter<key_map, BPrivate::MemoryDelete>
							fKeyMap;
			BPrivate::AutoDeleter<char, BPrivate::MemoryDelete>
							fChars;

			bigtime_t		fRepeatDelay;
			int32			fRepeatRate;
			thread_id		fRepeatThread;
			sem_id			fRepeatThreadSem;
			BMessage		fRepeatMsg;
};


class TabletHandler : public VirtioInputHandler
{
public:
							TabletHandler(VirtioInputDevice* dev,
								const char* name);

	virtual	void			Reset();
	virtual	status_t		Control(uint32 command, BMessage* message);
	virtual	void			PacketReceived(const VirtioInputPacket &pkt);

private:
	static	bool			_FillMessage(BMessage& msg, const TabletState& s);

private:
			TabletState		fState;
			TabletState		fNewState;
			bigtime_t		fLastClick;
			int				fLastClickBtn;

			bigtime_t		fClickSpeed;
};


extern "C" _EXPORT BInputServerDevice* instantiate_input_device();


#endif	// _VIRTIOINPUTDEVICE_H_