/*********************************************************************
 Adafruit invests time and resources providing this open source code,
 please support Adafruit and open-source hardware by purchasing
 products from Adafruit!

 MIT license, check LICENSE for more information
 Copyright (c) 2019 Ha Thach for Adafruit Industries
 All text above, and the splash screen below must be included in
 any redistribution
*********************************************************************/
char Lahetettava[20];
int merkkijarj=0;
// pio-usb is required for rp2040 host
#include "pio_usb.h"
#define HOST_PIN_DP   D0   // Pin used as D+ for host, D- = D+ + 1

#include "Adafruit_TinyUSB.h"

#define LANGUAGE_ID 0x0409  // English

// USB Host object
Adafruit_USBH_Host USBHost;

// holding device descriptor
tusb_desc_device_t desc_device;

#define MAX_REPORT  4
//#define PRINTREPORT // Uncomment to print the report received from the HID device
 

// Keyboard
#define USE_ANSI_ESCAPE   0
static uint8_t const keycode2ascii[128][2] =  { HID_KEYCODE_TO_ASCII };
// Each HID instance can has multiple reports
static struct
{
  uint8_t report_count;
  tuh_hid_report_info_t report_info[MAX_REPORT];
}hid_info[CFG_TUH_HID];

int outPin=D3;
int odotusaika=10;
// the setup function runs once when you press reset or power the board
void setup()
{
  Serial1.begin(115200);

  Serial.begin(115200);
  //while ( !Serial ) delay(10);   // wait for native usb

  Serial.println("TinyUSB Dual Device Info Example");
  pinMode(outPin,OUTPUT);
}

void loop()
{
  
}

// core1's setup
void setup1() {
  //while ( !Serial ) delay(10);   // wait for native usb
  Serial.println("Core1 setup to run TinyUSB host with pio-usb");

  // Check for CPU frequency, must be multiple of 120Mhz for bit-banging USB
  uint32_t cpu_hz = clock_get_hz(clk_sys);
  if ( cpu_hz != 120000000UL && cpu_hz != 240000000UL ) {
    while ( !Serial ) delay(10);   // wait for native usb
    Serial.printf("Error: CPU Clock = %u, PIO USB require CPU clock must be multiple of 120 Mhz\r\n", cpu_hz);
    Serial.printf("Change your CPU Clock to either 120 or 240 Mhz in Menu->CPU Speed \r\n", cpu_hz);
    while(1) delay(1);
  }

  pio_usb_configuration_t pio_cfg = PIO_USB_DEFAULT_CONFIG;
  pio_cfg.pin_dp = HOST_PIN_DP;
  USBHost.configure_pio_usb(1, &pio_cfg);

  // run host stack on controller (rhport) 1
  // Note: For rp2040 pico-pio-usb, calling USBHost.begin() on core1 will have most of the
  // host bit-banging processing works done in core1 to free up core0 for other works
  USBHost.begin(1);
}

// core1's loop
void loop1()
{
  USBHost.task();
}

//--------------------------------------------------------------------+
// TinyUSB Host callbacks
//--------------------------------------------------------------------+

// Invoked when device is mounted (configured)
void tuh_mount_cb (uint8_t daddr)
{
  Serial.printf("Device attached, address = %d\r\n", daddr);

  // Get Device Descriptor
  tuh_descriptor_get_device(daddr, &desc_device, 18, print_device_descriptor, 0);
}

/// Invoked when device is unmounted (bus reset/unplugged)
void tuh_umount_cb(uint8_t daddr)
{
  Serial.printf("Device removed, address = %d\r\n", daddr);
}

// Invoked when device with hid interface is mounted
// Report descriptor is also available for use. tuh_hid_parse_report_descriptor()
// can be used to parse common/simple enough descriptor.
// Note: if report descriptor length > CFG_TUH_ENUMERATION_BUFSIZE, it will be skipped
// therefore report_desc = NULL, desc_len = 0
void tuh_hid_mount_cb(uint8_t dev_addr, uint8_t instance, uint8_t const* desc_report, uint16_t desc_len)
{
  uint16_t vid, pid;
  tuh_vid_pid_get(dev_addr, &vid, &pid);
  Serial.printf("HID device address = %d, instance = %d is mounted\r\n", dev_addr, instance);
  Serial.printf("VID = %04x, PID = %04x\r\n", vid, pid);
  // By default host stack will use activate boot protocol on supported interface.
  // Therefore for this simple example, we only need to parse generic report descriptor (with built-in parser)
  hid_info[instance].report_count = tuh_hid_parse_report_descriptor(hid_info[instance].report_info, MAX_REPORT, desc_report, desc_len);
  Serial.printf("HID has %u reports \r\n", hid_info[instance].report_count);
  uint8_t const itf_protocol = tuh_hid_interface_protocol(dev_addr, instance);
  switch(itf_protocol){
    case HID_ITF_PROTOCOL_NONE: //HID_PROTOCOL_BOOT:NONE
      Serial.printf("Detected NONE\r\n");
    case HID_ITF_PROTOCOL_KEYBOARD: //HID_PROTOCOL_BOOT:KEYBOARD
      Serial.printf("Detected KEYBOARD\r\n");
      break;
  }
  if ( !tuh_hid_receive_report(dev_addr, instance) )
  {
    Serial.printf("Error: cannot request to receive report\r\n");
  }
  Serial.printf("------------------------------------------------\r\n");
}

// Invoked when device with hid interface is un-mounted
void tuh_hid_umount_cb(uint8_t dev_addr, uint8_t instance)
{
  Serial.printf("HID device address = %d, instance = %d is unmounted\r\n", dev_addr, instance);
  Serial.printf("--------------------------------------------------\r\n");
  //if (ds4_mounted && ds4_dev_addr == dev_addr && ds4_instance == instance)
  //{
  //  ds4_mounted = false;
  //  Serial.printf("DualShock4 is unmounted\r\n");
  //}
}

// Invoked when received report from device via interrupt endpoint
void tuh_hid_report_received_cb(uint8_t dev_addr, uint8_t instance, uint8_t const* report, uint16_t len)
{
#ifdef PRINTREPORT
  Serial.println("tuh_hid_report_received_cb");
  Serial.print(":dev_addr = ");
  Serial.print(dev_addr);
  Serial.print(" :instance = ");
  Serial.println(instance);
  Serial.print("report");
  for(uint16_t i=0;i<len;i++){
    Serial.print(":");
    if(report[i]<0x10) Serial.print("0");
    Serial.print(report[i],HEX);
  }
  Serial.println("");
#endif
  uint8_t const itf_protocol = tuh_hid_interface_protocol(dev_addr, instance);
  switch (itf_protocol)
  {
    case HID_ITF_PROTOCOL_KEYBOARD:
//    Serial.printf("HID receive boot keyboard report\r\n");
      process_boot_kbd_report( (hid_keyboard_report_t const*) report );
    break;
//    case HID_ITF_PROTOCOL_MOUSE:
//    Serial.printf("HID receive boot mouse report\r\n");
//      if ( is_elecom_12bit_mouse(dev_addr) )
//      {
//        process_xy12mouse_report( (xy12mouse_report_t const*) report );
//      }
//      else
//      if ( is_elecom_16bit_mouse(dev_addr) )
//      {
//        process_xy16mouse_report( (xy16mouse_report_t const*) report );
//      }
//      else
//      {
//        process_boot_mouse_report( (hid_mouse_report_t const*) report );
//      }
//    break;
    default:
      // Generic report requires matching ReportID and contents with previous parsed report info
      process_generic_report(dev_addr, instance, report, len);
    break;
  }
  // continue to request to receive report
  if ( !tuh_hid_receive_report(dev_addr, instance) )
  {
    Serial.printf("Error: cannot request to receive report\r\n");
  }
}
 

//--------------------------------------------------------------------+
// Generic Report
//--------------------------------------------------------------------+
void process_generic_report(uint8_t dev_addr, uint8_t instance, uint8_t const* report, uint16_t len)
{
#ifdef PRINTREPORT
  Serial.println("process_generic_report");
  Serial.print(":dev_addr = ");
  Serial.print(dev_addr);
  Serial.print(" :instance = ");
  Serial.println(instance);
  Serial.print("report");
  for(uint16_t i=0;i<len;i++){
    Serial.print(":");
    if(report[i]<0x10) Serial.print("0");
    Serial.print(report[i],HEX);
  }
  Serial.println("");
#endif
  uint8_t const rpt_count = hid_info[instance].report_count;
  tuh_hid_report_info_t* rpt_info_arr = hid_info[instance].report_info;
  tuh_hid_report_info_t* rpt_info = NULL;
  if ( rpt_count == 1 && rpt_info_arr[0].report_id == 0)
  {
    // Simple report without report ID as 1st byte
    rpt_info = &rpt_info_arr[0];
  }else
  {
    // Composite report, 1st byte is report ID, data starts from 2nd byte
    uint8_t const rpt_id = report[0];
    // Find report id in the array
    for(uint8_t i=0; i<rpt_count; i++)
    {
      if (rpt_id == rpt_info_arr[i].report_id )
      {
        rpt_info = &rpt_info_arr[i];
        break;
      }
    }
    report++;
    len--;
  }
  uint16_t vid, pid;
  tuh_vid_pid_get(dev_addr, &vid, &pid);
  // For complete list of Usage Page & Usage checkout src/class/hid/hid.h. For examples:
  // - Keyboard                     : Desktop, Keyboard
  // - Mouse                        : Desktop, Mouse
  // - Gamepad                      : Desktop, Gamepad
  // - Consumer Control (Media Key) : Consumer, Consumer Control
  // - System Control (Power key)   : Desktop, System Control
  // - Generic (vendor)             : 0xFFxx, xx
  if ( rpt_info->usage_page == HID_USAGE_PAGE_DESKTOP )
  {
    switch (rpt_info->usage)
    {
      case HID_USAGE_DESKTOP_KEYBOARD:
        Serial.println("process_generic_report");
        Serial.println("HID receive keyboard report");
/*
        if ((vid == xxxx) && (pid == yyyy))
        {
          process_other_kbd_report(dev_addr, instance, report, len);
        } else
*/
        {
          // Assume keyboard follow boot report layout
          process_boot_kbd_report( (hid_keyboard_report_t const*) report );
        }
        break;
//      case HID_USAGE_DESKTOP_MOUSE:
//        Serial.println("process_generic_report");
//        Serial.println("HID receive mouse report");
/*
        if ((vid == xxxx) && (pid == yyyy))
        {
          process_other_mouse_report(dev_addr, instance, report, len);
        } else
*/
//       {
//          // Assume mouse follow boot report layout
//          process_boot_mouse_report( (hid_mouse_report_t const*) report );
//        }
//        break;
      default:
        Serial.println("process_generic_report");
        Serial.println("HID device report other than keyboard and mouce");
/*
        if ((vid == xxxx) && (pid == yyyy))
        {
          process_aaa_report(dev_addr, instance, report, len);
        }
*/
        break;
    }
  }
  else //Other than HID_USAGE_PAGE_DESKTOP
  {
//  Serial.printf("Other than HID_USAGE_PAGE_DESKTOP\r\n");
//    if ( ds4_mounted )
//    {
//      process_sony_ds4(report, len);
//    }
/*
    else if ((vid == xxxx) && (pid == yyyy))
    {
      process_bbb_report(dev_addr, instance, report, len);
    }
*/
  }
}
 

//--------------------------------------------------------------------+
// Keyboard
//--------------------------------------------------------------------+
// look up new key in previous keys
static inline bool find_key_in_report(hid_keyboard_report_t const *report, uint8_t keycode)
{
  for(uint8_t i=0; i<6; i++)
  {
    if (report->keycode[i] == keycode)  return true;
  }
  return false;
}

void process_boot_kbd_report(hid_keyboard_report_t const *report)
{
  hid_keyboard_report_t prev_report = { 0, 0, {0} }; // previous report to check key released
  //------------- example code ignore control (non-printable) key affects -------------//
  for(uint8_t i=0; i<6; i++)
  {
    if ( report->keycode[i] )
    {
      if ( find_key_in_report(&prev_report, report->keycode[i]) )
      {
        // exist in previous report means the current key is holding
      }else
      {
        // not existed in previous report means the current key is pressed
        bool const is_shift = report->modifier & (KEYBOARD_MODIFIER_LEFTSHIFT | KEYBOARD_MODIFIER_RIGHTSHIFT);
        char ch = keycode2ascii[report->keycode[i]][is_shift ? 1 : 0];
//      uint8_t ch = keycode2ascii[report->keycode[i]][is_shift ? 1 : 0];
        
        //Serial.print(ch);
        Lahetettava[merkkijarj]=ch;
        //Serial.print(merkkijarj);
        merkkijarj=merkkijarj+1;
        
        //Serial.print("t");
//      putchar(ch);
//        if ( ch == '\r' ) Serial.print('\n'); // added new line for enter key // aluksi eikomment
        if ( ch == '\r' ) {
          Aarnetransmit(Lahetettava,merkkijarj);
          //Aarnetransmit("1234567890123456789012345678901234567890",40);
        }
//      if ( ch == '\r' ) putchar('\n'); // added new line for enter key
//      fflush(stdout); // flush right away, else nanolib will wait for newline
      }
    }
    // TODO example skips key released
  }
  prev_report = *report;
}

void print_device_descriptor(tuh_xfer_t* xfer)
{
  if ( XFER_RESULT_SUCCESS != xfer->result )
  {
    Serial.printf("Failed to get device descriptor\r\n");
    return;
  }

  uint8_t const daddr = xfer->daddr;

  Serial.printf("Device %u: ID %04x:%04x\r\n", daddr, desc_device.idVendor, desc_device.idProduct);
  Serial.printf("Device Descriptor:\r\n");
  Serial.printf("  bLength             %u\r\n"     , desc_device.bLength);
  Serial.printf("  bDescriptorType     %u\r\n"     , desc_device.bDescriptorType);
  Serial.printf("  bcdUSB              %04x\r\n"   , desc_device.bcdUSB);
  Serial.printf("  bDeviceClass        %u\r\n"     , desc_device.bDeviceClass);
  Serial.printf("  bDeviceSubClass     %u\r\n"     , desc_device.bDeviceSubClass);
  Serial.printf("  bDeviceProtocol     %u\r\n"     , desc_device.bDeviceProtocol);
  Serial.printf("  bMaxPacketSize0     %u\r\n"     , desc_device.bMaxPacketSize0);
  Serial.printf("  idVendor            0x%04x\r\n" , desc_device.idVendor);
  Serial.printf("  idProduct           0x%04x\r\n" , desc_device.idProduct);
  Serial.printf("  bcdDevice           %04x\r\n"   , desc_device.bcdDevice);

  // Get String descriptor using Sync API
  uint16_t temp_buf[128];

  Serial.printf("  iManufacturer       %u     "     , desc_device.iManufacturer);
  if (XFER_RESULT_SUCCESS == tuh_descriptor_get_manufacturer_string_sync(daddr, LANGUAGE_ID, temp_buf, sizeof(temp_buf)) )
  {
    print_utf16(temp_buf, TU_ARRAY_SIZE(temp_buf));
  }
  Serial.printf("\r\n");

  Serial.printf("  iProduct            %u     "     , desc_device.iProduct);
  if (XFER_RESULT_SUCCESS == tuh_descriptor_get_product_string_sync(daddr, LANGUAGE_ID, temp_buf, sizeof(temp_buf)))
  {
    print_utf16(temp_buf, TU_ARRAY_SIZE(temp_buf));
  }
  Serial.printf("\r\n");

  Serial.printf("  iSerialNumber       %u     "     , desc_device.iSerialNumber);
  if (XFER_RESULT_SUCCESS == tuh_descriptor_get_serial_string_sync(daddr, LANGUAGE_ID, temp_buf, sizeof(temp_buf)))
  {
    print_utf16(temp_buf, TU_ARRAY_SIZE(temp_buf));
  }
  Serial.printf("\r\n");

  Serial.printf("  bNumConfigurations  %u\r\n"     , desc_device.bNumConfigurations);
}

//--------------------------------------------------------------------+
// String Descriptor Helper
//--------------------------------------------------------------------+

static void _convert_utf16le_to_utf8(const uint16_t *utf16, size_t utf16_len, uint8_t *utf8, size_t utf8_len) {
  // TODO: Check for runover.
  (void)utf8_len;
  // Get the UTF-16 length out of the data itself.

  for (size_t i = 0; i < utf16_len; i++) {
    uint16_t chr = utf16[i];
    if (chr < 0x80) {
      *utf8++ = chr & 0xff;
    } else if (chr < 0x800) {
      *utf8++ = (uint8_t)(0xC0 | (chr >> 6 & 0x1F));
      *utf8++ = (uint8_t)(0x80 | (chr >> 0 & 0x3F));
    } else {
      // TODO: Verify surrogate.
      *utf8++ = (uint8_t)(0xE0 | (chr >> 12 & 0x0F));
      *utf8++ = (uint8_t)(0x80 | (chr >> 6 & 0x3F));
      *utf8++ = (uint8_t)(0x80 | (chr >> 0 & 0x3F));
    }
    // TODO: Handle UTF-16 code points that take two entries.
  }
}

// Count how many bytes a utf-16-le encoded string will take in utf-8.
static int _count_utf8_bytes(const uint16_t *buf, size_t len) {
  size_t total_bytes = 0;
  for (size_t i = 0; i < len; i++) {
    uint16_t chr = buf[i];
    if (chr < 0x80) {
      total_bytes += 1;
    } else if (chr < 0x800) {
      total_bytes += 2;
    } else {
      total_bytes += 3;
    }
    // TODO: Handle UTF-16 code points that take two entries.
  }
  return total_bytes;
}

static void print_utf16(uint16_t *temp_buf, size_t buf_len) {
  size_t utf16_len = ((temp_buf[0] & 0xff) - 2) / sizeof(uint16_t);
  size_t utf8_len = _count_utf8_bytes(temp_buf + 1, utf16_len);

  _convert_utf16le_to_utf8(temp_buf + 1, utf16_len, (uint8_t *) temp_buf, sizeof(uint16_t) * buf_len);
  ((uint8_t*) temp_buf)[utf8_len] = '\0';

  Serial.printf((char*)temp_buf);
}

void Aarnetransmit(String transmitstring, int merkkeja) {
  Serial.println(transmitstring);
  Serial.println(merkkeja);
  merkkijarj=0;
  for (int i = 1; i <= 4; i++) {
    delay(odotusaika);
    digitalWrite(outPin,HIGH);
  }

  for (int jj=0;jj<=merkkeja;jj++){
    //Serial.println(transmitstring[jj]);
    if(transmitstring[jj]=='1') {
      //Serial.println(transmitstring[jj]);
      delay(odotusaika);
      digitalWrite(outPin,LOW);
      delay(odotusaika);
      digitalWrite(outPin,LOW);
      delay(odotusaika);
      digitalWrite(outPin,LOW);
      delay(odotusaika);
      digitalWrite(outPin,HIGH);
    }
    if(transmitstring[jj]=='2') {
      //Serial.println(transmitstring[jj]);
      delay(odotusaika);
      digitalWrite(outPin,LOW);
      delay(odotusaika);
      digitalWrite(outPin,LOW);
      delay(odotusaika);
      digitalWrite(outPin,HIGH);
      delay(odotusaika);
      digitalWrite(outPin,LOW);
    }
    if(transmitstring[jj]=='3') {
      //Serial.println(transmitstring[jj]);
      delay(odotusaika);
      digitalWrite(outPin,LOW);
      delay(odotusaika);
      digitalWrite(outPin,LOW);
      delay(odotusaika);
      digitalWrite(outPin,HIGH);
      delay(odotusaika);
      digitalWrite(outPin,HIGH);
    }
    if(transmitstring[jj]=='4') {
      //Serial.println(transmitstring[jj]);
      delay(odotusaika);
      digitalWrite(outPin,LOW);
      delay(odotusaika);
      digitalWrite(outPin,HIGH);
      delay(odotusaika);
      digitalWrite(outPin,LOW);
      delay(odotusaika);
      digitalWrite(outPin,LOW);
    }
    if(transmitstring[jj]=='5') {
      //Serial.println(transmitstring[jj]);
      delay(odotusaika);
      digitalWrite(outPin,LOW);
      delay(odotusaika);
      digitalWrite(outPin,HIGH);
      delay(odotusaika);
      digitalWrite(outPin,LOW);
      delay(odotusaika);
      digitalWrite(outPin,HIGH);
    }
    if(transmitstring[jj]=='6') {
      //Serial.println(transmitstring[jj]);
      delay(odotusaika);
      digitalWrite(outPin,LOW);
      delay(odotusaika);
      digitalWrite(outPin,HIGH);
      delay(odotusaika);
      digitalWrite(outPin,HIGH);
      delay(odotusaika);
      digitalWrite(outPin,LOW);
    }
    if(transmitstring[jj]=='7') {
      //Serial.println(transmitstring[jj]);
      delay(odotusaika);
      digitalWrite(outPin,LOW);
      delay(odotusaika);
      digitalWrite(outPin,HIGH);
      delay(odotusaika);
      digitalWrite(outPin,HIGH);
      delay(odotusaika);
      digitalWrite(outPin,HIGH);
    }
    if(transmitstring[jj]=='8') {
      //Serial.println(transmitstring[jj]);
      delay(odotusaika);
      digitalWrite(outPin,HIGH);
      delay(odotusaika);
      digitalWrite(outPin,LOW);
      delay(odotusaika);
      digitalWrite(outPin,LOW);
      delay(odotusaika);
      digitalWrite(outPin,LOW);
    }
    if(transmitstring[jj]=='9') {
      //Serial.println(transmitstring[jj]);
      delay(odotusaika);
      digitalWrite(outPin,HIGH);
      delay(odotusaika);
      digitalWrite(outPin,LOW);
      delay(odotusaika);
      digitalWrite(outPin,LOW);
      delay(odotusaika);
      digitalWrite(outPin,HIGH);
    }
    if(transmitstring[jj]=='0') {
      //Serial.println(transmitstring[jj]);
      delay(odotusaika);
      digitalWrite(outPin,HIGH);
      delay(odotusaika);
      digitalWrite(outPin,LOW);
      delay(odotusaika);
      digitalWrite(outPin,HIGH);
      delay(odotusaika);
      digitalWrite(outPin,LOW);
    }

  }

  for (int i = 0; i <= 4; i++) {
    delay(odotusaika);
    digitalWrite(outPin,LOW);
  }

}