/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2019 Ha Thach (tinyusb.org)
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 *
 */

#include "tusb.h"
#include "ff.h"
#include "diskio.h"
#include "pico/time.h"
#include "stdlib.h"

//--------------------------------------------------------------------+
// MACRO TYPEDEF CONSTANT ENUM DECLARATION
//--------------------------------------------------------------------+
static scsi_inquiry_resp_t inquiry_resp;

//------------- Elm Chan FatFS -------------//
static FATFS fatfs[CFG_TUH_DEVICE_MAX]; // for simplicity only support 1 LUN per device

bool file_accessible = false;
FIL fp;

void log_to_usb(const char * message);

bool inquiry_complete_cb(uint8_t dev_addr, tuh_msc_complete_data_t const * cb_data)
{
  msc_cbw_t const* cbw = cb_data->cbw;
  msc_csw_t const* csw = cb_data->csw;
  FRESULT error;

  if (csw->status != 0)
  {
    printf("Inquiry failed\r\n");
    return false;
  }

  // Print out Vendor ID, Product ID and Rev
  printf("%.8s %.16s rev %.4s\r\n", inquiry_resp.vendor_id, inquiry_resp.product_id, inquiry_resp.product_rev);

  // Get capacity of device
  uint32_t const block_count = tuh_msc_get_block_count(dev_addr, cbw->lun);
  uint32_t const block_size = tuh_msc_get_block_size(dev_addr, cbw->lun);

  printf("Disk Size: %" PRIu32 " MB\r\n", block_count / ((1024*1024)/block_size));
  printf("Block Count = %" PRIu32 ", Block Size: %" PRIu32 "\r\n", block_count, block_size);


  printf("Monter le système de fichier avec FatFs\n");

  // Monter le système de fichier avec FatFs
  uint8_t const drive_num = dev_addr-1;
  char drive_path[3] = "0:";
  drive_path[0] += drive_num + DEV_USB_MIN;
  printf("dev_addr: %d\ndrive_num: %d\n", dev_addr, drive_num);
  error = f_mount(&fatfs[drive_num], drive_path, 1);
  if ( error != FR_OK )
  {
    printf("FatFs mount failed, error: %d\n", error);
    return true;
  }
  
  const char buffer[]= "Ceci est le test de Poivron Robotique\n";
  char big_buffer[0x1000]; // 4 ko
  char big_big_buffer[0x10000]; // 16 ko
  int nb_byte_written;
  char filepath[50];
  filepath[0] = drive_path[0];
  filepath[1] = ':';
  filepath[2] = '\0';
  strcat(filepath, "Poivron.txt");
  printf("filepath:%s\n", filepath);

  
  error = f_open(&fp, filepath, FA_WRITE | FA_OPEN_ALWAYS);
  if(error){
    printf("f_open: error %d\n", error);
  }
  file_accessible = true;

  // Ecrit petit buffer
  log_to_usb(buffer);
  // Ecrit gros buffer
  int size = 0;
  big_buffer[0]= '\0';
  while(size + strlen(buffer) < 0x1000){
    strcat(big_buffer, buffer);
    size += strlen(buffer);
  }
  log_to_usb(big_buffer);

  // Ecrit très gros buffer
  size = 0;
  big_big_buffer[0]= '\0';
  while(size + strlen(buffer) < 0x10000){
    strcat(big_big_buffer, buffer);
    size += strlen(buffer);
  }
  log_to_usb(big_big_buffer);

  printf("Fichier Poivron.txt cree avec succes\n");

  return true;
}

void log_to_usb(const char * message){
  int nb_byte_written;
  static int i=0;
  absolute_time_t current_time_us, start_time_us;
  start_time_us = get_absolute_time();
  FRESULT error;
  if(file_accessible){
    error = f_write(&fp, message, strlen(message), &nb_byte_written);
    if(error){
      printf("f_write: error %d\n", error);
      return;
    }
    f_sync(&fp);
    current_time_us = get_absolute_time();
    printf("Ecrit: %d octets en  %llu us\n", nb_byte_written, current_time_us - start_time_us);
    printf(">usb(Mo/s):%d:%f\n", (int) (current_time_us/1000), (float)(nb_byte_written) / (float)(current_time_us - start_time_us));
  }
}

//------------- IMPLEMENTATION -------------//
void tuh_msc_mount_cb(uint8_t dev_addr)
{
  printf("A MassStorage device is mounted\r\n");

  uint8_t const lun = 0;
  tuh_msc_inquiry(dev_addr, lun, &inquiry_resp, inquiry_complete_cb, 0);
}

void tuh_msc_umount_cb(uint8_t dev_addr)
{
  file_accessible = false;
  f_close(&fp);
  (void) dev_addr;
  printf("A MassStorage device is unmounted\r\n");
}


