#pragma once
#include "lidarlib/lidar.hpp"
#include <cstdint>
#include <string>

namespace lidarlib {

// ESPE LGA60-320: 320° FOV, device sweeps 20°..340° with 0° at the rear
// (angle_offset_deg = -180 so output 0° = ahead). Range per datasheet page;
// the wire caps distance at 50000 mm.
inline constexpr ModelConfig MODEL_ESPE_LGA60 { "ESPE-LGA60", -160.f, 160.f, 0.05f, 50.f, -180.f };

// ESPE LGA60 over TCP (default port 8080) or UDP, ported from the vendor's
// ROS driver; NOT verified on real hardware. open() sends the "RAuto" start
// command; device parameters (spin rate, resolution, filters) are whatever
// the vendor Windows config tool programmed — this driver does not set them.
class EspeDriver : public Lidar {
public:
    using ScanCallback = lidarlib::ScanCallback;

    // ip: device address; use_udp selects the transport the device is
    // configured for (vendor default is TCP); inverted: unit mounted
    // upside-down → mirror the scan.
    explicit EspeDriver(const ModelConfig& cfg,
                        const std::string& ip,
                        uint16_t            port     = 8080,
                        bool                use_udp  = false,
                        bool                inverted = false);
    ~EspeDriver();

    EspeDriver(const EspeDriver&)            = delete;
    EspeDriver& operator=(const EspeDriver&) = delete;

    // Connect + send the start-capture command.
    ErrorCode open() override;
    void close() override;
    bool recv_scan(ScanResult& out, int timeout_ms = 1000) override;
    void set_scan_callback(ScanCallback cb) override { cb_ = std::move(cb); }
    bool spin_once() override;
    bool is_open() const override { return sock_fd_ >= 0; }

    // No model string on the wire — returns the configured name.
    const char* detected_model() const override { return detected_model_name_.c_str(); }

    Diagnostics get_diagnostics() const override { return latest_diag_; }

private:
    bool fill_buffer(int timeout_ms);   // one recv() into recv_buf_
    bool parse_buffer();                 // consume frames; true when a scan completed
    void handle_range_frame(const uint8_t* frame, uint16_t data_size);
    void finish_scan();

    ModelConfig  cfg_;
    std::string  detected_model_name_;  // owned copy of cfg_.name (stable lifetime)
    std::string  ip_;
    uint16_t     port_;
    bool         use_udp_  = false;
    bool         inverted_ = false;
    int          sock_fd_ = -1;
    ScanCallback cb_;

    // Stream bytes carried across frame boundaries; per-instance.
    std::string recv_buf_;

    // Per-revolution accumulation
    std::vector<float> pending_ranges_;
    std::vector<float> pending_intensities_;
    float    rev_start_deg_ = 0.f;  // device angle of the revolution's first point
    float    angle_inc_deg_ = 0.f;
    uint32_t points_total_  = 0;    // measure_size from the header; 0 = no rev open
    uint16_t pending_time_  = 0;    // header "time" field, unit unverified

    // Latched from the newest "WSimu" area frame, if the device sends any.
    std::optional<uint16_t> espe_error_status_;

    // Snapshot for get_diagnostics(); refreshed by finish_scan().
    Diagnostics latest_diag_;

    ScanResult ready_result_;
    bool       scan_ready_ = false;
};

} // namespace lidarlib