
// ****************************************************************************
//
//                                 Main code
//
// ****************************************************************************
// Composite HID (mouse + keyboard) example from TinyUSB

#include "include.h"

//--------------------------------------------------------------------+
// MACRO CONSTANT TYPEDEF PROTYPES
//--------------------------------------------------------------------+

/* Blink pattern
 * - 250 ms  : device not mounted
 * - 1000 ms : device mounted
 * - 2500 ms : device is suspended
 */
enum {
	BLINK_NOT_MOUNTED = 250,
	BLINK_MOUNTED = 1000,
	BLINK_SUSPENDED = 2500,
};

static uint32_t blink_interval_ms = BLINK_NOT_MOUNTED;

void led_blinking_task(void);
void hid_task(void);

/*------------- MAIN -------------*/
int main(void)
{
	board_init();
	tusb_init();

	while (1)
	{
		tud_task(); // tinyusb device task
		led_blinking_task();

		hid_task();
	}

	return 0;
}

//--------------------------------------------------------------------+
// Device callbacks
//--------------------------------------------------------------------+

// Invoked when device is mounted
void tud_mount_cb(void)
{
	blink_interval_ms = BLINK_MOUNTED;
}

// Invoked when device is unmounted
void tud_umount_cb(void)
{
	blink_interval_ms = BLINK_NOT_MOUNTED;
}

// Invoked when usb bus is suspended
// remote_wakeup_en : if host allow us  to perform remote wakeup
// Within 7ms, device must draw an average of current less than 2.5 mA from bus
void tud_suspend_cb(bool remote_wakeup_en)
{
	(void) remote_wakeup_en;
	blink_interval_ms = BLINK_SUSPENDED;
}

// Invoked when usb bus is resumed
void tud_resume_cb(void)
{
	blink_interval_ms = BLINK_MOUNTED;
}

//--------------------------------------------------------------------+
// USB HID
//--------------------------------------------------------------------+

void hid_task(void)
{
	// Poll every 10ms
	const uint32_t interval_ms = 10;
	static uint32_t start_ms = 0;

	if (board_millis() - start_ms < interval_ms) return; // not enough time
	start_ms += interval_ms;

	uint32_t const btn = 1;

	// Remote wakeup
	if (tud_suspended() && btn)
	{
		// Wake up host if we are in suspend mode
		// and REMOTE_WAKEUP feature is enabled by host
		tud_remote_wakeup();
	}

	/*------------- Mouse -------------*/
	if (tud_hid_ready())
	{
		if (btn)
		{
			int8_t const delta = 5;

			// no button, right + down, no scroll pan
			tud_hid_mouse_report(REPORT_ID_MOUSE, 0x00, delta, delta, 0, 0);

			// delay a bit before attempt to send keyboard report
			board_delay(10);
		}
	}

	/*------------- Keyboard -------------*/
	if (tud_hid_ready())
	{
		// use to avoid send multiple consecutive zero report for keyboard
		static bool has_key = false;

		static bool toggle = false;
		if (toggle = !toggle)
		{
			uint8_t keycode[6] = {0};
			keycode[0] = HID_KEY_A;

			tud_hid_keyboard_report(REPORT_ID_KEYBOARD, 0, keycode);

			has_key = true;
		}
		else
		{
			// send empty key report if previously has key pressed
			if (has_key) tud_hid_keyboard_report(REPORT_ID_KEYBOARD, 0, NULL);
			has_key = false;
		}
	}
}

// Invoked when received GET_REPORT control request
// Application must fill buffer report's content and return its length.
// Return zero will cause the stack to STALL request
uint16_t tud_hid_get_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t *buffer, uint16_t reqlen)
{
	// TODO not Implemented
	(void) report_id;
	(void) report_type;
	(void) buffer;
	(void) reqlen;

	return 0;
}

// Invoked when received SET_REPORT control request or
// received data on OUT endpoint ( Report ID = 0, Type = 0 )
void tud_hid_set_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t const *buffer, uint16_t bufsize)
{
	// TODO set LED based on CAPLOCK, NUMLOCK etc...
	(void) report_id;
	(void) report_type;
	(void) buffer;
	(void) bufsize;
}

//--------------------------------------------------------------------+
// BLINKING TASK
//--------------------------------------------------------------------+
void led_blinking_task(void)
{
	static uint32_t start_ms = 0;
	static bool led_state = false;

	// Blink every interval ms
	if (board_millis() - start_ms < blink_interval_ms) return; // not enough time
	start_ms += blink_interval_ms;

	board_led_write(led_state);
	led_state = 1 - led_state; // toggle
}
