/*
 * Copyright 2020, Jérôme Duval, jerome.duval@gmail.com.
 * Distributed under the terms of the MIT License.
 */
#ifndef WMI_PRIVATE_H
#define WMI_PRIVATE_H


#include <ACPI.h>
#include <new>
#include <stdio.h>
#include <string.h>

#include <lock.h>
#include <smbios.h>
#include <util/AutoLock.h>
#include <util/DoublyLinkedList.h>
#include <wmi.h>


//#define WMI_TRACE
#ifndef DRIVER_NAME
#	define DRIVER_NAME "wmi"
#endif
#ifdef WMI_TRACE
#	define TRACE(x...)		dprintf("\33[33m" DRIVER_NAME ":\33[0m " x)
#else
#	define TRACE(x...)
#endif
#define TRACE_ALWAYS(x...)	dprintf("\33[33m" DRIVER_NAME ":\33[0m " x)
#define ERROR(x...)			TRACE_ALWAYS(x)
#define CALLED() 			TRACE("CALLED %s\n", __PRETTY_FUNCTION__)


#define WMI_ACPI_DRIVER_NAME "drivers/wmi/acpi/driver_v1"
#define WMI_DEVICE_MODULE_NAME "drivers/wmi/device/driver_v1"

#define WMI_ASUS_DRIVER_NAME "drivers/wmi/asus/driver_v1"

#define WMI_BUS_COOKIE "wmi/bus/index"


class WMIACPI;
class WMIDevice;


extern device_manager_info *gDeviceManager;
extern smbios_module_info *gSMBios;
extern wmi_device_interface gWMIDeviceModule;
extern driver_module_info gWMIAsusDriverModule;


class WMIDevice {
public:
								WMIDevice(device_node* node);
								~WMIDevice();

			status_t			InitCheck();
			status_t			EvaluateMethod(uint8 instance, uint32 methodId,
									const acpi_data* in, acpi_data* out);
			status_t			InstallEventHandler(const char* guidString,
									acpi_notify_handler handler, void* context);
			status_t			RemoveEventHandler(const char* guidString);
			status_t			GetEventData(uint32 notify, acpi_data* out);
			const char*			GetUid();
private:

private:
			device_node*		fNode;
			WMIACPI* 			fBus;
			uint32				fBusCookie;
			status_t			fInitStatus;
};


typedef struct {
	uint8	guid[16];
	union {
		char	oid[2];
		struct {
			uint8 notify_id;
		};
	};
	uint8	max_instance;
	uint8	flags;
} guid_info;


struct wmi_info;
typedef struct wmi_info : DoublyLinkedListLinkImpl<wmi_info> {
	guid_info			guid;
	acpi_notify_handler	handler;
	void*				handler_context;
} wmi_info;
typedef DoublyLinkedList<wmi_info> WMIInfoList;



class WMIACPI {
public:
								WMIACPI(device_node *node);
								~WMIACPI();

			status_t			InitCheck();

			status_t			Scan();

			status_t			GetBlock(uint32 busCookie,
									uint8 instance, uint32 methodId,
									acpi_data* out);
			status_t			SetBlock(uint32 busCookie,
									uint8 instance, uint32 methodId,
									const acpi_data* in);
			status_t			EvaluateMethod(uint32 busCookie,
									uint8 instance, uint32 methodId,
									const acpi_data* in, acpi_data* out);
			status_t			InstallEventHandler(const char* guidString,
									acpi_notify_handler handler, void* context);
			status_t			RemoveEventHandler(const char* guidString);
			status_t			GetEventData(uint32 notify, acpi_data* out);
			const char*			GetUid(uint32 busCookie);
private:
			status_t			_SetEventGeneration(wmi_info* info,
									bool enabled);
			status_t			_EvaluateMethodSimple(const char* method,
									uint64 integer);
			void				_Notify(acpi_handle device, uint32 value);
	static	void				_NotifyHandler(acpi_handle device,
									uint32 value, void *context);

			void				_GuidToGuidString(uint8 guid[16],
									char* guidString);
private:
			device_node*		fNode;
			acpi_device_module_info* acpi;
			acpi_device			acpi_cookie;
			status_t			fStatus;
			WMIInfoList			fList;
			wmi_info*			fWMIInfos;
			uint32				fWMIInfoCount;
			const char*			fUid;
};


#endif // WMI_PRIVATE_H