#include "file_views.h"

#include <cstdio>
#include <cstdlib>
#include <cstring>

#include "file_list.h"
#include "track.h"

namespace roro::files {

std::string hexRow(uint32_t offset, const uint8_t* data, size_t len) {
    char head[8];
    std::snprintf(head, sizeof head, "%05X", static_cast<unsigned>(offset));
    std::string row = head, text;
    for (size_t i = 0; i < 8; i++) {
        if (i % 2 == 0) row += ' ';
        char hex[3] = "  ";
        if (i < len) {
            std::snprintf(hex, sizeof hex, "%02x", data[i]);
            text += data[i] >= 0x20 && data[i] < 0x7F ? static_cast<char>(data[i]) : '.';
        }
        row += hex;
    }
    return row + "  " + text;
}

namespace {
// Days since 1970-01-01 (Howard Hinnant's days_from_civil): no timegm() everywhere.
int64_t daysFromCivil(int y, int m, int d) {
    y -= m <= 2;
    int64_t era = (y >= 0 ? y : y - 399) / 400;
    int yoe = static_cast<int>(y - era * 400);
    int doy = (153 * (m + (m > 2 ? -3 : 9)) + 2) / 5 + d - 1;
    int doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
    return era * 146097 + doe - 719468;
}

bool attribute(const std::string& element, const char* name, double& out) {
    size_t at = element.find(name);
    if (at == std::string::npos) return false;
    const char* from = element.c_str() + at + std::strlen(name);
    char* end = nullptr;
    out = std::strtod(from, &end);
    return end != from;
}
}  // namespace

void GpxSummary::point(const std::string& element) {
    double lat, lon;
    if (!attribute(element, "lat=\"", lat) || !attribute(element, "lon=\"", lon)) return;
    if (points_ > 0) meters_ += gnss::distanceMeters(lat_, lon_, lat, lon);
    lat_ = lat;
    lon_ = lon;
    points_++;
    size_t at = element.find("<time>");
    int y, mo, d, h, mi, s;
    if (at != std::string::npos && std::sscanf(element.c_str() + at + 6, "%d-%d-%dT%d:%d:%d", &y, &mo, &d, &h, &mi, &s) == 6) {
        int64_t t = daysFromCivil(y, mo, d) * 86400 + h * 3600 + mi * 60 + s;
        if (first_ == 0) first_ = t;
        last_ = t;
    }
}

void GpxSummary::feed(const char* data, size_t len) {
    carry_.append(data, len);
    size_t done = 0;
    for (;;) {
        size_t open = carry_.find("<trkpt", done);
        if (open == std::string::npos) {
            // Nothing begun, except perhaps the first letters of a tag at the very end.
            done = carry_.size() > 6 ? carry_.size() - 6 : done;
            break;
        }
        size_t close = carry_.find("</trkpt>", open);
        size_t next = carry_.find("<trkpt", open + 6);  // a point with nothing inside: <trkpt .../>
        if (close == std::string::npos && next == std::string::npos) {
            done = open;
            break;
        }
        size_t end = close != std::string::npos && (next == std::string::npos || close < next) ? close + 8 : next;
        point(carry_.substr(open, end - open));
        done = end;
    }
    carry_.erase(0, done);
    if (carry_.size() > 2048) carry_.erase(0, carry_.size() - 6);  // not a GPX point: don't keep it
}

std::string formatDuration(int64_t seconds) {
    char s[24];
    if (seconds < 60) std::snprintf(s, sizeof s, "%d s", static_cast<int>(seconds));
    else if (seconds < 3600) std::snprintf(s, sizeof s, "%d min %02d s", static_cast<int>(seconds / 60), static_cast<int>(seconds % 60));
    else std::snprintf(s, sizeof s, "%d h %02d min", static_cast<int>(seconds / 3600), static_cast<int>(seconds % 3600 / 60));
    return s;
}

std::vector<std::string> GpxSummary::lines() const {
    std::vector<std::string> out;
    out.push_back(std::to_string(points_) + (points_ == 1 ? " point" : " points"));
    if (first_ > 0) {
        out.push_back("Started " + formatStamp(static_cast<uint32_t>(first_)));
        out.push_back("Lasted " + formatDuration(last_ - first_));
    }
    char s[32];
    if (meters_ < 1000) std::snprintf(s, sizeof s, "Distance %.0f m", meters_);
    else std::snprintf(s, sizeof s, "Distance %.2f km", meters_ / 1000);
    out.push_back(s);
    return out;
}

namespace {
uint32_t le32(const uint8_t* p) { return p[0] | p[1] << 8 | p[2] << 16 | static_cast<uint32_t>(p[3]) << 24; }
}  // namespace

PcapHeader parsePcapHeader(const uint8_t* data, size_t len) {
    PcapHeader h;
    if (len < kPcapHeaderSize || le32(data) != 0xA1B2C3D4) return h;  // little-endian, microseconds: what we write
    h.ok = true;
    h.linkType = le32(data + 20);
    return h;
}

bool parsePcapRecord(const uint8_t* data, size_t len, PcapRecord& out) {
    if (len < kPcapRecordSize) return false;
    out.seconds = le32(data);
    out.micros = le32(data + 4);
    out.length = le32(data + 8);
    return out.length <= 65535;
}

bool parseLoraTap(const uint8_t* d, size_t len, lora::RxInfo& out) {
    if (len < lora::kLoraTapSize || d[0] != 0) return false;
    out.frequencyHz = static_cast<uint32_t>(d[4]) << 24 | d[5] << 16 | d[6] << 8 | d[7];
    out.bandwidthKHz = d[8] * 125.0f;
    out.spreadingFactor = d[9];
    out.rssi = d[10] - 139.0f;
    out.noiseFloor = d[12] - 139.0f;
    out.snr = static_cast<int8_t>(d[13]) / 4.0f;
    out.syncWord = d[14];
    return true;
}

}  // namespace roro::files