#pragma once

#include <utility>

#include "Core/Base/SM_RingBuffer.h"
#include "Core/Serial/Serial.h"

#include "Core/Statistics/Frequency_Limit.h"
#include "Core/Statistics/Statistics.h"
#include "Core/transmit_protocol/core/statistics.h"
#include "Database.h"

#include "Local_Server/global_include.h"
#include "global.h"
#include "PlayBack.h"

namespace Psc {
class SM_RingBuffer;
}
// 统一封装数据输出的模式
class Data_Source;
std::shared_ptr<Data_Source> create_from_json(const Psc::JSON *that_json);


class Input_Format {
public:
    Input_Format() {
        test_v.resize(static_cast<size_t>(SSR::Downlink_Format::Unknown));
    }

    Psc::JSON to_json() {
        std::lock_guard g(mtx);
        Psc::JSON ret = Psc::JSON::object();
        for (auto e : magic_enum::enum_values<SSR::Downlink_Format>()) {
            std::string_view value_view = magic_enum::enum_name(e);
            std::string value(value_view.begin(), value_view.end());
            if (value == Psc::to_string(SSR::Downlink_Format::Unknown)) continue;
            auto ev = static_cast<std::uint8_t>(e);
            bool it = test_v[ev];
            ret.append({value, it});
        }
        return ret;
    }

    void from_json(const Psc::JSON* json) {
        std::lock_guard g(mtx);
        for (auto e : magic_enum::enum_values<SSR::Downlink_Format>()) {
            std::string_view value_view = magic_enum::enum_name(e);
            std::string value(value_view.begin(), value_view.end());
            if (value == Psc::to_string(SSR::Downlink_Format::Unknown)) continue;
            auto use = json->get_bool(value);
            auto ev = static_cast<std::uint8_t>(e);
            test_v[ev] = use;
        }
    }


    bool test(SSR::Downlink_Format df) {
        std::lock_guard g(mtx);
        auto dfv = static_cast<std::uint8_t>(df);
        if (dfv >= static_cast<std::uint8_t>(SSR::Downlink_Format::Unknown)) return false;
        return test_v[dfv];
    }

    bool test(std::uint8_t dfv) {
        std::lock_guard g(mtx);
        if (dfv >= static_cast<std::uint8_t>(SSR::Downlink_Format::Unknown)) return false;
        return test_v[dfv];
    }
protected:
    std::mutex mtx;
    std::vector<bool> test_v;
};

class Data_Source : public DataBase, public std::enable_shared_from_this<Data_Source> {
public:
    ~Data_Source() override = default;
    virtual std::string          read() { return ""; }
    std::shared_ptr<Data_Source> that();
    virtual Psc::JSON get_custom_state_json() = 0;
    Psc::JSON get_state();


    std::string last_char; // 用于处理奇数字节的情况

    // std::shared_ptr<Input_Format> parse_format;
    Psc::Speed_Statistics read_speed;
    Psc::Value_Statistics value_statistics;
    Data_Source() {
        // parse_format = std::make_shared<Input_Format>();
        // 写入到配置文件是懒加载  其他保存时他跟着保存
        base_station.handle_when_updated = [this](SSR::HULC_Status_Message msg) {
            if (this->update_form_gps) {
                lat = msg.get_latitude();
                lon = msg.get_longitude();
                alt = msg.Alt;
            }
        };
    }
    std::shared_ptr<SSR::Mode_Msg> last_prase_msg = nullptr;




    virtual void handle_mode_s(std::shared_ptr<SSR::Mode_S_Msg> msg);
    virtual void pre_handle(const std::string &data);
    virtual std::shared_ptr<SSR::Msg> create_msg(const std::shared_ptr<SSR::Data_Source_Interface>& source, const std::string& packet);
    virtual void update_msg_day_time(std::shared_ptr<SSR::Msg> msg);
    virtual void  handle_mode_acs_source();


    void refresh_data_feed_key_list();
    void                   push_to_feed(const std::shared_ptr<SSR::Msg> &msg);
    std::atomic<bool>      enable{};
    std::string            type;
    std::atomic<bool>      base_station_show{};
    std::atomic<bool>      aircraft_show{};


    std::atomic<bool>      show_icao = true;
    std::atomic<bool>      show_call_sign = false;
    std::atomic<bool>      show_fly_status = false;
    std::atomic<bool>      keep_mode = true;



    double                 lat{};
    double                 lon{};
    double                 alt{};
    std::atomic<bool>      update_form_gps{};
    std::string            color = "#1677ff";
    int                    aircraft_pixel_size{};
    Mode_AC_Statistic_Data mode_ac_statistic;
    Mode_S_Statistic_Data  mode_s_statistic;
    Frequency_Limit statistic_fl;

    virtual void handle_in_loop() {};
    std::string  thread_key() const;
    void         test_and_attach_thread();
    void         test_and_stop_thread() const;
    Psc::JSON     statistic_json() {
        Psc::JSON ret = Psc::JSON::object();
        Ret_J(enable);
        Ret_J(type);
        ret.append({"飞机总数", get_aircraft_num()});
        ret.append({"解出位置的数量", have_pos_aircraft_num});
        ret.append({"mode_ac_statistic", mode_ac_statistic.to_json()});
        ret.append({"mode_s_statistic", mode_s_statistic.to_json()});
        ret.append({"all_connect_feed", get_all_connect_feed_status()});


        return ret;
    }
    virtual Psc::JSON to_json() {
        Psc::JSON ret = Psc::JSON::object();
        Ret_J(key);
        Ret_J(enable);
        Ret_J(base_station_show);
        Ret_J(aircraft_show);
        Ret_J(color);
        Ret_J(aircraft_pixel_size);
        Ret_J(type);
        Ret_J(lat);
        Ret_J(lon);
        Ret_J(alt);
        Ret_J(update_form_gps);
        Ret_J(show_icao);
        Ret_J(show_call_sign);
        Ret_J(show_fly_status);
        Ret_J(keep_mode);
        // ret.append({"parse_format", parse_format->to_json()});
        return ret;
    }
    virtual void from_json(const Psc::JSON *that_json) {
        Get_J(key);
        Get_J(enable);
        Get_J(base_station_show);
        Get_J(aircraft_show);
        Get_J(color);
        Get_J(aircraft_pixel_size);
        Get_J(type);
        Get_J(lat);
        Get_J(lon);
        Get_J(alt);
        Get_J(update_form_gps);
        Get_J(show_icao);
        Get_J(show_call_sign);
        Get_J(show_fly_status);
        Get_J(keep_mode);
        // parse_format->from_json(that_json->get("parse_format"));
    }
    bool open() {
        if (!_open_) {
            _open_ =  _open();
            return _open_;
        }
        return true;
    }
    void close() {
        if (_open_) {
            _open_ = false;
            _close();
        }
    }

    struct Cached_Source_Info {
        std::string key;
        Psc::Value_Statistics mode_s_cache_num;
        Psc::Value_Statistics mode_other_cache_num;
    };

    std::string       buffer;
    std::atomic<bool> need_refresh_data_feed_key_list = true;
    Psc::JSON get_all_connect_feed_status();
    Psc::JSON get_all_connect_feed();
protected:
    std::mutex cdf_mtx;
    std::vector<Cached_Source_Info> cached_data_feed_key_list{};
    bool                     _open_ = false;
    virtual bool             _open() = 0;
    virtual void             _close() = 0;
};


struct TCP_Client_Data_Source : Data_Source {
    void handle_in_loop() override {
        ucoro::sync_await(cli.tick_coro());
    }
    Psc::JSON get_custom_state_json() override {
        auto& state = cli.state;
        return VAR_JSON_1(state);
    }
    Psc::asio_socket::TCP_Client_Coro cli;
    std::string               ip;
    std::uint16_t             port{};

    ~TCP_Client_Data_Source() override = default;
    TCP_Client_Data_Source() {
        type = "TCP_Client_Data_Source";
    }
    bool _open() override {
        Psc::asio_socket::Sockaddr_In addr;
        addr.ip = ip;
        addr.port = port;

        cli.set_dest_address(addr);
        cli.create();
        ucoro::sync_await(cli.connect_coro());
        return true;
    }
    void     _close() override { cli.close(); }

    Psc::JSON to_json() override {
        Psc::JSON ret = Data_Source::to_json();
        Ret_J(ip);
        Ret_J(port);
        return ret;
    }
    void from_json(const Psc::JSON *that_json) override {
        Data_Source::from_json(that_json);
        Get_J(ip);
        Get_J(port);
    }

    std::string read() override {
        return ucoro::sync_await(cli.read_coro());
    }
};
struct Serial_Data_Source : Data_Source {
    std::string    port_name;
    Baud_Rate_Type baud_rate{};
    Psc::JSON get_custom_state_json() override {
        return Psc::JSON::object();
    }
    Serial_Data_Source() { this->type = "Serial_Data_Source"; }
    bool _open() override {
        serial = new Psc::serial::Serial;
        serial->set_serial_name(port_name);
        serial->set_baud_rate(baud_rate);
        serial->set_parity(Psc::serial::Parity::NoParity);
        serial->set_data_bits(Psc::serial::DataBits::Data8);
        serial->set_stop_bits(Psc::serial::StopBits::OneStop);
        serial->set_flow_control(Psc::serial::FlowControl::HardwareControl);
        serial->set_buffer_byte_size(10 * 1024);
        bool ok = serial->open();
        if (!ok) {
            std::cerr << "createSerial " + port_name + ":" + std::to_string(baud_rate) + " 打开串口失败！\n";
        } else {
            // std::cerr << "createSerial " + serial_name + ":" + std::to_string(baud_rate) + " 打开串口成功！\n";
        }
        return ok;
    }
    void        _close() override { serial->close(); }
    std::string read() override { return serial->read(); }
    Psc::JSON    to_json() override {
        Psc::JSON ret = Data_Source::to_json();
        Ret_J(port_name);
        Ret_J(baud_rate);
        return ret;
    }
    void from_json(const Psc::JSON *that_json) override {
        Data_Source::from_json(that_json);
        Get_J(port_name) Get_J(baud_rate);
    }
    Psc::serial::Serial *serial{};
    ~Serial_Data_Source() override {
        if (serial) {
            serial->close();
            delete serial;
        }
    }
};


enum class File_Data_Type {
    SIMPLE_BIN_Blank, // 没有1a转义的
    BIN_Blank_Text,
    AVR,
    BIN_Text,
    BIN_Blank_One_Line_With_Escape,
    BIN_Blank_One_Line_No_Escape,
    BIN,
    Unknown
    // 纯粹的二进制
};
enum Play_Mode { one, loop, analysis, time_batch };


struct File_Data_Source : public Data_Source {
    std::string    file_path;
    File_Data_Type data_type = File_Data_Type::BIN_Blank_Text;
    Play_Mode      play_mode = Play_Mode::one;
    bool           have_report_play_back_all_success = false;
    std::string state = "null";
    Psc::JSON get_custom_state_json() override {
        auto cur_virtual_time = player_clock.get_cur_time_point();
        auto playback_speed_rate = player_clock.playback_speed_rate;
        return VAR_JSON_5(cur_virtual_time, playback_speed_rate, state, index, part_infos.size());
    }
    File_Data_Source() { this->type = "File_Data_Source"; }
    ~File_Data_Source() override = default;




    struct Cache_Msg {
        explicit Cache_Msg(std::shared_ptr<SSR::Mode_S_Msg> msg) : msg(std::move(msg)) {}
        SSR::Play_Back_Time_Point time() const {
            return SSR::Play_Back_Time_Point{day_num, msg->mlat_timestamp.daysec};
        }
        std::uint64_t day_num = 0;
        std::shared_ptr<SSR::Mode_S_Msg> msg;
    };
    Player_Clock player_clock;
    std::shared_ptr<Cache_Msg> pre_cache = nullptr;
    std::deque<std::shared_ptr<Cache_Msg>> cache_list;



    std::string get_true_file_path() const { return Psc::get_abs_path(file_path); }
    void _close() override;
    bool _open() override;
    std::vector<std::string> readBinaryFileAsString(const std::string& filepath, size_t part_size);
    void from_json(const Psc::JSON *that_json) override {
        Data_Source::from_json(that_json);
        Get_J(file_path);
        Get_J(data_type);
        Get_J(play_mode);
    }

    Psc::JSON to_json() override {
        Psc::JSON ret = Data_Source::to_json();
        Ret_J(file_path);
        Ret_J(data_type);
        Ret_J(play_mode);
        return ret;
    }
    std::string read() override;
    void handle_mode_acs_source() override;

  protected:
    std::optional<std::string> get_raw_line(int &ret_index);
    long long                  index = 0;
    std::vector<std::string>   part_infos;
    std::mutex                 mtx;
};
struct Dll_Data_Source : Data_Source {
    Psc::JSON get_custom_state_json() override {
        auto ret = VAR_JSON_1(state);
        ret.append({"read_vaild_len", vs.to_string()});
        return ret;
    }
    Psc::Value_Statistics vs;
    std::string    library_path;
    std::string    function_name;
    File_Data_Type data_type = File_Data_Type::BIN_Blank_Text;
    Dll_Data_Source() { this->type = "Dll_Data_Source"; }
    ~Dll_Data_Source() override = default;
    std::size_t buffer_size{};
    std::vector<std::uint8_t> buffer;
    void from_json(const Psc::JSON *that_json) override {
        Data_Source::from_json(that_json);
        Get_J(library_path);
        Get_J(function_name);
        Get_J(data_type);
        Get_J(buffer_size);
        buffer.resize(buffer_size);
    }
    Psc::JSON to_json() override {
        Psc::JSON ret = Data_Source::to_json();
        Ret_J(library_path);
        Ret_J(function_name);
        Ret_J(data_type);
        Ret_J(buffer_size);
        return ret;
    }
    void *lib{};

    using Func_Type = size_t (*)(char *buf, std::size_t max_len);
    // using Func_Type = std::uint16_t (*)(char *buf, std::uint16_t max_len);
    Func_Type read_func_ptr{};


    using Call_Back = void (*)(char *buf, std::size_t len);
    using set_Call_back = void (*)(Call_Back);

    std::string state;
    void      _close() override { Psc::free_library(lib); }
    bool      _open() override {
        {
            auto r = Psc::try_load_library(Psc::get_abs_path(library_path));
            if (!r) {
                state = r.error().message();
                return false;
            }
            lib = r.value();
        }
        {
            auto r = Psc::try_load_function(lib, function_name);
            if (!r) {
                state = r.error().message();
                std::cout << LOG_POS <<  "  [" <<  function_name <<  "]  函数指针加载失败!" << std::endl;
                return false;
            }
            read_func_ptr = (Func_Type) r.value();
        }
        state = "加载成功";
        return true;
    }
    std::string read() override;
};


struct Shared_Memory_Data_Source : Data_Source {
    Psc::JSON get_custom_state_json() override {
        return Psc::JSON::object();
    }
    void from_json(const Psc::JSON *that_json) override {
        Data_Source::from_json(that_json);
        Get_J(shared_memory_name);
        Get_J(shared_memory_size);
        Get_J(data_type);
    }
    Psc::JSON to_json() override {
        Psc::JSON ret = Data_Source::to_json();
        Ret_J(shared_memory_name);
        Ret_J(shared_memory_size);
        Ret_J(data_type);
        return ret;
    }
    bool      _open() override;
    void      _close() override;
    std::string read() override;

protected:
    std::unique_ptr<Psc::SM_RingBuffer> sm;
    std::string    shared_memory_name;
    std::uint64_t   shared_memory_size{};
    File_Data_Type data_type = File_Data_Type::BIN_Blank_Text;
};


inline std::shared_ptr<Data_Source> create_data_source_from_type(const std::string &t) {
    std::shared_ptr<Data_Source> ret{};
    if (t == "Serial_Data_Source")
        ret = std::make_shared<Serial_Data_Source>();
    else if (t == "TCP_Client_Data_Source")
        ret = std::make_shared<TCP_Client_Data_Source>();
    else if (t == "File_Data_Source")
        ret = std::make_shared<File_Data_Source>();
    else if (t == "Dll_Data_Source")
        ret = std::make_shared<Dll_Data_Source>();
    else if (t == "Shared_Memory_Data_Source")
        ret = std::make_shared<Shared_Memory_Data_Source>();
    else {
        std::cout << "未知的 Data_Source type类型!" << std::endl;
        throw std::invalid_argument("unknown Data_Source type: " + t);
    }
    return ret;
}


struct Data_Source_Config {
    Ordered_Map<std::string, std::shared_ptr<Data_Source>> map;
    Data_Source_Config() = default;
    void init(const Psc::JSON *that_json) {
        auto list = that_json->get("list");
        for (auto &it: list->children) {
            auto ds = create_from_json(&it);
            map.push_back(ds);
        }
    }
    Psc::JSON list() {
        auto connect_json = Psc::JSON::array();
        for (auto &it: map.list()) {
            connect_json.children.emplace_back(it->to_json());
        }
        return connect_json;
    }
    Psc::JSON to_json() {
        Psc::JSON ret = Psc::JSON::object();
        ret.append({"list", list()});
        return ret;
    }
    void server(Global *g);
};