#include "ets_device_runtime.h"

#include "gateway_knx_internal.h"

#include "esp_log.h"
#include "knx/cemi_server.h"
#include "knx/group_object.h"
#include "knx/secure_application_layer.h"
#include "knx/property.h"
#include "tpuart_uart_interface.h"

#include <algorithm>
#include <cstdint>
#include <cstdio>
#include <string>
#include <utility>
#include <vector>

namespace gateway::openknx {
namespace {

thread_local EtsDeviceRuntime* active_function_property_runtime = nullptr;
EtsDeviceRuntime* active_group_object_runtime = nullptr;

class ActiveFunctionPropertyRuntimeScope {
 public:
  explicit ActiveFunctionPropertyRuntimeScope(EtsDeviceRuntime* runtime)
      : previous_(active_function_property_runtime) {
    active_function_property_runtime = runtime;
  }

  ~ActiveFunctionPropertyRuntimeScope() { active_function_property_runtime = previous_; }

 private:
  EtsDeviceRuntime* previous_;
};

constexpr uint16_t kInvalidIndividualAddress = 0xffff;
constexpr uint16_t kKnxUnconfiguredBroadcastAddress = 0xffff;  // KNX broadcast IA for unconfigured devices

bool IsUsableIndividualAddress(uint16_t address) {
  return address != 0 && address != kInvalidIndividualAddress;
}

std::string HexBytesString(const uint8_t* data, size_t length) {
  if (data == nullptr || length == 0) {
    return {};
  }

  std::string out;
  out.reserve(length * 3);
  char buffer[4] = {0};
  for (size_t index = 0; index < length; ++index) {
    std::snprintf(buffer, sizeof(buffer), "%02X", data[index]);
    out += buffer;
    if (index + 1 < length) {
      out.push_back(' ');
    }
  }
  return out;
}

std::string PrintableOrderNumber(const uint8_t* data, size_t length) {
  if (data == nullptr || length == 0) {
    return {};
  }

  std::string out;
  out.reserve(length);
  for (size_t index = 0; index < length; ++index) {
    if (data[index] == 0) {
      break;
    }
    out.push_back(static_cast<char>(data[index]));
  }
  return out;
}

void LogReg1DaliIdentity(const std::string& nvs_namespace, Bau07B0& device) {
  uint8_t program_version[5] = {0};
  if (auto* property = device.parameters().property(PID_PROG_VERSION); property != nullptr) {
    property->read(program_version);
  }

  const std::string hardware_type =
      HexBytesString(device.deviceObject().hardwareType(), LEN_HARDWARE_TYPE);
  const std::string program_version_hex =
      HexBytesString(program_version, sizeof(program_version));
  const std::string order_number =
      PrintableOrderNumber(device.deviceObject().orderNumber(),
                           sizeof(knx_internal::kReg1DaliOrderNumber));

  ESP_LOGI("gateway_knx",
           "OpenKNX identity namespace=%s manufacturer=0x%04x mask=0x%04x deviceVersion=0x%04x hardwareType=%s progVersion=%s order=%s",
           nvs_namespace.c_str(), device.deviceObject().manufacturerId(),
           device.deviceObject().maskVersion(), device.deviceObject().version(),
           hardware_type.c_str(), program_version_hex.c_str(), order_number.c_str());
}

void ApplyReg1DaliIdentity(Bau07B0& device, EspIdfPlatform& platform) {
  device.deviceObject().manufacturerId(knx_internal::kReg1DaliManufacturerId);
  device.deviceObject().bauNumber(platform.uniqueSerialNumber());
  device.deviceObject().hardwareType(knx_internal::kReg1DaliHardwareType);
  device.deviceObject().orderNumber(knx_internal::kReg1DaliOrderNumber);
  device.parameters().property(PID_PROG_VERSION)->write(
      knx_internal::kReg1DaliProgramVersion);
}

}  // namespace

EtsDeviceRuntime::EtsDeviceRuntime(std::string nvs_namespace,
                                   uint16_t fallback_individual_address,
                                   uint16_t tunnel_client_address,
                                   std::unique_ptr<TpuartUartInterface> tp_uart_interface)
    : nvs_namespace_(std::move(nvs_namespace)),
      tp_uart_interface_(std::move(tp_uart_interface)),
      platform_(tp_uart_interface_.get(), nvs_namespace_.c_str()),
      device_(platform_) {
  platform_.outboundCemiFrameCallback(&EtsDeviceRuntime::HandleOutboundCemiFrame, this);
  ApplyReg1DaliIdentity(device_, platform_);
  if (IsUsableIndividualAddress(fallback_individual_address)) {
    device_.deviceObject().individualAddress(fallback_individual_address);
  }
  ESP_LOGI("gateway_knx", "OpenKNX loading memory namespace=%s", nvs_namespace_.c_str());
  device_.readMemory();
  installGroupObjectCallbacks();
  if (!IsUsableIndividualAddress(device_.deviceObject().individualAddress()) &&
      IsUsableIndividualAddress(fallback_individual_address)) {
    device_.deviceObject().individualAddress(fallback_individual_address);
  }
  LogReg1DaliIdentity(nvs_namespace_, device_);
  if (auto* server = device_.getCemiServer()) {
    server->clientAddress(IsUsableIndividualAddress(tunnel_client_address)
                              ? tunnel_client_address
                              : DefaultTunnelClientAddress(
                                    device_.deviceObject().individualAddress()));
    server->deviceAddressPropertiesTargetClient(false);
    server->tunnelFrameCallback(&EtsDeviceRuntime::EmitTunnelFrame, this);
  }
  device_.functionPropertyCallback(&EtsDeviceRuntime::HandleFunctionPropertyCommand);
  device_.functionPropertyStateCallback(&EtsDeviceRuntime::HandleFunctionPropertyState);
#ifdef USE_DATASECURE
  device_.secureGroupWriteCallback(&EtsDeviceRuntime::HandleSecureGroupWrite, this);
#endif
}

EtsDeviceRuntime::~EtsDeviceRuntime() {
  if (tp_uart_interface_ != nullptr) {
    device_.enabled(false);
  }
  platform_.outboundCemiFrameCallback(nullptr, nullptr);
#ifdef USE_DATASECURE
  device_.secureGroupWriteCallback(nullptr, nullptr);
#endif
#ifdef SMALL_GROUPOBJECT
  if (active_group_object_runtime == this) {
    GroupObject::classCallback(GroupObjectUpdatedHandler{});
  }
#else
  auto& table = device_.groupObjectTable();
  for (uint16_t asap = 1; asap <= table.entryCount(); ++asap) {
    table.get(asap).callback(GroupObjectUpdatedHandler{});
  }
#endif
  if (active_group_object_runtime == this) {
    active_group_object_runtime = nullptr;
  }
  device_.functionPropertyCallback(nullptr);
  device_.functionPropertyStateCallback(nullptr);
  if (auto* server = device_.getCemiServer()) {
    server->tunnelFrameCallback(nullptr, nullptr);
  }
}

uint16_t EtsDeviceRuntime::individualAddress() const {
  return const_cast<Bau07B0&>(device_).deviceObject().individualAddress();
}

uint16_t EtsDeviceRuntime::tunnelClientAddress() const {
  if (auto* server = const_cast<Bau07B0&>(device_).getCemiServer()) {
    return server->clientAddress();
  }
  return DefaultTunnelClientAddress(individualAddress());
}

bool EtsDeviceRuntime::configured() const { return const_cast<Bau07B0&>(device_).configured(); }

bool EtsDeviceRuntime::programmingMode() const {
  return const_cast<Bau07B0&>(device_).deviceObject().progMode();
}

void EtsDeviceRuntime::setProgrammingMode(bool enabled) {
  device_.deviceObject().progMode(enabled);
}

void EtsDeviceRuntime::toggleProgrammingMode() { setProgrammingMode(!programmingMode()); }

DeviceObject& EtsDeviceRuntime::deviceObject() { return device_.deviceObject(); }

Platform& EtsDeviceRuntime::platform() { return platform_; }

EtsMemorySnapshot EtsDeviceRuntime::snapshot() const {
  EtsMemorySnapshot out;
  auto& device = const_cast<Bau07B0&>(device_);
  out.configured = device.configured();
  out.individual_address = device.deviceObject().individualAddress();
  device.forEachEtsAssociation(
      [](uint16_t group_address, uint16_t group_object_number, void* context) {
        auto* associations = static_cast<std::vector<EtsAssociation>*>(context);
        if (associations != nullptr) {
          associations->push_back(EtsAssociation{group_address, group_object_number});
        }
      },
      &out.associations);
  std::sort(out.associations.begin(), out.associations.end(),
            [](const EtsAssociation& lhs, const EtsAssociation& rhs) {
              if (lhs.group_address != rhs.group_address) {
                return lhs.group_address < rhs.group_address;
              }
              return lhs.group_object_number < rhs.group_object_number;
            });
  out.associations.erase(
      std::unique(out.associations.begin(), out.associations.end(),
                  [](const EtsAssociation& lhs, const EtsAssociation& rhs) {
                    return lhs.group_address == rhs.group_address &&
                           lhs.group_object_number == rhs.group_object_number;
                  }),
      out.associations.end());
  return out;
}

void EtsDeviceRuntime::setFunctionPropertyHandlers(FunctionPropertyHandler command_handler,
                                                   FunctionPropertyHandler state_handler) {
  command_handler_ = std::move(command_handler);
  state_handler_ = std::move(state_handler);
}

void EtsDeviceRuntime::setGroupWriteHandler(GroupWriteHandler handler) {
  group_write_handler_ = std::move(handler);
}

void EtsDeviceRuntime::setGroupObjectWriteHandler(GroupObjectWriteHandler handler) {
  group_object_write_handler_ = std::move(handler);
  installGroupObjectCallbacks();
}

void EtsDeviceRuntime::setBusFrameSender(CemiFrameSender sender) {
  bus_frame_sender_ = std::move(sender);
}

void EtsDeviceRuntime::setNetworkInterface(esp_netif_t* netif) {
  platform_.networkInterface(netif);
}

bool EtsDeviceRuntime::hasTpUart() const { return tp_uart_interface_ != nullptr; }

bool EtsDeviceRuntime::enableTpUart(bool enabled) {
  if (tp_uart_interface_ == nullptr) {
    return false;
  }
  device_.enabled(enabled);
  loop();
  return !enabled || device_.enabled();
}

bool EtsDeviceRuntime::tpUartOnline() const {
  return tp_uart_interface_ != nullptr && const_cast<Bau07B0&>(device_).enabled();
}

bool EtsDeviceRuntime::transmitTpFrame(const uint8_t* data, size_t len) {
  auto* data_link_layer = device_.getDataLinkLayer();
  if (tp_uart_interface_ == nullptr || data_link_layer == nullptr || data == nullptr || len < 2 ||
      !data_link_layer->enabled()) {
    return false;
  }
  std::vector<uint8_t> frame_data(data, data + len);
  CemiFrame frame(frame_data.data(), static_cast<uint16_t>(frame_data.size()));
  if (!frame.valid()) {
    return false;
  }
  return data_link_layer->transmitFrame(frame);
}

bool EtsDeviceRuntime::handleTunnelFrame(const uint8_t* data, size_t len,
                                         CemiFrameSender sender) {
  auto* server = device_.getCemiServer();
  if (server == nullptr || data == nullptr || len < 2) {
    return false;
  }
  std::vector<uint8_t> frame_data(data, data + len);
  CemiFrame frame(frame_data.data(), static_cast<uint16_t>(frame_data.size()));
  const bool consumed = shouldConsumeTunnelFrame(frame);
  if (!consumed) {
    return false;
  }
  const bool suppress_group_object_route =
      frame.messageCode() == L_data_req && frame.addressType() == GroupAddress &&
      frame.apdu().type() == GroupValueWrite;
  const bool previous_suppression = suppress_group_object_write_callback_;
  if (suppress_group_object_route) {
    suppress_group_object_write_callback_ = true;
  }
  sender_ = std::move(sender);
  ActiveFunctionPropertyRuntimeScope callback_scope(this);
  server->frameReceived(frame);
  loop();
  sender_ = nullptr;
  suppress_group_object_write_callback_ = previous_suppression;
  installGroupObjectCallbacks();
  return consumed;
}

bool EtsDeviceRuntime::handleBusFrame(const uint8_t* data, size_t len) {
  auto* data_link_layer = device_.getDataLinkLayer();
  if (data_link_layer == nullptr || data == nullptr || len < 2) {
    return false;
  }
  std::vector<uint8_t> frame_data(data, data + len);
  CemiFrame frame(frame_data.data(), static_cast<uint16_t>(frame_data.size()));
  const bool consumed = shouldConsumeBusFrame(frame);
  if (!consumed) {
    return false;
  }
  data_link_layer->externalFrameReceived(frame);
  loop();
  installGroupObjectCallbacks();
  return consumed;
}

bool EtsDeviceRuntime::emitGroupValue(uint16_t group_object_number, const uint8_t* data,
                                      size_t len, CemiFrameSender sender) {
  if (group_object_number == 0 || data == nullptr || !sender || !device_.configured()) {
    return false;
  }
  auto& table = device_.groupObjectTable();
  if (group_object_number > table.entryCount()) {
    return false;
  }
  auto& group_object = table.get(group_object_number);
  if (len != group_object.valueSize() || group_object.valueRef() == nullptr) {
    return false;
  }
  if (group_object.sizeInTelegram() == 0) {
    group_object.valueRef()[0] = data[0] & 0x01;
  } else {
    std::copy_n(data, len, group_object.valueRef());
  }
  const bool previous_suppression = suppress_group_object_write_callback_;
  suppress_group_object_write_callback_ = true;
  sender_ = std::move(sender);
  group_object.objectWritten();
  loop();
  sender_ = nullptr;
  suppress_group_object_write_callback_ = previous_suppression;
  return true;
}

void EtsDeviceRuntime::loop() { device_.loop(); }

bool EtsDeviceRuntime::HandleOutboundCemiFrame(CemiFrame& frame, void* context) {
  auto* self = static_cast<EtsDeviceRuntime*>(context);
  if (self == nullptr || !self->sender_) {
    return false;
  }
  self->sender_(frame.data(), frame.dataLength());
  return true;
}

void EtsDeviceRuntime::EmitTunnelFrame(CemiFrame& frame, void* context) {
  auto* self = static_cast<EtsDeviceRuntime*>(context);
  if (self == nullptr) {
    return;
  }
  if (self->sender_) {
    self->sender_(frame.data(), frame.dataLength());
    return;
  }
  if (self->bus_frame_sender_) {
    self->bus_frame_sender_(frame.data(), frame.dataLength());
  }
}

void EtsDeviceRuntime::HandleSecureGroupWrite(uint16_t group_address, const uint8_t* data,
                                              uint8_t data_length, void* context) {
  auto* self = static_cast<EtsDeviceRuntime*>(context);
  if (self == nullptr) {
    return;
  }
  if (self->group_object_write_handler_) {
    return;
  }
  if (self->group_write_handler_) {
    self->group_write_handler_(group_address, data, data_length);
  }
}

void EtsDeviceRuntime::HandleGroupObjectWrite(GroupObject& ko) {
  auto* self = active_group_object_runtime;
  if (self == nullptr || self->suppress_group_object_write_callback_ ||
      !self->group_object_write_handler_) {
    return;
  }
  const size_t value_size = ko.valueSize();
  const uint8_t* value = ko.valueRef();
  if (value == nullptr || value_size == 0) {
    ESP_LOGW("gateway_knx", "OpenKNX group-object callback ignored namespace=%s ko=%u len=%u",
             self->nvs_namespace_.c_str(), static_cast<unsigned>(ko.asap()),
             static_cast<unsigned>(value_size));
    return;
  }
  const std::string value_hex = HexBytesString(value, value_size);
  ESP_LOGI("gateway_knx", "OpenKNX group-object callback namespace=%s ko=%u len=%u value=%s",
           self->nvs_namespace_.c_str(), static_cast<unsigned>(ko.asap()),
           static_cast<unsigned>(value_size), value_hex.c_str());
  self->group_object_write_handler_(ko.asap(), value, value_size);
}

bool EtsDeviceRuntime::HandleFunctionPropertyCommand(uint8_t object_index, uint8_t property_id,
                                                     uint8_t length, uint8_t* data,
                                                     uint8_t* result_data,
                                                     uint8_t& result_length) {
  if (active_function_property_runtime == nullptr) {
    return false;
  }
  return DispatchFunctionProperty(&active_function_property_runtime->command_handler_, object_index,
                                  property_id, length, data, result_data, result_length);
}

bool EtsDeviceRuntime::HandleFunctionPropertyState(uint8_t object_index, uint8_t property_id,
                                                   uint8_t length, uint8_t* data,
                                                   uint8_t* result_data,
                                                   uint8_t& result_length) {
  if (active_function_property_runtime == nullptr) {
    return false;
  }
  return DispatchFunctionProperty(&active_function_property_runtime->state_handler_, object_index,
                                  property_id, length, data, result_data, result_length);
}

bool EtsDeviceRuntime::DispatchFunctionProperty(FunctionPropertyHandler* handler,
                                                uint8_t object_index, uint8_t property_id,
                                                uint8_t length, uint8_t* data,
                                                uint8_t* result_data, uint8_t& result_length) {
  if (handler == nullptr || !*handler || result_data == nullptr) {
    return false;
  }
  std::vector<uint8_t> response;
  if (!(*handler)(object_index, property_id, data, length, &response)) {
    return false;
  }
  result_length = static_cast<uint8_t>(std::min<size_t>(response.size(), result_length));
  if (result_length > 0) {
    std::copy_n(response.begin(), result_length, result_data);
  }
  return true;
}

void EtsDeviceRuntime::installGroupObjectCallbacks() {
  active_group_object_runtime = this;
  auto& table = device_.groupObjectTable();
  const uint16_t count = table.entryCount();
#ifdef SMALL_GROUPOBJECT
  GroupObject::classCallback(&EtsDeviceRuntime::HandleGroupObjectWrite);
#else
  for (uint16_t asap = 1; asap <= count; ++asap) {
    table.get(asap).callback(&EtsDeviceRuntime::HandleGroupObjectWrite);
  }
#endif
  if (count != group_object_callback_count_) {
    ESP_LOGI("gateway_knx", "OpenKNX group-object callbacks namespace=%s count=%u",
             nvs_namespace_.c_str(), static_cast<unsigned>(count));
    group_object_callback_count_ = count;
  }
}

uint16_t EtsDeviceRuntime::DefaultTunnelClientAddress(uint16_t individual_address) {
  if (!IsUsableIndividualAddress(individual_address)) {
    return 0x1101;
  }
  const uint16_t line_base = individual_address & 0xff00;
  uint16_t device = static_cast<uint16_t>((individual_address & 0x00ff) + 1);
  if (device == 0 || device > 0xff) {
    device = 1;
  }
  return static_cast<uint16_t>(line_base | device);
}

bool EtsDeviceRuntime::shouldConsumeTunnelFrame(CemiFrame& frame) const {
  switch (frame.messageCode()) {
    case M_PropRead_req:
    case M_PropWrite_req:
    case M_Reset_req:
    case M_FuncPropCommand_req:
    case M_FuncPropStateRead_req:
      return true;
    case L_data_req: {
      if (tpUartOnline()) {
        return true;
      }
      // In commissioning / programming mode ETS may address the device via its
      // individual address, the cEMI-client tunnel address (device+1), or the
      // unconfigured broadcast address 0xFFFF.  Consume only those; let all
      // other individual-addressed frames (bus-scan, DeviceDescriptorRead, …)
      // pass through to the physical TP-UART so real KNX devices on the bus
      // can reply.
      const uint16_t dest = frame.destinationAddress();
      const uint16_t own_address = individualAddress();
      const uint16_t client_address = tunnelClientAddress();
      const bool commissioning = !const_cast<Bau07B0&>(device_).configured() || programmingMode();

      if (frame.addressType() == IndividualAddress) {
        if (dest == own_address || dest == client_address ||
            (commissioning && dest == kKnxUnconfiguredBroadcastAddress)) {
          return true;
        }
      }
      return false;
    }
    default:
      return false;
  }
}

bool EtsDeviceRuntime::shouldConsumeBusFrame(CemiFrame& frame) const {
#ifdef USE_DATASECURE
  return frame.messageCode() == L_data_ind && frame.addressType() == GroupAddress &&
         frame.apdu().type() == SecureService;
#else
  return false;
#endif
}

}  // namespace gateway::openknx