/*
   * app_clock.c
   *
   * Implementation of LoRaWAN Application Layer Clock Synchronization v1.0.0 Specification
   * https://lora-alliance.org/resource-hub/lorawanr-application-layer-clock-synchronization-specification-v100
   *
   * LoRaWAN® Application Layer Clock Synchronization Specification, authored by the FUOTA Working Group of the
   * LoRa Alliance® Technical Committee, proposes an application layer messaging package running over LoRaWAN®
   * to synchronize the real-time clock of an end-device to the network’s GPS clock with second accuracy.
   *
   * This package is useful for end-devices which do not have access to other accurate time source.
   * An end-device using LoRaWAN 1.1 or above SHOULD use DeviceTimeReq MAC command instead of this package.
   * ClassB end-devices have a more efficient way of synchronizing their clock, the classB network beacon. They
   * SHOULD NOT use this package and directly use the beacon time information.
   * End-devices with an accurate external clock source (e.g.: GPS) SHOULD use that clock source instead.
   *
   * Remark: Since GPS clock sources can be jammed or spoofed, this package can be used for secure time distribution.
   *         https://wiki.eclipse.org/images/3/3a/Eclipse-IoTDay2020Grenoble-friedt.pdf
   */
  
  /**
   * @ingroup     pkg_lorawan_app_clock
   * @{
   *
   * @file
   * @brief       Implementation of Implementation of LoRaWAN Application Layer Clock Synchronization v1.0.0 Specification.
   *
   * @author      Didier Donsez <didier.donsez@univ-grenoble-alpes.fr>
   *
   * @}
   */
  
  #define ENABLE_DEBUG (1)
  #include "debug.h"
  
  #include "app_clock.h"
  
  #include "xtimer.h"
  #include <time.h>
  
  #include "net/loramac.h"
  #include "semtech_loramac.h"
  #include "loramac_utils.h"
  
  #include "periph_conf.h"
  #include "periph/rtc.h"
  
  // 1972 and 1976 have 366 days (DELTA_EPOCH_GPS is 315964800 seconds)
  // GPS Epoch consists of a count of weeks and seconds of the week since 0 hours (midnight) Sunday 6 January 1980
  #define DELTA_EPOCH_GPS ((365*8 + 366*2 + 5)*(24*60*60))
  
  // The end-device responds by sending up to NbTransmissions AppTimeReq messages
  // with the AnsRequired bit set to 0.
  // The end-device stops re-transmissions of the AppTimeReq if a valid AppTimeAns is received.
  // If the NbTransmissions field is 0, the command SHALL be silently discarded.
  // The delay between consecutive transmissions of the AppTimeReq is application specific.
  // TODO static unsigned int NbTransmissions = 0;
  
  // TokenReq is a 4 bits counter initially set to 0. TokenReq is incremented (modulo 16) each time the end-device receives and processes successfully an AppTimeAns message.
  static unsigned int TokenReq = 0;
  
  // If the AnsRequired bit is set to 1 the end-device expects an answer whether its clock is well
  // synchronized or not. If this bit is set to 0, this signals to the AS that it only needs to answer if
  // the end-device clock is de-synchronized.
  // TODO static unsigned int AnsRequired = 1;
  
  // Period encodes the periodicity of the AppTimeReq transmissions. The actual periodicity in
  // seconds is 128.2𝑃𝑒𝑟𝑖𝑜𝑑 ±𝑟𝑎𝑛𝑑(30) where 𝑟𝑎𝑛𝑑(30) is a random integer in the +/-30sec
  // range varying with each transmission.
  static bool isPeriodDefined = false;
  static unsigned int Period = 0;
  
  #define sent_buffer_SIZE ((1 + sizeof(APP_CLOCK_PackageVersionAns_t)) + (1 + sizeof(APP_CLOCK_DeviceAppTimePeriodicityAns_t)) + (1 + sizeof(APP_CLOCK_AppTimeReq_t)))
  
  static uint8_t sent_buffer[sent_buffer_SIZE];
  
  static uint32_t sent_buffer_cursor = 0;
  
  static uint32_t sent_buffer_device_time_pos = 0;
  
  static time_t lastTimeCorrection = 0; // 01/01/1970
  
  /*
   * print a tm struct
   */
  #define TM_YEAR_OFFSET      (1900)
  /**
   * Print the time
   *
   * @param label the label prefixing the time
   * @param time the time
   */
  static void print_time(const char *label, const struct tm *time) {
  	DEBUG("%s  %04d-%02d-%02d %02d:%02d:%02d
  ", label,
  			time->tm_year + TM_YEAR_OFFSET, time->tm_mon + 1, time->tm_mday,
  			time->tm_hour, time->tm_min, time->tm_sec);
  }
  
  /**
   * Print the RTC time
   */
  void app_clock_print_rtc(void) {
  	/* read RTC */
  	struct tm current_time;
  	rtc_get_time(&current_time);
  	print_time("[clock] Current RTC time : ", &current_time);
  	struct tm lastTimeCorrectionTime = *localtime(&lastTimeCorrection);
  	if (lastTimeCorrection == 0) {
  		DEBUG("[clock] Last correction  : never
  ");
  	} else {
  		print_time("[clock] Last correction  : ", &lastTimeCorrectionTime);
  	}
  }
  
  /**
   * Get the RTC time in seconds since 1/1/1980 (GPS time)
   */
  static unsigned int getTimeSinceEpoch(void) {
  	struct tm current_time;
  	// Read the RTC current time
  	rtc_get_time(&current_time);
  	print_time("[clock] Current time: ", &current_time);
  	time_t timeSinceEpoch = mktime(&current_time);
  	// substract number of seconds between 6/1/1980 and 1/1/1970
  	timeSinceEpoch -= DELTA_EPOCH_GPS;
  	return timeSinceEpoch;
  }
  
  /**
   * Correct the RTC time
   *
   * @param timeCorrection the correction to apply to the RTC
   */
  static void correct_rtc(int timeCorrection) {
  	struct tm current_time;
  	// Read the RTC current time
  	rtc_get_time(&current_time);
  	print_time("[clock] Current time    : ", &current_time);
  	time_t timeSinceEpoch = mktime(&current_time);
  	// Apply correction
  	timeSinceEpoch += timeCorrection;
  	DEBUG("[clock] Time Correction : %d
  ", timeCorrection);
  	current_time = *localtime(&timeSinceEpoch);
  	rtc_set_time(&current_time);
  	lastTimeCorrection = mktime(&current_time);
  	print_time("[clock] RTC time fixed  : ", &current_time);
  }
  
  /**
   * Set the RTC time
   *
   * @param timeToSet the time in seconds since 6/1/1980 (GPS start time)
   */
  static void set_rtc(unsigned int timeToSet) {
  	struct tm current_time;
  	// Read the RTC current time
  	rtc_get_time(&current_time);
  	print_time("[clock] Current time    : ", &current_time);
  	time_t _TimeToSet = timeToSet + DELTA_EPOCH_GPS;
  	current_time = *localtime(&_TimeToSet);
  	rtc_set_time(&current_time);
  	lastTimeCorrection = mktime(&current_time);
  	print_time("[clock] RTC time fixed  : ", &current_time);
  }
  
  int8_t app_clock_process_downlink(semtech_loramac_t *loramac) {
  	DEBUG("[clock] app_clock_process_downlink
  ");
  
  	uint32_t len = loramac->rx_data.payload_len;
  
  	uint32_t idx = 0;
  
  	uint8_t *payload = (uint8_t*) loramac->rx_data.payload;
  
  	int8_t error = APP_CLOCK_OK;
  
  	sent_buffer_cursor = 0;
  
  	bool contains_APP_CLOCK_CID_PackageVersionReq = false;
  	bool contains_APP_CLOCK_CID_DeviceAppTimePeriodicityReq = false;
  	bool contains_APP_CLOCK_CID_AppTimeAns = false;
  	bool contains_APP_CLOCK_CID_ForceDeviceResyncReq = false;
  #ifdef EXPERIMENTAL
  	bool contains_X_APP_CLOCK_CID_AppTimeSetReq = false;
  #endif
  
  	while (idx < len && (error == APP_CLOCK_OK )) {
  		uint8_t cid = payload[idx];
  		switch (cid) {
  		case APP_CLOCK_CID_PackageVersionReq :
  			DEBUG("[clock] APP_CLOCK_CID_PackageVersionReq
  ")
  			;
  			if (contains_APP_CLOCK_CID_PackageVersionReq) {
  				error = APP_CLOCK_CID_ALREADY_PROCESS;
  				DEBUG("[clock] APP_CLOCK_CID_PackageVersionReq, error=%d
  ", error);
  				break;
  			}
  			contains_APP_CLOCK_CID_PackageVersionReq = true;
  			if (idx + 1 + 0 <= len) {
  
  				sent_buffer[sent_buffer_cursor] =
  						APP_CLOCK_CID_PackageVersionAns;
  				APP_CLOCK_PackageVersionAns_t *pva =
  						(APP_CLOCK_PackageVersionAns_t*) (sent_buffer
  								+ (1 + sent_buffer_cursor));
  				pva->PackageIdentifier = 1;
  				pva->PackageVersion = 1;
  
  				sent_buffer_cursor +=
  						(1 + sizeof(APP_CLOCK_PackageVersionAns_t));
  				idx += 1;
  			} else {
  				error = APP_CLOCK_ERROR_OVERFLOW;
  				DEBUG("[clock] APP_CLOCK_CID_PackageVersionReq, error=%d
  ", error);
  			}
  			break;
  
  		case APP_CLOCK_CID_DeviceAppTimePeriodicityReq :
  			DEBUG("[clock] APP_CLOCK_CID_DeviceAppTimePeriodicityReq
  ")
  			;
  			if (contains_APP_CLOCK_CID_DeviceAppTimePeriodicityReq) {
  				error = APP_CLOCK_CID_ALREADY_PROCESS;
  				DEBUG("[clock] APP_CLOCK_CID_DeviceAppTimePeriodicityReq, error=%d
  ",
  						error);
  				break;
  			}
  			contains_APP_CLOCK_CID_DeviceAppTimePeriodicityReq = true;
  
  			if (idx + 1 + sizeof(APP_CLOCK_DeviceAppTimePeriodicityReq_t)
  					<= len) {
  				APP_CLOCK_DeviceAppTimePeriodicityReq_t *datpr =
  						(APP_CLOCK_DeviceAppTimePeriodicityReq_t*) (payload
  								+ (idx + 1));
  
  				isPeriodDefined = true;
  				Period = datpr->Period;
  
  				sent_buffer[sent_buffer_cursor] =
  						APP_CLOCK_CID_DeviceAppTimePeriodicityAns;
  				APP_CLOCK_DeviceAppTimePeriodicityAns_t *datpa =
  						(APP_CLOCK_DeviceAppTimePeriodicityAns_t*) (sent_buffer
  								+ (1 + sent_buffer_cursor));
  				sent_buffer_device_time_pos = 1 + sent_buffer_cursor;
  				datpa->NotSupported = 0; // The endpoint is not supporting periodicity currently
  				datpa->Time = getTimeSinceEpoch();
  
  				sent_buffer_cursor += (1
  						+ sizeof(APP_CLOCK_DeviceAppTimePeriodicityAns_t));
  				idx += (1 + sizeof(APP_CLOCK_DeviceAppTimePeriodicityReq_t));
  			} else {
  				error = APP_CLOCK_ERROR_OVERFLOW;
  				DEBUG("[clock] APP_CLOCK_CID_DeviceAppTimePeriodicityReq, error=%d
  ",
  						error);
  			}
  			break;
  
  		case APP_CLOCK_CID_AppTimeAns :
  			DEBUG("[clock] APP_CLOCK_CID_AppTimeAns
  ")
  			;
  			if (contains_APP_CLOCK_CID_AppTimeAns) {
  				error = APP_CLOCK_CID_ALREADY_PROCESS;
  				DEBUG("[clock] APP_CLOCK_CID_AppTimeAns, error=%d
  ", error);
  				break;
  			}
  			contains_APP_CLOCK_CID_AppTimeAns = true;
  
  			if (idx + 1 + sizeof(APP_CLOCK_AppTimeAns_t) <= len) {
  				APP_CLOCK_AppTimeAns_t *ata = (APP_CLOCK_AppTimeAns_t*) (payload
  						+ (idx + 1));
  
  				unsigned int TokenAns = ata->TokenAns;
  				if (TokenAns != TokenReq) {
  					error = APP_CLOCK_BAD_TOKEN;
  					DEBUG("[clock] APP_CLOCK_CID_AppTimeAns, error=%d
  ", error);
  					break;
  				}
  
  				correct_rtc(ata->TimeCorrection);
  
  				// increment TokenReq
  				TokenReq++;
  				TokenReq %= 16;
  
  				idx += (1 + sizeof(APP_CLOCK_AppTimeAns_t));
  			} else {
  				error = APP_CLOCK_ERROR_OVERFLOW;
  				DEBUG("[clock] APP_CLOCK_CID_AppTimeAns, error=%d
  ", error);
  			}
  			break;
  
  		case APP_CLOCK_CID_ForceDeviceResyncReq :
  			DEBUG("[clock] APP_CLOCK_CID_ForceDeviceResyncReq
  ")
  			;
  			if (contains_APP_CLOCK_CID_ForceDeviceResyncReq) {
  				error = APP_CLOCK_CID_ALREADY_PROCESS;
  				DEBUG("[clock] APP_CLOCK_CID_ForceDeviceResyncReq, error=%d
  ", error);
  				break;
  			}
  			contains_APP_CLOCK_CID_ForceDeviceResyncReq = true;
  
  			if (idx + 1 + sizeof(APP_CLOCK_ForceDeviceResyncReq_t) <= len) {
  				APP_CLOCK_ForceDeviceResyncReq_t *fdrr =
  						(APP_CLOCK_ForceDeviceResyncReq_t*) (payload + (idx + 1));
  				unsigned int NbTransmissions = fdrr->NbTransmissions;
  				(void) NbTransmissions;
  				// TODO
  
  				idx += (1 + sizeof(APP_CLOCK_ForceDeviceResyncReq_t));
  				error = APP_CLOCK_NOT_IMPLEMENTED;
  				DEBUG("[clock] APP_CLOCK_CID_ForceDeviceResyncReq, error=%d
  ", error);
  			} else {
  				error = APP_CLOCK_ERROR_OVERFLOW;
  				DEBUG("[clock] APP_CLOCK_CID_ForceDeviceResyncReq, error=%d
  ", error);
  			}
  			break;
  
  #ifdef EXPERIMENTAL
  		case X_APP_CLOCK_CID_AppTimeSetReq :
  			DEBUG("[clock] X_APP_CLOCK_CID_AppTimeSetReq
  ")
  			;
  			if (contains_X_APP_CLOCK_CID_AppTimeSetReq) {
  				error = APP_CLOCK_CID_ALREADY_PROCESS;
  				DEBUG("[clock] X_APP_CLOCK_CID_AppTimeSetReq, error=%d
  ", error);
  				break;
  			}
  			contains_X_APP_CLOCK_CID_AppTimeSetReq = true;
  
  			if (idx + 1 + sizeof(X_APP_CLOCK_AppTimeSetReq_t) <= len) {
  				X_APP_CLOCK_AppTimeSetReq_t *atsr =
  						(X_APP_CLOCK_AppTimeSetReq_t*) (payload + (idx + 1));
  				set_rtc(atsr->TimeToSet);
  				idx += (1 + sizeof(X_APP_CLOCK_AppTimeSetReq_t));
  			} else {
  				error = APP_CLOCK_ERROR_OVERFLOW;
  				DEBUG("[clock] X_APP_CLOCK_CID_AppTimeSetReq, error=%d
  ", error);
  			}
  			break;
  #endif
  
  		default:
  			error = APP_CLOCK_UNKNOWN_CID;
  			DEBUG("[clock] APP_CLOCK : Unknown CID, error=%d
  ", error)
  			;
  			break;
  		}
  	}
  
  	DEBUG("[clock] sent_buffer:");
  	printf_ba(sent_buffer, sent_buffer_cursor);
  	DEBUG("
  ");
  
  	if (error == APP_CLOCK_OK) {
  		error = app_clock_send_buffer(loramac);
  	} else {
  		sent_buffer_cursor = 0;
  	}
  
  	// TODO if NbTransmissions > 0, send an APP_CLOCK_CID_AppTimeReq
  
  	return error;
  }
  
  int8_t app_clock_send_app_time_req(semtech_loramac_t *loramac) {
  	DEBUG("[clock] app_clock_send_app_time_req
  ");
  
  	uint8_t payload[1 + sizeof(APP_CLOCK_AppTimeReq_t)];
  	payload[0] = APP_CLOCK_CID_AppTimeReq;
  
  	APP_CLOCK_AppTimeReq_t *atr = (APP_CLOCK_AppTimeReq_t*) (payload + 1);
  	atr->TokenReq = TokenReq;
  	atr->AnsRequired = 1;
  
  	atr->DeviceTime = getTimeSinceEpoch();
  
  	// save the current fPort and set the APP_CLOCK_PORT
  	uint8_t current_fPort = semtech_loramac_get_tx_port(loramac);
  	semtech_loramac_set_tx_port(loramac, APP_CLOCK_PORT);
  
  	/* send the LoRaWAN message */
  	uint8_t ret = semtech_loramac_send(loramac, payload,
  			1 + sizeof(APP_CLOCK_AppTimeReq_t));
  
  	int8_t error;
  	if (ret != SEMTECH_LORAMAC_TX_DONE) {
  		DEBUG("[clock] Cannot send buffer : ret code: %d (%s)
  ", ret,
  				loramac_utils_err_message(ret));
  		if (ret == SEMTECH_LORAMAC_TX_SCHEDULE
  				|| ret == SEMTECH_LORAMAC_DUTYCYCLE_RESTRICTED) {
  			error = APP_CLOCK_TX_RETRY_LATER;
  		} else {
  			error = APP_CLOCK_TX_KO;
  			// reset the buffer
  			sent_buffer_cursor = 0;
  		}
  	} else {
  		error = APP_CLOCK_OK;
  	}
  
  	// restore the current fPort
  	semtech_loramac_set_tx_port(loramac, current_fPort);
  
  	return error;
  }
  
  int8_t app_clock_send_buffer(semtech_loramac_t *loramac) {
  	DEBUG("[clock] app_clock_send_buffer
  ");
  
  	int8_t error = APP_CLOCK_OK;
  
  	if (sent_buffer_cursor != 0) {
  		// save the current fPort and set the APP_CLOCK_PORT
  		uint8_t current_fPort = semtech_loramac_get_tx_port(loramac);
  		semtech_loramac_set_tx_port(loramac, APP_CLOCK_PORT);
  
  		if (sent_buffer_device_time_pos != 0) {
  			APP_CLOCK_DeviceAppTimePeriodicityAns_t *datpa =
  					(APP_CLOCK_DeviceAppTimePeriodicityAns_t*) (sent_buffer
  							+ (1 + sent_buffer_device_time_pos));
  			datpa->Time = getTimeSinceEpoch();
  		}
  		/* send the LoRaWAN message */
  		uint8_t ret = semtech_loramac_send(loramac, sent_buffer,
  				sent_buffer_cursor);
  
  		if (ret != SEMTECH_LORAMAC_TX_DONE) {
  			DEBUG("[clock] Cannot send buffer : ret code: %d (%s)
  ", ret,
  					loramac_utils_err_message(ret));
  			if (ret == SEMTECH_LORAMAC_TX_SCHEDULE
  					|| ret == SEMTECH_LORAMAC_DUTYCYCLE_RESTRICTED) {
  				error = APP_CLOCK_TX_RETRY_LATER;
  			} else {
  				error = APP_CLOCK_TX_KO;
  				// reset the buffer
  				sent_buffer_cursor = 0;
  			}
  		} else {
  			// reset the buffer
  			sent_buffer_cursor = 0;
  		}
  
  		// restore the current fPort
  		semtech_loramac_set_tx_port(loramac, current_fPort);
  	}
  
  	return error;
  }
  
  bool app_clock_is_pending_buffer(void) {
  	return sent_buffer_cursor != 0;
  }