/*
 *  spreadspace avr utils
 *
 *
 *  Copyright (C) 2013-2018 Christian Pointner <equinox@spreadspace.org>
 *
 *  This file is part of spreadspace avr utils.
 *
 *  spreadspace avr utils is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  any later version.
 *
 *  spreadspace avr utils is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with spreadspace avr utils. If not, see <http://www.gnu.org/licenses/>.
 */


#include <avr/io.h>
#include <avr/wdt.h>
#include <avr/interrupt.h>
#include <avr/power.h>
#include <stdio.h>

#include "util.h"
#include "led.h"
#include "serialio.h"

/*
             LUFA Library
     Copyright (C) Dean Camera, 2014.

  dean [at] fourwalledcubicle [dot] com
           www.lufa-lib.org
*/
#include <LUFA/Drivers/USB/USB.h>
#include <LUFA/Drivers/Misc/RingBuffer.h>
#include "lufa-descriptor-keyboardmouse.h"

static uint8_t PrevKeyboardHIDReportBuffer[sizeof(USB_KeyboardReport_Data_t)];
static uint8_t PrevMouseHIDReportBuffer[sizeof(USB_MouseReport_Data_t)];

USB_ClassInfo_HID_Device_t Keyboard_HID_Interface =
  {
    .Config =
      {
        .InterfaceNumber              = INTERFACE_ID_Keyboard,
        .ReportINEndpoint             =
          {
            .Address              = KEYBOARD_IN_EPADDR,
            .Size                 = HID_EPSIZE,
            .Banks                = 1,
          },
        .PrevReportINBuffer           = PrevKeyboardHIDReportBuffer,
        .PrevReportINBufferSize       = sizeof(PrevKeyboardHIDReportBuffer),
      },
  };

USB_ClassInfo_HID_Device_t Mouse_HID_Interface =
  {
    .Config =
      {
        .InterfaceNumber              = INTERFACE_ID_Mouse,
        .ReportINEndpoint             =
          {
            .Address              = MOUSE_IN_EPADDR,
            .Size                 = HID_EPSIZE,
            .Banks                = 1,
          },
        .PrevReportINBuffer           = PrevMouseHIDReportBuffer,
        .PrevReportINBufferSize       = sizeof(PrevMouseHIDReportBuffer),
      },
  };

void EVENT_USB_Device_ConfigurationChanged(void)
{
  HID_Device_ConfigureEndpoints(&Keyboard_HID_Interface);
  HID_Device_ConfigureEndpoints(&Mouse_HID_Interface);

  USB_Device_EnableSOFEvents();
}

/** Event handler for the library USB Control Request reception event. */
void EVENT_USB_Device_ControlRequest(void)
{
  HID_Device_ProcessControlRequest(&Keyboard_HID_Interface);
  HID_Device_ProcessControlRequest(&Mouse_HID_Interface);
}

/** Event handler for the USB device Start Of Frame event. */
void EVENT_USB_Device_StartOfFrame(void)
{
  HID_Device_MillisecondElapsed(&Keyboard_HID_Interface);
  HID_Device_MillisecondElapsed(&Mouse_HID_Interface);
}
/* end LUFA CDC-ACM specific definitions*/

static RingBuffer_t keyboard_buffer;
static uint8_t keyboard_buffer_data[16];
static RingBuffer_t mouse_buffer;
static uint8_t mouse_buffer_data[16];

bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo,
                                         uint8_t* const ReportID,
                                         const uint8_t ReportType,
                                         void* ReportData,
                                         uint16_t* const ReportSize)
{

  if (HIDInterfaceInfo == &Keyboard_HID_Interface) {
    USB_KeyboardReport_Data_t* KeyboardReport = (USB_KeyboardReport_Data_t*)ReportData;

    if(!RingBuffer_IsEmpty(&keyboard_buffer)) {
      uint8_t received_byte = RingBuffer_Remove(&keyboard_buffer);
      switch(received_byte) {
      case '1': KeyboardReport->KeyCode[0] = HID_KEYBOARD_SC_1_AND_EXCLAMATION; break;
      case '2': KeyboardReport->KeyCode[0] = HID_KEYBOARD_SC_2_AND_AT; break;
      case '3': KeyboardReport->KeyCode[0] = HID_KEYBOARD_SC_3_AND_HASHMARK; break;
      case '4': KeyboardReport->KeyCode[0] = HID_KEYBOARD_SC_4_AND_DOLLAR; break;
      case 'c': KeyboardReport->KeyCode[0] = HID_KEYBOARD_SC_CAPS_LOCK; break;
      default: return 0; // no key has been pressed - just return
      }
    }
//    KeyboardReport->Modifier = HID_KEYBOARD_MODIFIER_LEFTSHIFT;

    *ReportSize = sizeof(USB_KeyboardReport_Data_t);
    return false;

  }
  else
  {
    USB_MouseReport_Data_t* MouseReport = (USB_MouseReport_Data_t*)ReportData;

    MouseReport->Y = 0;
    MouseReport->X = 0;
    if(!RingBuffer_IsEmpty(&mouse_buffer)) {
      uint8_t received_byte = RingBuffer_Remove(&mouse_buffer);
      switch(received_byte) {
      case 'w': MouseReport->Y = -1; break; // UP
      case 's': MouseReport->Y =  1; break; // DOWN
      case 'a': MouseReport->X = -1; break; // LEFT
      case 'd': MouseReport->X =  1; break; // RIGHT
      case 'q': MouseReport->Button |= (1 << 0); break; // Button 1
      case 'e': MouseReport->Button |= (1 << 1); break; // Button 2
      }
    }
    *ReportSize = sizeof(USB_MouseReport_Data_t);
    return true;
  }
}

void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo,
                                          const uint8_t ReportID,
                                          const uint8_t ReportType,
                                          const void* ReportData,
                                          const uint16_t ReportSize)
{
  if (HIDInterfaceInfo == &Keyboard_HID_Interface)
  {
    uint8_t* LEDReport = (uint8_t*)ReportData;

    /* if (*LEDReport & HID_KEYBOARD_LED_NUMLOCK) */
    /*       // do something */

    if (*LEDReport & HID_KEYBOARD_LED_CAPSLOCK)
      led_on();
    else
      led_off();

    /* if (*LEDReport & HID_KEYBOARD_LED_SCROLLLOCK) */
    /*       // do something */
  }
}

int main(void)
{
  MCUSR &= ~(1 << WDRF);
  wdt_disable();

  cpu_init();
  led_init();
  USB_Init();
  serialio_init(115200, false);
  RingBuffer_InitBuffer(&keyboard_buffer, keyboard_buffer_data, sizeof(keyboard_buffer_data));
  RingBuffer_InitBuffer(&mouse_buffer, mouse_buffer_data, sizeof(mouse_buffer_data));

  sei();

  for(;;) {
    if(serialio_bytes_received()) {
      int received_byte = fgetc(stdin);
      switch(received_byte) {
      case '1':
      case '2':
      case '3':
      case '4':
      case 'c':
        RingBuffer_Insert(&keyboard_buffer, (uint8_t)received_byte); break;
      case 'w':
      case 's':
      case 'a':
      case 'd':
      case 'q':
      case 'e':
        RingBuffer_Insert(&mouse_buffer, (uint8_t)received_byte); break;
      }
    }

    HID_Device_USBTask(&Keyboard_HID_Interface);
    HID_Device_USBTask(&Mouse_HID_Interface);
    USB_USBTask();
  }
}