#include "includes.h"

NvmData_Type mNvmData;
NvmData_Type mNvmDataShadow;

uint16_t drv_nvm_get_sum(uint8_t * pData, uint16_t len)
{
  uint16_t sum = 0;
  while (len > 0) {
    sum += *pData;
    pData++;
    len--;
  }
  return sum;
}

void drv_nvm_load_default_calibration_value(NvmParam_Type * pData,  uint8_t withDynamic)
{
  // NOT in this file
  //drv_nvm_load_default_calibration_static_value(pData);//gh,2024.1.3

  if (withDynamic) 
  {
  //  drv_nvm_load_default_calibration_dynamic_value(pData);
    drv_nvm_load_default_calibration_static_value(pData, 1);//gh,2024.1.3
  }
  else 
  {
    drv_nvm_load_default_calibration_static_value(pData, 0);//gh,2024.1.3
  }
}

void drv_nvm_load_default_value(NvmParam_Type * pData)
{
  pData->nvm_version = NVM_VERSION;

#if defined (FEAT_POWER_ON_NOT_ACTIVE)
  pData->lock_mcu_flash = 0;
  pData->lock_mcu_swd = 0;
#else
  pData->lock_mcu_flash = 0;
  pData->lock_mcu_swd = 0;
#endif

  drv_nvm_load_default_calibration_value(pData, 1);//gh,2024.1.3
}

void drv_nvm_init(void)
{
  uint8_t * p;
  uint16_t len;
  uint16_t dataSum0; 
  uint16_t dataSum1;
  uint32_t sn_32bits;
  //uint32_t *data_32bits_ptr;
  sn_32bits = *(__IO uint32_t*)(0x1FFFF7E8);
  sn_32bits += *(__IO uint32_t*)(0x1FFFF7EC);
  sn_32bits += *(__IO uint32_t*)(0x1FFFF7F0);
  // srand(sn_32bits);
  // uint16_t a = 0;
  // a = rand()%(9999-1000+1);
  // DreamSetBTAudioName[17] = a/1000%10 + 0x30;
  // DreamSetBTAudioName[18] = a/100%10 + 0x30;
  // DreamSetBTAudioName[19] = a/10%10 + 0x30;
  // DreamSetBTAudioName[20] = a%10 + 0x30;
  // DreamSetBLEName[16] = a/1000%10 + 0x30;
  // DreamSetBLEName[17] = a/100%10 + 0x30;
  // DreamSetBLEName[18] = a/10%10 + 0x30;
  // DreamSetBLEName[19] = a%10 + 0x30;
  len = sizeof(NvmData_Type);
  p = (uint8_t *)(INNER_FLASH_SAVE_ADDRESS);
  memcpy(&mNvmData, p, len);

  // 
  // TODO
  
  len = sizeof(NvmParam_Type);
  dataSum0 = drv_nvm_get_sum((uint8_t *)&mNvmData.data, len);
  dataSum1 = ~dataSum0;

  if ((dataSum0 != mNvmData.sum[0]) || (dataSum1 != mNvmData.sum[1]) || (mNvmData.data.nvm_version != NVM_VERSION)) {
    LOG_W("NVM", "checksum fail load default ver=%u", (unsigned)mNvmData.data.nvm_version);
    drv_nvm_load_default_value(&mNvmData.data);
    drv_nvm_save_to_flash();
  }else
  {
    drv_nvm_load_default_calibration_value(&mNvmData.data,0);
    drv_nvm_save_to_flash();
  }
  memcpy(&mNvmDataShadow, &mNvmData, sizeof(NvmData_Type));
  LOG_I("NVM", "init ok ver=%u", (unsigned)mNvmData.data.nvm_version);
}

NvmParam_Type * drv_nvm_param_ptr(void)
{
  return &mNvmData.data;
}

//uint8_t drv_nvm_save_to_flash(void)
//{
//  uint16_t len;
//  uint16_t dataSum;
//  uint16_t * pData16;
//
//  uint32_t addr;
//  NvmData_Type * NvmDataToSave;
//
//  if (memcmp (&mNvmDataShadow, &mNvmData, sizeof (NvmData_Type)) == 0) {
//    return 0;
//  }
//
//  NvmDataToSave = &mNvmData;
//
//  len = sizeof(NvmParam_Type);
//  dataSum = drv_nvm_get_sum((uint8_t *)&NvmDataToSave->data, len);
//
//  // data valid check point
//  NvmDataToSave->sum[0] = dataSum;
//  NvmDataToSave->sum[1] = ~dataSum;
//
//  memcpy (&mNvmDataShadow, &mNvmData, sizeof (NvmData_Type));
//
//  NvmDataToSave = &mNvmDataShadow;
//  
//  len = sizeof(NvmData_Type);
//  len = (len+1)/2;  
//  pData16 = (uint16_t *)NvmDataToSave;
//  addr = INNER_FLASH_SAVE_ADDRESS; // nvm storage address
//	
//  HAL_FLASH_Unlock();  
//  FLASH_PageErase(INNER_FLASH_SAVE_ADDRESS);
//  while((FLASH->SR & FLASH_SR_BSY) != 0); 
//  flash_write_nocheck(addr,pData16,len);
//  //flash_lock();	
//  HAL_FLASH_Lock();
//
//  return 1;
//}
////

uint8_t drv_nvm_save_to_flash(void)
{
  uint16_t len;
  uint16_t dataSum;
  uint16_t * pData16;

  uint32_t addr = INNER_FLASH_SAVE_ADDRESS;
  NvmData_Type * NvmDataToSave;

  // 无变化不保存
  if (memcmp(&mNvmDataShadow, &mNvmData, sizeof(NvmData_Type)) == 0) {
    LOG_D("NVM", "save skip unchanged");
    return 0;
  }

  NvmDataToSave = &mNvmData;
  len = sizeof(NvmParam_Type);
  dataSum = drv_nvm_get_sum((uint8_t *)&NvmDataToSave->data, len);

  // ���
  NvmDataToSave->sum[0] = dataSum;
  NvmDataToSave->sum[1] = ~dataSum;

  // ����
  memcpy(&mNvmDataShadow, &mNvmData, sizeof(NvmData_Type));
  NvmDataToSave = &mNvmDataShadow;

  len = sizeof(NvmData_Type);
  len = (len + 1) / 2;
  pData16 = (uint16_t *)NvmDataToSave;
  
  flash_unlock();
  flash_sector_erase(INNER_FLASH_SAVE_ADDRESS);
  flash_write_nocheck(addr,pData16,len);
  flash_lock();	

  LOG_I("NVM", "saved to flash");
  return 1;
}

extern GUI_SWITCH  mGuiData_SystemSETTING[];
extern GUI_SWITCH ParamGuiData[];
void drv_nvm_load_default_calibration_static_value(NvmParam_Type * pData,  uint8_t reset_open_status)  //gh,2023.12.30  增加了一�?参数用来判断�?开机还�?恢�?�出厂�?�置
{
  pData->nvm_version = NVM_VERSION;
  pData->Signature[0] = 0x52;
  pData->Signature[1] = 0x79;
  pData->Signature[2] = 0x61;
  pData->Signature[3] = 0x6E;
  
  memset(pData->Name,0,12);
  memcpy(pData->Name,fwname,sizeof(fwname));
  
  memset(pData->Data,0,16);
  memcpy(pData->Data,fwdata,sizeof(fwdata));
  
  memset(pData->Time,0,16);
  memcpy(pData->Time,fwtime,sizeof(fwtime));
    
  if(reset_open_status)
  {
    pData->param.BPM = 100;
    pData->param.Timbre = 0;
    pData->param.BandVol = 7;
    pData->param.StringVol = 7;
    pData->param.MIcVol = 7;
    pData->param.MicRev = 7;
    /* 与系统设置默认项一致：1 = 15分钟（设计稿 0902-07） */
    pData->param.AutoCloseTime    = 1;
    pData->param.Transpose      = 0;
    pData->param.Param1      = 0;
    pData->param.Param2      = 0;
    pData->param.Param3      = 0;
    //pData->param.Language      = 0;
  }
  mGuiData[GUI_SPEED].Current           		= pData->param.BPM;
  mGuiData[GUI_TIMBRE_SELECT].Current   		= pData->param.Timbre;
  mGuiData[GUI_TRANSPOSE].Current       		= pData->param.Transpose;
  faders[0].val 								= pData->param.BandVol;
  faders[1].val 								= pData->param.StringVol;
  faders[2].val 								= pData->param.MIcVol;
  faders[3].val 								= pData->param.MicRev;
  if (pData->param.AutoCloseTime > 3)
    pData->param.AutoCloseTime = 1;
  mGuiData_SystemSETTING[GUI_AUTOCLOSE].Current = pData->param.AutoCloseTime;
  /* 开机/出厂：同步自动关机运行时秒表 */
  AutoCloseFlag = true;
  switch (pData->param.AutoCloseTime)
  {
    case 0: AutoCloseTime = 5;  break;
    case 1: AutoCloseTime = 15; break;
    case 2: AutoCloseTime = 30; break;
    case 3: AutoCloseTime = 0; AutoCloseFlag = false; break;
    default: AutoCloseTime = 15; break;
  }
  if (AutoCloseFlag && AutoCloseTime)
    mAutoPowerOffCount = (uint16_t)(AutoCloseTime * 60);
  ParamGuiData[SONG_MODE_PARAM].Current         = pData->param.Param1;
  ParamGuiData[EXPRESS_MODE_PARAM].Current      = pData->param.Param2;
  ParamGuiData[ALL_MODE_PARAM].Current          = pData->param.Param3;

//  mGuiData[GUI_SPEED].Current   = pData->param.ReverbVolume;
//  mGuiData[GUI_SPEED].Current   = pData->param.WirelessSW;
//  mGuiData[GUI_SPEED].Current   = pData->param.WirelessChannel;
//  mGuiData[GUI_SPEED].Current   = pData->param.glissandoMax;
//  mGuiData[GUI_SPEED].Current   = pData->param.DreamSW;
  
}

//void drv_nvm_load_default_calibration_dynamic_value(NvmParam_Type * pData)
//{
//  pData->GasBase = 0xFFFFFFFF;
//  pData->tpadGate[0] = 0xFFFF;
//  pData->RokerBase[0] = 0xFFFF;
//  pData->RokerBase[1] = 0xFFFF;
//}