#include "main.h"
#include <chrono>
#include <csignal>
#include <cstring>
#include <fstream>
#include <functional>
#include <iostream>
#include <random>
#include <sstream>
#include <stack>
#include <string>
#include <thread>
#include <vector>
#include <iostream>
#include <optional>
#include "Core/Base/JSON.h"
#include "Core/Base/ThreadManager.h"
#include "Core/Base/global_include.h"
#include "Core/Shared_Memory/Shared_Memory.h"
#include "Core/system/export.h"
#include "Core/spdlog/export.h"
#include "Core/Base/SM_RingBuffer.h"
#include "Dll_Global.h"
#include <string_view>
#ifndef ECAP_ADSB_PLAYBACK_SPEED_RATE
#define ECAP_ADSB_PLAYBACK_SPEED_RATE 20.0
#endif
#ifndef ECAP_ADSB_PLAYBACK_LOOP
#define ECAP_ADSB_PLAYBACK_LOOP 1
#endif
#ifndef ECAP_ADSB_PLAYBACK_USE_VIRTUAL_TIME
#define ECAP_ADSB_PLAYBACK_USE_VIRTUAL_TIME 1
#endif
#ifndef ECAP_ADSB_PLAYBACK_MAX_BATCH_LINES
#define ECAP_ADSB_PLAYBACK_MAX_BATCH_LINES 512
#endif
#ifndef ECAP_ADSB_PLAYBACK_FALLBACK_LINE_INTERVAL_SEC
#define ECAP_ADSB_PLAYBACK_FALLBACK_LINE_INTERVAL_SEC 0.02
#endif
std::vector<std::string> ddd = {
    "1A 33 1A 1A F1 DA 08 2A 73 60 8D 78 12 0A EA 28 88 64 25 3C 08 33 22 41",
    "1A 33 1A 1A F1 D9 13 EA E7 11 8D 78 1D 40 58 BF 41 E2 45 49 09 7B C8 24",
    "1A 33 1A 1A F1 DA 08 2A 73 60 8D 78 12 0A EA 28 88 64 25 3C 08 33 22 41",
    "1A 33 1A 1A F1 DA D4 35 F9 69 A0 00 15 BC C2 9E 14 F0 A8 00 00 DE E7 37",
    "1A 33 1A 1A F1 DB 45 5D 1C 68 A0 00 15 BC FF DD 11 2B 60 04 DB 2F 06 E2",
    "1A 33 1A 1A F1 DD 0F 74 3E 20 A0 00 15 BC EE 0A 13 30 20 37 FF A9 CE DC",
    "1A 33 1A 1A F1 DD 50 97 59 30 8D 78 00 6C E1 1F 2E 00 00 00 00 09 43 55",
    "1A 33 1A 1A F1 DD 73 6B 25 2B 8D 78 16 2D F8 33 00 06 00 49 B8 CF B0 D7",
    "1A 33 1A 1A F1 DD F1 C2 C2 1D A0 00 15 BC 10 03 0A 80 ED 00 00 98 54 C8",
    "1A 33 1A 1A F1 DE 62 E9 B6 2A A0 00 15 BC 10 03 0A 80 ED 00 00 98 54 C8",
    "1A 33 1A 1A F1 DE B4 E1 1E 23 8D 79 A0 53 EA 3E C8 66 57 3C 08 71 74 65",
    "1A 33 1A 1A F1 DF 17 8E 3F 5D 8D 78 00 6C 58 63 44 5B 32 CB 60 C5 DD 2E",
    "1A 33 1A 1A F1 DF 3E 49 FD 76 A0 00 0E 3E A8 7A 23 26 E1 0C 22 4E D9 88",
    "1A 33 1A 1A F1 DF AF 71 5F 6C A0 00 0E 3E A8 7A 23 26 E1 0C 22 4E D9 88",
    "1A 33 1A 1A F1 E2 0A DD 76 2A A0 00 11 B1 B5 E8 00 30 AA 00 00 D5 D0 A3",
};
std::string get_absb() {
    static size_t index = 0; // 静态变量用于保存当前读取位置
    index++;
    if (index == ddd.size()) {
        index = 0;
    }
    return ddd[index];
}
class TextLineReader {
public:
    struct Playback_Line {
        std::string text;
        double virtual_second{};
    };
    explicit TextLineReader(std::string_view file_path) {
        load(file_path);
    }
    std::size_t read(char* buf, std::size_t len) {
        if (lines_.empty() || len == 0) {
            return 0;
        }
        std::string ret;
        std::size_t count = 0;
        while (count < ECAP_ADSB_PLAYBACK_MAX_BATCH_LINES) {
            if (index_ >= lines_.size()) {
                if (ECAP_ADSB_PLAYBACK_LOOP) {
                    reset();
                }
                else {
                    break;
                }
            }
            if (!line_ready(lines_[index_])) {
                break;
            }
            const auto& line = lines_[index_].text;
            auto next_size = ret.size() + line.size() + 1;
            if (!ret.empty() && next_size > len) {
                break;
            }
            ret += line;
            ret += '\n';
            ++index_;
            ++count;
            if (!ECAP_ADSB_PLAYBACK_USE_VIRTUAL_TIME) {
                break;
            }
        }
        auto copy_size = ret.size();
        if (copy_size > len) {
            copy_size = len;
        }
        std::memcpy(buf, ret.data(), copy_size);
        return copy_size;
    }
    void reset() {
        index_ = 0;
        true_start_time_ = clock::now();
        start_virtual_second_ = lines_.empty() ? 0 : lines_.front().virtual_second;
    }
    std::size_t size() const {
        return lines_.size();
    }
    bool empty() const {
        return lines_.empty();
    }
private:
    using clock = std::chrono::steady_clock;
    void load(std::string_view file_path) {
        std::ifstream file{std::string(file_path)};
        // std::cout << "抛出异常" << std::endl;
        // throw std::runtime_error("222");
        if (!file.is_open()) {
            auto err = "Failed to open file: " + std::string(file_path);
            std::cout << err << std::endl;
            std::exit(895);
            throw std::runtime_error(err);
        }
        std::string line;
        std::optional<double> last_day_second;
        std::uint64_t day_offset = 0;
        std::size_t fallback_index = 0;
        while (std::getline(file, line)) {
            auto day_second = parse_day_second(line);
            if (!day_second.has_value()) {
                day_second = fallback_index * ECAP_ADSB_PLAYBACK_FALLBACK_LINE_INTERVAL_SEC;
            }
            if (last_day_second.has_value() && day_second.value() + 3600.0 < last_day_second.value()) {
                ++day_offset;
            }
            lines_.push_back({line, day_offset * 86400.0 + day_second.value()});
            last_day_second = day_second;
            ++fallback_index;
        }
        reset();
    }
    bool line_ready(const Playback_Line& line) const {
        if (!ECAP_ADSB_PLAYBACK_USE_VIRTUAL_TIME) {
            return true;
        }
        return line.virtual_second <= current_virtual_second();
    }
    double current_virtual_second() const {
        auto elapsed = std::chrono::duration<double>(clock::now() - true_start_time_).count();
        return start_virtual_second_ + elapsed * ECAP_ADSB_PLAYBACK_SPEED_RATE;
    }
    static std::optional<double> parse_day_second(std::string_view line) {
        auto bytes = parse_hex_bytes(line);
        if (!bytes.has_value()) {
            return std::nullopt;
        }
        auto packet = unescape_packet(bytes.value());
        if (packet.size() < 8 || packet[0] != 0x1a) {
            return std::nullopt;
        }
        std::uint64_t raw = 0;
        for (std::size_t i = 2; i < 8; ++i) {
            raw = (raw << 8) | packet[i];
        }
        auto daysec = static_cast<std::uint32_t>((raw >> 30) & 0x3ffff);
        auto nanosec = static_cast<std::uint32_t>(raw & 0x3fffffff);
        return daysec + nanosec / 1000000000.0;
    }
    static std::optional<std::vector<std::uint8_t>> parse_hex_bytes(std::string_view line) {
        std::vector<std::uint8_t> ret;
        int high = -1;
        for (char ch : line) {
            int value = hex_value(ch);
            if (value < 0) {
                if (ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n') {
                    continue;
                }
                return std::nullopt;
            }
            if (high < 0) {
                high = value;
            }
            else {
                ret.push_back(static_cast<std::uint8_t>((high << 4) | value));
                high = -1;
            }
        }
        if (high >= 0) {
            return std::nullopt;
        }
        return ret;
    }
    static int hex_value(char ch) {
        if (ch >= '0' && ch <= '9') {
            return ch - '0';
        }
        if (ch >= 'a' && ch <= 'f') {
            return ch - 'a' + 10;
        }
        if (ch >= 'A' && ch <= 'F') {
            return ch - 'A' + 10;
        }
        return -1;
    }
    static std::vector<std::uint8_t> unescape_packet(const std::vector<std::uint8_t>& bytes) {
        std::vector<std::uint8_t> ret;
        ret.reserve(bytes.size());
        for (std::size_t i = 0; i < bytes.size(); ++i) {
            ret.push_back(bytes[i]);
            if (bytes[i] == 0x1a && i + 1 < bytes.size() && bytes[i + 1] == 0x1a) {
                ++i;
            }
        }
        return ret;
    }
private:
    std::vector<Playback_Line> lines_;
    std::size_t index_ = 0;
    clock::time_point true_start_time_{clock::now()};
    double start_virtual_second_ = 0;
};
std::size_t adsb_read(char* buf, std::size_t len) {
    static TextLineReader reader(get_exe_dir() + "/ADS-B_195_0205.txt");
    auto l = reader.read(buf, len);
    /*static Frequency_Limit fl;
    if (fl.test()) {
        std::cout << "adsb_read" << VAR_STR_2(l, len) << std::endl;
    }*/
    return l;
}
int adsb_set_iq_cbk(iq_cbk_t recv_cbk, void* pusr) {
    auto dg = Dll_Global::instance();
    dg->recv_cbk = recv_cbk;
    dg->puser = pusr;
    dg->init_when_dll();
    return 0;
}
int adsb_set_less_30Mhz_ddc_param(uint64_t cf_hz, uint64_t sf_hz, uint64_t bw_hz, int8_t sw) {
    auto dg = Dll_Global::instance();
    dg->center_freq = cf_hz;
    dg->sample_rate = sf_hz; // 设置采样率
    dg->band_width = bw_hz;
    return 0;
}
int adsb_set_less_30Mhz_fft_param(uint64_t fftWin, uint64_t fftLen, int fftPeriod_ms, int8_t sw) {
    auto dg = Dll_Global::instance();
    dg->fft_point_number = fftLen;
    dg->fft_period_ms = fftPeriod_ms;
    dg->fft_win_type = (UHD_FFTWin)fftWin;
    return 0;
}
int main() {
    init_signal_config();
    auto dg = Dll_Global::instance();
    dg->init_when_exe();
    bool debug = false;
    auto mb = get_system_memory() / (1024 * 1024);
    auto gb = mb / (1024);
    std::cout << "当前系统的物理内存大小" << mb << " MB" << std::endl;
    std::cout << "当前系统的物理内存大小" << gb << " GB" << std::endl;
    dg->dtm.test_and_start_thread("dsp共享内存数据推送", [dg](std::atomic<bool>& running) {
        bool debug = true;
        while (running) {
            auto list = dg->iq_memory_buffer.get_all();
            // 释放内存池
            Pool_Guard pg(&dg->iq_memory_buffer.pool, list);
            if (debug && list.size() > 1000) {
                static Frequency_Limit fl(1.0 / 60.0);
                std::ostringstream oss;
                oss << get_current_millisecond_timestamp() << " 警告： dsp共享内存数据推送数据过多 当前数据队列长度:" << list.size() <<
                std::endl;
                if (fl.test()) {
                    std::cout << oss.str() << std::endl;
                }
            }
            if (list.empty()) {
                std::this_thread::sleep_for(std::chrono::microseconds(1));
                continue;
            }
            auto frame_number = list.size();
            static Frequency_Limit fl(freq);
            if (fl.test()) {
                std::cout << dg->rb->state_str() << " dsp数据推送" << frame_number << "条" << std::endl;
            }
            for (int i = 0; i < frame_number; i++) {
                auto buf = list[i];
                dg->handle_2112(buf->data());
            }
        }
    });
    while (!stop_program) {
        dg->handle_json_call();
    }
    if (stop_program == SIGINT) {
        std::cout << "开始关闭所有子线程!" << std::endl;
    }
    return 0;
}