/*
 *    Copyright (C) 2013 SAMSUNG S.LSI
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at:
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *
 */

#include <hardware/nfc.h>
#include <malloc.h>
#include <string.h>

#include "device.h"
#include "hal.h"
#include "hal_msg.h"
#include "osi.h"
#include "util.h"

#include <cutils/properties.h>

uint32_t fw_update_state = 0;
/* START [181106] Patch for supporting NCI v2.0 */
// [1. NCI Version Management]
int gNciVersion = NCI_VER_1_0;  // 0x10 : NCI 1.0, 0x20 : NCI2.0
/* END [181106] Patch for supporting NCI v2.0 */

static void nfc_hal_state_switch(tNFC_HAL_MSG* msg, eHAL_STATE state) {
  tNFC_HAL_MSG* new_msg;

  new_msg = (tNFC_HAL_MSG*)OSI_mem_get(HAL_EVT_SIZE);
  if (!new_msg) {
    OSI_loge("Failed to memory allocate!");
    nfc_stack_cback(HAL_NFC_ERROR_EVT, HAL_NFC_STATUS_OK);
    return;
  }

  nfc_hal_info.state = state;
  memcpy(new_msg, msg, sizeof(HAL_EVT_SIZE));
  OSI_queue_put(nfc_hal_info.msg_q, (void*)new_msg);
}

void hal_sleep(__attribute__((unused)) void* param) {
  nfc_hal_info.flag &= ~HAL_FLAG_PROP_ONE_TIMER;
  nfc_hal_info.cfg.override_timeout = 0;
  device_sleep();
}

void hal_update_sleep_timer(void) {
  device_wakeup();

  /* workaround for double timer */
  if (nfc_hal_info.flag & HAL_FLAG_MASK_USING_TIMER) return;

  if (nfc_hal_info.flag & HAL_FLAG_PROP_ONE_TIMER)
    OSI_timer_start(nfc_hal_info.sleep_timer, nfc_hal_info.cfg.override_timeout,
                    (tOSI_TIMER_CALLBACK)hal_sleep, NULL);
  else
    OSI_timer_start(nfc_hal_info.sleep_timer, nfc_hal_info.cfg.sleep_timeout,
                    (tOSI_TIMER_CALLBACK)hal_sleep, NULL);
}

int __send_to_device(uint8_t* data, size_t len) {
  hal_update_sleep_timer();
  if (nfc_hal_info.nci_last_pkt)
    memcpy((void*)nfc_hal_info.nci_last_pkt, (void*)data, len);

  return device_write(data, len);
}

void nfc_hal_open_sm(tNFC_HAL_MSG* msg) {
  tNFC_NCI_PKT* pkt = &msg->nci_packet;

  switch (msg->event) {
    case HAL_EVT_OPEN:
      device_set_mode(NFC_DEV_MODE_ON);
      hal_nci_send_prop_fw_cfg();
      break;
    case HAL_EVT_READ:
      nci_read_payload(msg);
      util_nci_analyzer(pkt);
      if (NCI_MT(pkt) != NCI_MT_RSP || NCI_GID(pkt) != NCI_GID_PROP ||
          NCI_OID(pkt) != NCI_PROP_FW_CFG) {
        OSI_logd("Not matched rsponse!! we expect NCI_PROP_FW_CFG_RSP");
      } else {
        if (NCI_STATUS(pkt) != NCI_STATUS_OK &&
            NCI_STATUS(pkt) != NCI_STATUS_E_SYNTAX &&
            NCI_STATUS(pkt) != NCI_CLOCK_STATUS_SYNTAX_ERROR &&
            NCI_STATUS(pkt) != NCI_CLOCK_STATUS_MISMATCHED &&
            NCI_STATUS(pkt) != NCI_CLOCK_STATUS_FULL) {
          OSI_loge("Failed to config FW, status: %d", NCI_STATUS(pkt));
          break;
        } else {
          if (NCI_STATUS(pkt) == NCI_STATUS_OK) {
            nfc_hal_info.state = HAL_STATE_POSTINIT;
            nfc_stack_cback(HAL_NFC_OPEN_CPLT_EVT, HAL_NFC_STATUS_OK);
            break;
          }
          OSI_loge("Failed to config FW, status: %d", NCI_STATUS(pkt));
        }
      }
      break;
    case HAL_EVT_COMPLETE_FAILED:
      device_set_mode(NFC_DEV_MODE_OFF);
      nfc_stack_cback(HAL_NFC_OPEN_CPLT_EVT, HAL_NFC_STATUS_FAILED);
      break;

    case HAL_EVT_TERMINATE:
      // TODO: terminate
      break;
    default:
      break;
  }
}

void nfc_hal_postinit_sm(tNFC_HAL_MSG* msg) {
  tNFC_NCI_PKT* pkt = &msg->nci_packet;

  switch (msg->event) {
    case HAL_EVT_CORE_INIT:
      nfc_hal_info.vs_info.state = VS_INIT;
      nfc_hal_state_switch(msg, HAL_STATE_VS);
      break;

    case HAL_EVT_WRITE:
      if (NCI_GID(pkt) == NCI_GID_CORE) {
        if (NCI_OID(pkt) == NCI_CORE_RESET && NCI_LEN(pkt) == 1) {
          if (nfc_hal_info.flag & HAL_FLAG_ALREADY_RESET) goto complete;

          nfc_hal_info.flag |= HAL_FLAG_W4_CORE_RESET_RSP;
          OSI_timer_start(nfc_hal_info.nci_timer, 1000,
                          (tOSI_TIMER_CALLBACK)fw_force_update, NULL);
          OSI_logd("set flag to 0x%06X", nfc_hal_info.flag);
        } else if (NCI_OID(pkt) == NCI_CORE_INIT &&
                   (NCI_LEN(pkt) == 0 || NCI_LEN(pkt) == 2)) {
          if (nfc_hal_info.flag & HAL_FLAG_ALREADY_INIT) goto complete;

          nfc_hal_info.flag |= HAL_FLAG_W4_CORE_INIT_RSP;
          OSI_timer_start(nfc_hal_info.nci_timer, 1000,
                          (tOSI_TIMER_CALLBACK)nci_init_timeout, NULL);
          OSI_logd("set flag to 0x%06X", nfc_hal_info.flag);
        }
      }
      hal_nci_send(&msg->nci_packet);
      break;

    case HAL_EVT_READ:
      nci_read_payload(msg);
      if (NCI_GID(pkt) == NCI_GID_CORE) {
        if (NCI_OID(pkt) == NCI_CORE_RESET) {
          OSI_logd("Respond CORE_RESET_RSP");
          nfc_hal_info.flag &= ~HAL_FLAG_W4_CORE_RESET_RSP;
          nfc_hal_info.flag |= HAL_FLAG_ALREADY_RESET;
          /* START [19082300] Patch for supporting NCI v2.0 */
          // [1. NCI Version Management]
          // gNciVersion : 0x10 : NCI1.0, 0x20 : NCI2.0
          if ((NCI_LEN(pkt) == 0x03) && NCI_MT(pkt) == NCI_MT_RSP)
            gNciVersion = NCI_VER_1_0;
          else {
            gNciVersion = NCI_VER_2_0;
          }
          /* END [19082300] Patch for supporting NCI v2.0 */
        } else if (NCI_OID(pkt) == NCI_CORE_INIT) {
          OSI_logd("Respond CORE_INIT_RSP");
          nfc_hal_info.flag &= ~HAL_FLAG_W4_CORE_INIT_RSP;
          nfc_hal_info.flag |= HAL_FLAG_ALREADY_INIT;
        }
        OSI_timer_stop(nfc_hal_info.nci_timer);
      }
      util_nci_analyzer(pkt);
      nfc_data_callback(&msg->nci_packet);
      break;

    case HAL_EVT_COMPLETE:
    complete:
      nfc_hal_info.flag |= HAL_FLAG_NTF_TRNS_ERROR | HAL_FLAG_RETRY_TRNS;
      nfc_hal_info.state = HAL_STATE_SERVICE;

      OSI_logd("Complete postinit sm");

      nfc_stack_cback(HAL_NFC_POST_INIT_CPLT_EVT, HAL_NFC_STATUS_OK);
      break;
    case HAL_EVT_COMPLETE_FAILED:
      nfc_stack_cback(HAL_NFC_POST_INIT_CPLT_EVT, HAL_NFC_STATUS_FAILED);
      break;

    /* START - VTS */
    case HAL_EVT_POWER_CYCLE:
      OSI_logt("HAL_EVT_POWER_CYCLE");
      device_sleep();
      device_close();
      OSI_logt("HAL state change to POWERCYCLE");
      nfc_hal_state_switch(msg, HAL_STATE_POWERCYCLE);
      break;
      /* END - VTS */

    case HAL_EVT_TERMINATE:
      // TODO: terminate
      break;
    default:
      break;
  }
}

void nfc_hal_vs_sm(tNFC_HAL_MSG* msg) {
  tNFC_HAL_VS_INFO* vs = &nfc_hal_info.vs_info;

  if (msg->event != HAL_EVT_READ && msg->event != HAL_EVT_CORE_INIT) {
    OSI_loge("Unexpected event [%d]", msg->event);
    return;
  }

  if (vs->state != VS_INIT) {
    nci_read_payload(msg);
    util_nci_analyzer(pkt);
  }

  switch (vs->state) {
    case VS_INIT:
      hal_nci_send_clearLmrt();
      vs->state = VS_W4_COMPLETE;
      break;
    case VS_W4_COMPLETE:
      OSI_logd("Vendor Specific is complete.");
      msg->event = HAL_EVT_COMPLETE;
      nfc_hal_state_switch(msg, HAL_STATE_POSTINIT);
      break;
    default:
      OSI_loge("Unexpected event [%d]", msg->event);
      break;
  }
}

void nfc_hal_service_sm(tNFC_HAL_MSG* msg) {
  tNFC_NCI_PKT* pkt = &msg->nci_packet;
  /* START [H16031401] */
  nfc_hal_info.msg_event = msg->event;
  /* END [H16031401] */

  switch (msg->event) {
    /* START - VTS */
    case HAL_EVT_CORE_INIT:
      nfc_hal_info.vs_info.state = VS_INIT;
      nfc_hal_state_switch(msg, HAL_STATE_VS);
      break;
    /* END - VTS */
    case HAL_EVT_WRITE:
      if (nfc_hal_prehandler(pkt)) hal_nci_send(pkt);
      break;
    case HAL_EVT_READ:
      nci_read_payload(msg);
      util_nci_analyzer(pkt);
      hal_update_sleep_timer();
      if (nfc_hal_prehandler(pkt)) nfc_data_callback(pkt);
      break;
    case HAL_EVT_CONTROL_GRANTED:
      nfc_hal_state_switch(msg, HAL_STATE_GRANTED);
      break;
    case HAL_EVT_TERMINATE:
      // TODO: terminate
      break;
    default:
      break;
  }
}

static void nfc_hal_grant_finish(void) {
  nfc_stack_cback(HAL_NFC_RELEASE_CONTROL_EVT, HAL_NFC_STATUS_OK);
  nfc_hal_info.state = HAL_STATE_SERVICE;
  nfc_hal_info.grant_cback = NULL;
}

void nfc_hal_grant_sm(tNFC_HAL_MSG* msg) {
  tNFC_NCI_PKT* pkt = &msg->nci_packet;
  uint8_t cback_ret = HAL_GRANT_FINISH;

  /* Granted mode is not need to SLEEP.
   * hal should pend granted mode just few time */
  switch (msg->event) {
    case HAL_EVT_READ:
      nci_read_payload(msg);
      util_nci_analyzer(pkt);
      cback_ret = nfc_hal_info.grant_cback(pkt);
      if (cback_ret == HAL_GRANT_FINISH) nfc_hal_grant_finish();

      if (cback_ret != HAL_GRANT_SEND_NEXT) break;
      [[fallthrough]];
    case HAL_EVT_CONTROL_GRANTED:
      pkt = (tNFC_NCI_PKT*)OSI_queue_get(nfc_hal_info.nci_q);
      if (pkt) {
        // TODO: Should CLF respond?
        hal_nci_send(pkt);
        OSI_mem_free((tOSI_MEM_HANDLER)pkt);
      } else
        nfc_hal_grant_finish();

      break;

    case HAL_EVT_WRITE:
      OSI_loge("HAL is in granted mode!");
      break;
  }
}
/* START - VTS */
void nfc_hal_power_sm(tNFC_HAL_MSG* msg) {
  switch (msg->event) {
    case HAL_EVT_POWER_CYCLE:
      // have to do is hal open
      OSI_logt("HAL_EVT_POWER_CYCLE");
      // nfc_hal_init();

      if (device_open()) return;

      msg->event = HAL_EVT_OPEN;
      nfc_hal_state_switch(msg, HAL_STATE_OPEN);
      break;
    default:
      break;
  }
}
/* END - VTS */

/* TASK */
void nfc_hal_task(void) {
  tNFC_HAL_MSG* msg;
  eHAL_STATE old_st;

  OSI_logt("enter!");

  if (!nfc_hal_info.msg_task || !nfc_hal_info.nci_timer ||
      !nfc_hal_info.msg_q || !nfc_hal_info.nci_q) {
    OSI_loge("msg_task = %p, nci_timer = %p, msg_q = %p, nci_q = %p",
             nfc_hal_info.msg_task, nfc_hal_info.nci_timer, nfc_hal_info.msg_q,
             nfc_hal_info.nci_q);

    nfc_hal_deinit();
    OSI_loge("nfc_hal initialization is not succeeded.");
    nfc_stack_cback(HAL_NFC_ERROR_EVT, HAL_NFC_STATUS_FAILED);
    return;
  }

  while (OSI_task_isRun(nfc_hal_info.msg_task) == OSI_RUN) {
    msg = (tNFC_HAL_MSG*)OSI_queue_get_wait(nfc_hal_info.msg_q);
    if (!msg) continue;

    OSI_logd("Got a event: %s(%d)", event_to_string(msg->event), msg->event);
    if (msg->event == HAL_EVT_TERMINATE) break;

    OSI_logd("current state: %s", state_to_string(nfc_hal_info.state));
    old_st = nfc_hal_info.state;
    switch (nfc_hal_info.state) {
      case HAL_STATE_INIT:
      case HAL_STATE_DEINIT:
      case HAL_STATE_OPEN:
        nfc_hal_open_sm(msg);
        break;
      case HAL_STATE_VS:
        nfc_hal_vs_sm(msg);
        break;
      case HAL_STATE_POSTINIT:
        nfc_hal_postinit_sm(msg);
        break;
      case HAL_STATE_SERVICE:
        nfc_hal_service_sm(msg);
        break;
      case HAL_STATE_GRANTED:
        nfc_hal_grant_sm(msg);
        break;
      /* START - VTS */
      case HAL_STATE_POWERCYCLE:
        nfc_hal_power_sm(msg);
        break;
      /* END - VTS */
      default:
        break;
    }
    OSI_mem_free((tOSI_MEM_HANDLER)msg);

    if (old_st != nfc_hal_info.state) {
      OSI_logd("hal state is changed: %s -> %s", state_to_string(old_st),
               state_to_string(nfc_hal_info.state));
    }
  }
  OSI_logt("exit!");
}

/* Print */
const char* event_to_string(uint8_t event) {
  switch (event) {
    case HAL_EVT_OPEN:
      return "HAL_EVT_OPEN";
    case HAL_EVT_CORE_INIT:
      return "HAL_EVT_CORE_INIT";
    case HAL_EVT_WRITE:
      return "HAL_EVT_WRITE";
    case HAL_EVT_READ:
      return "HAL_EVT_READ";
    case HAL_EVT_CONTROL_GRANTED:
      return "HAL_EVT_CONTROL_GRANTED";
    /* START - VTS */
    case HAL_EVT_POWER_CYCLE:
      return "HAL_EVT_POWER_CYCLE";
    /* END - VTS */
    case HAL_EVT_TERMINATE:
      return "NFC_HAL_TERMINATE";
    case HAL_EVT_COMPLETE:
      return "NFC_HAL_COMPLETE";
    case HAL_EVT_COMPLETE_FAILED:
      return "NFC_HAL_COMPLETE_FAILED";
  }
  return "Unknown event.";
}

const char* state_to_string(eHAL_STATE state) {
  switch (state) {
    case HAL_STATE_INIT:
      return "INIT";
    case HAL_STATE_DEINIT:
      return "DEINIT";
    case HAL_STATE_OPEN:
      return "OPEN";
    case HAL_STATE_VS:
      return "VENDOR_SPECIFIC";
    case HAL_STATE_POSTINIT:
      return "POST_INIT";
    case HAL_STATE_SERVICE:
      return "SERVICE";
    case HAL_STATE_GRANTED:
      return "GRANT";
    /* START - VTS */
    case HAL_STATE_POWERCYCLE:
      return "POWER_CYCLE";
      /* END - VTS */
    case HAL_STATE_CLOSE:
      return "CLOSE";
  }
  return "Unknown state.";
}