// led/BX6K1YYProtocol.cxx
#include "BX6K1YYProtocol.hpp"

#include <algorithm>

namespace led {

namespace {

inline void appendLe16(std::vector<uint8_t>& v, uint16_t value) {
    v.push_back(static_cast<uint8_t>(value & 0xff));
    v.push_back(static_cast<uint8_t>((value >> 8) & 0xff));
}

inline void appendLe32(std::vector<uint8_t>& v, uint32_t value) {
    v.push_back(static_cast<uint8_t>(value & 0xff));
    v.push_back(static_cast<uint8_t>((value >> 8) & 0xff));
    v.push_back(static_cast<uint8_t>((value >> 16) & 0xff));
    v.push_back(static_cast<uint8_t>((value >> 24) & 0xff));
}

std::vector<uint8_t> escape(const std::vector<uint8_t>& in) {
    std::vector<uint8_t> out;
    out.reserve(in.size());
    for (uint8_t b : in) {
        switch (b) {
        case 0xA5: out.push_back(0xA6); out.push_back(0x02); break;
        case 0xA6: out.push_back(0xA6); out.push_back(0x01); break;
        case 0x5A: out.push_back(0x5B); out.push_back(0x02); break;
        case 0x5B: out.push_back(0x5B); out.push_back(0x01); break;
        default:   out.push_back(b);                break;
        }
    }
    return out;
}

} // anonymous namespace

uint16_t crc16(const std::vector<uint8_t>& data) {
    uint16_t crc = 0;
    for (uint8_t b : data) {
        crc ^= b;
        for (int i = 0; i < 8; ++i) {
            crc = (crc & 1u) ? static_cast<uint16_t>((crc >> 1) ^ 0xA001u)
                             : static_cast<uint16_t>(crc >> 1);
        }
    }
    return crc;
}

std::vector<uint8_t> makeFrame(const std::vector<uint8_t>& payload) {
    std::vector<uint8_t> phy1;
    appendLe16(phy1, 0xFFFE);   // 目标：广播/任意控制器
    appendLe16(phy1, 0x8000);   // 源：PC
    phy1.push_back(0x00);       // barcode 选项：关
    phy1.push_back(0x00);
    phy1.push_back(0x00);
    phy1.push_back(0x00);       // CRC16 模式
    phy1.push_back(0x00);       // 显示模式（动态区域文本）
    phy1.push_back(kDeviceType);
    phy1.push_back(kProtocolVersion);
    appendLe16(phy1, static_cast<uint16_t>(payload.size()));
    phy1.insert(phy1.end(), payload.begin(), payload.end());

    uint16_t cs = crc16(phy1);
    phy1.push_back(static_cast<uint8_t>(cs & 0xff));
    phy1.push_back(static_cast<uint8_t>((cs >> 8) & 0xff));

    std::vector<uint8_t> frame;
    frame.reserve(9 + phy1.size() * 2);
    frame.insert(frame.end(), 8, 0xA5);        // 8 字节头
    auto esc = escape(phy1);
    frame.insert(frame.end(), esc.begin(), esc.end());
    frame.push_back(0x5A);                    // 1 字节尾
    return frame;
}

std::vector<uint8_t> buildScreenParameterQueryFrame() {
    return makeFrame(std::vector<uint8_t>{0xA2, 0x0A, 0x01, 0x00, 0x00});
}

// 27 字节 AreaHeader + 文本内容（与 Windows 版 buildArea 等价）
static std::vector<uint8_t> buildArea(const std::string& text,
                                       int screenWidth,
                                       int areaY, int areaHeight,
                                       int areaId,
                                       bool expireWhenNotUpdated,
                                       int timeoutSeconds) {
    std::vector<uint8_t> area;
    area.reserve(27 + text.size());
    area.push_back(0x00);                                     // AreaType: 字符
    appendLe16(area, 0x8000);                                 // AreaX: 0（像素单位）
    appendLe16(area, static_cast<uint16_t>(areaY));
    appendLe16(area, static_cast<uint16_t>(0x8000 | screenWidth));
    appendLe16(area, static_cast<uint16_t>(areaHeight));
    area.push_back(static_cast<uint8_t>(areaId));
    area.push_back(0x00);                                     // 行间距
    area.push_back(expireWhenNotUpdated ? 0x02 : 0x00);       // RunMode
    int t = (timeoutSeconds < 0) ? 0 : (timeoutSeconds > 0xffff ? 0xffff : timeoutSeconds);
    appendLe16(area, static_cast<uint16_t>(t));
    area.push_back(0x00);                                     // SoundMode
    area.push_back(0x00); area.push_back(0x00);               // 保留
    area.push_back(0x02);                                     // 多行
    area.push_back(0x01);                                     // 手动换行
    area.push_back(0x01);                                     // 静态显示
    area.push_back(0x00);                                     // 退出方式
    area.push_back(0x02);                                     // 速度
    area.push_back(0x0A);                                     // 停留（0.5s 单位）
    appendLe32(area, static_cast<uint32_t>(text.size()));
    area.insert(area.end(), text.begin(), text.end());
    return area;
}

std::vector<uint8_t> buildDynamicTextFrame(const std::string& encodedText,
                                            int screenWidth, int lineHeight,
                                            int areaId,
                                            bool expireWhenNotUpdated,
                                            int timeoutSeconds) {
    if (screenWidth <= 0 || screenWidth > 0x7fff) return {};
    if (lineHeight  <= 0) return {};

    const std::vector<uint8_t> area = buildArea(encodedText, screenWidth,
                                                 /*areaY=*/0, lineHeight, areaId,
                                                 expireWhenNotUpdated, timeoutSeconds);
    if (area.empty() || area.size() > 0xffff) return {};

    std::vector<uint8_t> payload;
    payload.push_back(0xA3);
    payload.push_back(0x06);                                  // 动态区域下发
    payload.push_back(0x01);                                  // 需要 ACK
    payload.push_back(0x00);                                  // ProcessMode: 替换
    payload.push_back(0x00);                                  // 保留
    payload.push_back(0x00);                                  // DeleteAreaNum: 0
    payload.push_back(0x01);                                  // AreaNum: 1
    appendLe16(payload, static_cast<uint16_t>(area.size()));
    payload.insert(payload.end(), area.begin(), area.end());
    return makeFrame(payload);
}

std::vector<uint8_t> buildDeleteDynamicAreaFrame(int areaId) {
    if (areaId < 0 || areaId > 0xff) return {};
    std::vector<uint8_t> payload = {
        0xA3, 0x07, 0x01, 0x00, 0x00, 0x01,
        static_cast<uint8_t>(areaId)
    };
    return makeFrame(payload);
}

bool decodeFrame(const std::vector<uint8_t>& frame,
                 std::vector<uint8_t>& outPhy1,
                 std::string& error) {
    outPhy1.clear();
    if (frame.size() < 8 + 14 + 2 + 1 || frame.back() != 0x5A) {
        error = "frame too short or missing tail";
        return false;
    }
    for (size_t i = 0; i < 8; ++i) {
        if (frame[i] != 0xA5) { error = "header invalid"; return false; }
    }
    std::vector<uint8_t> body(frame.begin() + 8, frame.end() - 1);
    for (size_t i = 0; i < body.size(); ++i) {
        uint8_t b = body[i];
        if (b == 0xA6 || b == 0x5B) {
            if (++i >= body.size()) { error = "truncated escape"; return false; }
            uint8_t n = body[i];
            if (b == 0xA6) {
                if      (n == 0x02) outPhy1.push_back(0xA5);
                else if (n == 0x01) outPhy1.push_back(0xA6);
                else { error = "bad A6 escape"; return false; }
            } else {
                if      (n == 0x02) outPhy1.push_back(0x5A);
                else if (n == 0x01) outPhy1.push_back(0x5B);
                else { error = "bad 5B escape"; return false; }
            }
        } else {
            outPhy1.push_back(b);
        }
    }
    if (outPhy1.size() < 16) { error = "phy1 too short"; return false; }

    std::vector<uint8_t> withoutCrc(outPhy1.begin(), outPhy1.end() - 2);
    uint16_t expected = crc16(withoutCrc);
    uint16_t actual = static_cast<uint16_t>(outPhy1[outPhy1.size() - 2]) |
                      static_cast<uint16_t>(outPhy1[outPhy1.size() - 1] << 8);
    if (expected != actual) { error = "crc16 mismatch"; return false; }

    outPhy1.pop_back(); outPhy1.pop_back();
    return true;
}

bool parseScreenDimensions(const std::vector<uint8_t>& phy1,
                            int& outWidth, int& outHeight,
                            std::string& error) {
    if (phy1.size() < 14 + 13 || phy1[10] != kDeviceType || phy1[11] != kProtocolVersion) {
        error = "response header invalid";
        return false;
    }
    std::vector<uint8_t> payload(phy1.begin() + 14, phy1.end());
    if (payload.size() < 13 || payload[0] != 0xA2 || payload[1] != 0x0A || payload[2] != 0x00) {
        error = "response payload invalid";
        return false;
    }
    outWidth  = static_cast<uint16_t>(payload[9])  | (static_cast<uint16_t>(payload[10]) << 8);
    outHeight = static_cast<uint16_t>(payload[11]) | (static_cast<uint16_t>(payload[12]) << 8);
    if (outWidth == 0 || outHeight == 0) { error = "invalid dimensions"; return false; }
    return true;
}

} // namespace led