#pragma once

#include "esp_idf_platform.h"
#include "ets_memory_loader.h"

#include "knx/bau07B0.h"
#include "knx/cemi_frame.h"

#include <cstddef>
#include <cstdint>
#include <functional>
#include <string>
#include <vector>

namespace gateway::openknx {

class EtsDeviceRuntime {
 public:
  using CemiFrameSender = std::function<void(const uint8_t* data, size_t len)>;
  using GroupWriteHandler = std::function<void(uint16_t group_address, const uint8_t* data,
                                               size_t len)>;
  using FunctionPropertyHandler = std::function<bool(uint8_t object_index, uint8_t property_id,
                                                     const uint8_t* data, size_t len,
                                                     std::vector<uint8_t>* response)>;

  EtsDeviceRuntime(std::string nvs_namespace,
                   uint16_t fallback_individual_address,
                   uint16_t tunnel_client_address = 0);
  ~EtsDeviceRuntime();

  uint16_t individualAddress() const;
  uint16_t tunnelClientAddress() const;
  bool configured() const;
  bool programmingMode() const;
  void setProgrammingMode(bool enabled);
  void toggleProgrammingMode();
  EtsMemorySnapshot snapshot() const;

  void setFunctionPropertyHandlers(FunctionPropertyHandler command_handler,
                                   FunctionPropertyHandler state_handler);
  void setGroupWriteHandler(GroupWriteHandler handler);
  void setNetworkInterface(esp_netif_t* netif);

  bool handleTunnelFrame(const uint8_t* data, size_t len, CemiFrameSender sender);
  bool handleBusFrame(const uint8_t* data, size_t len);
  bool emitGroupValue(uint16_t group_object_number, const uint8_t* data, size_t len,
                      CemiFrameSender sender);
  void loop();

 private:
  static bool HandleOutboundCemiFrame(CemiFrame& frame, void* context);
  static void EmitTunnelFrame(CemiFrame& frame, void* context);
  static void HandleSecureGroupWrite(uint16_t group_address, const uint8_t* data,
                                     uint8_t data_length, void* context);
  static bool HandleFunctionPropertyCommand(uint8_t object_index, uint8_t property_id,
                                            uint8_t length, uint8_t* data,
                                            uint8_t* result_data, uint8_t& result_length);
  static bool HandleFunctionPropertyState(uint8_t object_index, uint8_t property_id,
                                          uint8_t length, uint8_t* data,
                                          uint8_t* result_data, uint8_t& result_length);
  static uint16_t DefaultTunnelClientAddress(uint16_t individual_address);
  static bool 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);
  bool shouldConsumeTunnelFrame(CemiFrame& frame) const;
  bool shouldConsumeBusFrame(CemiFrame& frame) const;

  std::string nvs_namespace_;
  EspIdfPlatform platform_;
  Bau07B0 device_;
  CemiFrameSender sender_;
  GroupWriteHandler group_write_handler_;
  FunctionPropertyHandler command_handler_;
  FunctionPropertyHandler state_handler_;
};

}  // namespace gateway::openknx