#include "slave_monitoring.h"

#include "main.h"
#include "ts_state_machine.h"

#include "can-halal.h"

#include "stm32f3xx_hal.h"
#include "stm32f3xx_hal_gpio.h"

#include <stdint.h>
#include <string.h>

SlaveHandle slaves[N_SLAVES];
uint16_t min_voltage;
int16_t max_temp;

void slaves_init() {
  for (int i = 0; i < N_SLAVES; i++) {
    slaves[i].id = i;
    slaves[i].error.kind = SLAVE_ERR_NONE;
    slaves[i].last_message = 0;
    slaves[i].min_voltage = 0;
    slaves[i].max_voltage = 0;
    slaves[i].max_temp = 0;
  }

  HAL_GPIO_WritePin(SLAVE_POWER_0_GPIO_Port, SLAVE_POWER_0_Pin, GPIO_PIN_SET);
  HAL_GPIO_WritePin(SLAVE_POWER_1_GPIO_Port, SLAVE_POWER_1_Pin, GPIO_PIN_RESET);
  HAL_GPIO_WritePin(SLAVE_POWER_DSEL_GPIO_Port, SLAVE_POWER_DSEL_Pin,
                    GPIO_PIN_RESET);
  // TODO: Enable & read out current
  HAL_GPIO_WritePin(SLAVE_POWER_DEN_GPIO_Port, SLAVE_POWER_DEN_Pin,
                    GPIO_PIN_RESET);
}

void slaves_check() {
  int any_slave_error = 0;
  uint32_t now = HAL_GetTick();
  uint16_t min_voltage_new = 0xFFFF;
  int16_t max_temp_new = 0xFFFF;
  for (int i = 0; i < N_SLAVES; i++) {
    if (now - slaves[i].last_message >= SLAVE_TIMEOUT) {
      // Don't overwrite a different error kind
      if (slaves[i].error.kind == SLAVE_ERR_NONE) {
        slaves[i].error.kind = SLAVE_ERR_TIMEOUT;
      }
    } else if (slaves[i].error.kind == SLAVE_ERR_TIMEOUT) {
      slaves[i].error.kind = SLAVE_ERR_NONE;
    }
    if (slaves[i].min_voltage < min_voltage_new) {
      min_voltage_new = slaves[i].min_voltage;
    }
    if (slaves[i].max_temp > max_temp_new) {
      max_temp_new = slaves[i].max_temp;
    }

    if (slaves[i].error.kind != SLAVE_ERR_NONE) {
      any_slave_error = 1;
    }
  }
  min_voltage = min_voltage_new;
  max_temp = max_temp_new;

  if (any_slave_error) {
    ts_sm_set_error_source(TS_ERROR_SOURCE_SLAVES, 1);
  }
}

void slaves_handle_panic(const uint8_t *data) {
  uint8_t slave_id = ftcan_unmarshal_unsigned(&data, 1);
  uint8_t error_kind = ftcan_unmarshal_unsigned(&data, 1);
  switch (error_kind) {
  case SLAVE_PANIC_OT:
    slaves[slave_id].error.kind = SLAVE_ERR_OT;
    break;
  case SLAVE_PANIC_UT:
    slaves[slave_id].error.kind = SLAVE_ERR_UT;
    break;
  case SLAVE_PANIC_OV:
    slaves[slave_id].error.kind = SLAVE_ERR_OV;
    break;
  case SLAVE_PANIC_UV:
    slaves[slave_id].error.kind = SLAVE_ERR_UV;
    break;
  }
  slaves[slave_id].error.data = ftcan_unmarshal_unsigned(&data, 4);
  slaves[slave_id].last_message = HAL_GetTick();
}

void slaves_handle_status(const uint8_t *data) {
  uint8_t slave_id = data[0] & 0x7F;
  int error = data[0] & 0x80;
  if (error) {
    if (slaves[slave_id].error.kind == SLAVE_ERR_NONE) {
      slaves[slave_id].error.kind = SLAVE_ERR_UNKNOWN;
    }
  } else {
    slaves[slave_id].error.kind = SLAVE_ERR_NONE;
  }
  slaves[slave_id].soc = data[1];
  const uint8_t *ptr = &data[2];
  slaves[slave_id].min_voltage = ftcan_unmarshal_unsigned(&ptr, 2);
  slaves[slave_id].max_voltage = ftcan_unmarshal_unsigned(&ptr, 2);
  slaves[slave_id].max_temp = ftcan_unmarshal_unsigned(&ptr, 2);
  slaves[slave_id].last_message = HAL_GetTick();
}

void slaves_handle_log(const uint8_t *data) {
  // TODO
}