// 1. 创建 UDP Socket
int sockfd = socket(AF_INET, SOCK_DGRAM, 0);

// 2. 绑定本地地址（服务器端必需）
bind(sockfd, (struct sockaddr*)&local_addr, sizeof(local_addr));

// 3. 发送数据
sendto(sockfd, buffer, len, 0, 
       (struct sockaddr*)&dest_addr, sizeof(dest_addr));

// 4. 接收数据
recvfrom(sockfd, buffer, max_len, 0,
         (struct sockaddr*)&from_addr, &addr_len);

// ============================================
// 简单的 UDP Echo 服务器
// ============================================
#pragma once
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <cstring>
#include <functional>

namespace live {

class UdpServer {
public:
    using PacketHandler = std::function<void(
        const uint8_t* data, size_t len,
        const sockaddr_in& from)>;

    UdpServer() : sockfd_(-1) {}
    
    ~UdpServer() { Stop(); }

    // 绑定本地端口
    bool Bind(uint16_t port) {
        sockfd_ = socket(AF_INET, SOCK_DGRAM, 0);
        if (sockfd_ < 0) return false;

        sockaddr_in addr{};
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = INADDR_ANY;

        if (bind(sockfd_, (sockaddr*)&addr, sizeof(addr)) < 0) {
            close(sockfd_);
            sockfd_ = -1;
            return false;
        }
        return true;
    }

    // 启动接收循环（阻塞模式）
    void StartBlocking(PacketHandler handler) {
        uint8_t buffer[2048];
        sockaddr_in from_addr;
        socklen_t addr_len = sizeof(from_addr);

        while (running_) {
            ssize_t n = recvfrom(sockfd_, buffer, sizeof(buffer), 0,
                                 (sockaddr*)&from_addr, &addr_len);
            if (n > 0 && handler) {
                handler(buffer, n, from_addr);
            }
        }
    }

    // 发送数据到指定地址
    void SendTo(const uint8_t* data, size_t len, 
                const sockaddr_in& to) {
        sendto(sockfd_, data, len, 0, 
               (sockaddr*)&to, sizeof(to));
    }

    void Stop() {
        running_ = false;
        if (sockfd_ >= 0) {
            close(sockfd_);
            sockfd_ = -1;
        }
    }

private:
    int sockfd_;
    bool running_ = true;
};

} // namespace live

// ============================================
// UDP 客户端
// ============================================
#pragma once
#include "udp_server.hpp"

namespace live {

class UdpClient {
public:
    bool Connect(const char* ip, uint16_t port) {
        sockfd_ = socket(AF_INET, SOCK_DGRAM, 0);
        if (sockfd_ < 0) return false;

        server_addr_.sin_family = AF_INET;
        server_addr_.sin_port = htons(port);
        inet_pton(AF_INET, ip, &server_addr_.sin_addr);
        
        connected_ = true;
        return true;
    }

    // 发送数据
    bool Send(const uint8_t* data, size_t len) {
        if (!connected_) return false;
        ssize_t sent = sendto(sockfd_, data, len, 0,
                              (sockaddr*)&server_addr_, 
                              sizeof(server_addr_));
        return sent == (ssize_t)len;
    }

    // 接收数据（带超时）
    bool Receive(uint8_t* buffer, size_t max_len, 
                 size_t& received, int timeout_ms) {
        // 设置接收超时
        timeval tv{timeout_ms / 1000, 
                   (timeout_ms % 1000) * 1000};
        setsockopt(sockfd_, SOL_SOCKET, SO_RCVTIMEO, 
                   &tv, sizeof(tv));

        sockaddr_in from;
        socklen_t addr_len = sizeof(from);
        ssize_t n = recvfrom(sockfd_, buffer, max_len, 0,
                             (sockaddr*)&from, &addr_len);
        if (n > 0) {
            received = n;
            return true;
        }
        return false;
    }

private:
    int sockfd_ = -1;
    sockaddr_in server_addr_;
    bool connected_ = false;
};

} // namespace live

// ============================================
// 非阻塞 UDP 服务器（基于 epoll）
// ============================================
#pragma once
#include <sys/epoll.h>
#include <fcntl.h>
#include <vector>

namespace live {

class UdpServerAsync {
public:
    bool Initialize(uint16_t port) {
        // 创建 socket
        sockfd_ = socket(AF_INET, SOCK_DGRAM, 0);
        if (sockfd_ < 0) return false;

        // 设置为非阻塞模式
        int flags = fcntl(sockfd_, F_GETFL, 0);
        fcntl(sockfd_, F_SETFL, flags | O_NONBLOCK);

        // 绑定地址
        sockaddr_in addr{};
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = INADDR_ANY;
        bind(sockfd_, (sockaddr*)&addr, sizeof(addr));

        // 创建 epoll 实例
        epollfd_ = epoll_create1(0);
        
        // 注册读事件
        epoll_event ev{};
        ev.events = EPOLLIN;
        ev.data.fd = sockfd_;
        epoll_ctl(epollfd_, EPOLL_CTL_ADD, sockfd_, &ev);

        return true;
    }

    // 事件循环
    void RunLoop() {
        epoll_event events[10];
        while (running_) {
            // 等待事件，最多阻塞 100ms
            int nfds = epoll_wait(epollfd_, events, 10, 100);
            
            for (int i = 0; i < nfds; i++) {
                if (events[i].data.fd == sockfd_) {
                    OnSocketReadable();
                }
            }
        }
    }

private:
    void OnSocketReadable() {
        uint8_t buffer[2048];
        sockaddr_in from;
        socklen_t addr_len = sizeof(from);

        // 循环读取所有可用数据（边缘触发模式需要）
        while (true) {
            ssize_t n = recvfrom(sockfd_, buffer, sizeof(buffer), 0,
                                 (sockaddr*)&from, &addr_len);
            if (n <= 0) {
                if (errno == EAGAIN || errno == EWOULDBLOCK) {
                    break; // 没有更多数据了
                }
                // 处理错误
                break;
            }
            // 处理数据包
            ProcessPacket(buffer, n, from);
        }
    }

    void ProcessPacket(const uint8_t* data, size_t len, 
                       const sockaddr_in& from) {
        // 实际业务逻辑
    }

    int sockfd_ = -1;
    int epollfd_ = -1;
    bool running_ = true;
};

} // namespace live

// ============================================
// RTP 打包器
// ============================================
#pragma once
#include <cstdint>
#include <cstring>

namespace live {

// RTP 头部结构（固定 12 字节）
struct RtpHeader {
    uint8_t flags;        // V(2) + P(1) + X(1) + CC(4)
    uint8_t m_pt;         // M(1) + PT(7)
    uint16_t sequence;    // 序列号（网络字节序）
    uint32_t timestamp;   // 时间戳（网络字节序）
    uint32_t ssrc;        // 同步源（网络字节序）

    // 设置各个字段
    void SetVersion(uint8_t v) { flags = (flags & 0x3F) | (v << 6); }
    void SetPadding(bool p) { flags = p ? (flags | 0x20) : (flags & 0xDF); }
    void SetExtension(bool x) { flags = x ? (flags | 0x10) : (flags & 0xEF); }
    void SetCsrcCount(uint8_t cc) { flags = (flags & 0xF0) | (cc & 0x0F); }
    void SetMarker(bool m) { m_pt = m ? (m_pt | 0x80) : (m_pt & 0x7F); }
    void SetPayloadType(uint8_t pt) { m_pt = (m_pt & 0x80) | (pt & 0x7F); }
    
    // 网络字节序转换
    void SetSequence(uint16_t seq) { sequence = htons(seq); }
    void SetTimestamp(uint32_t ts) { timestamp = htonl(ts); }
    void SetSsrc(uint32_t s) { ssrc = htonl(s); }
};
static_assert(sizeof(RtpHeader) == 12, "RtpHeader size must be 12");

class RtpPacketizer {
public:
    RtpPacketizer(uint8_t payload_type, uint32_t ssrc)
        : payload_type_(payload_type), ssrc_(ssrc), sequence_(0) {}

    // 打包一帧数据
    bool Packetize(const uint8_t* frame, size_t frame_len,
                   uint32_t timestamp,
                   std::vector<std::vector<uint8_t>>& packets) {
        
        const size_t MAX_RTP_PAYLOAD = 1400; // 预留空间给头部
        size_t offset = 0;
        bool first_fragment = true;

        while (offset < frame_len) {
            size_t remaining = frame_len - offset;
            size_t payload_size = std::min(remaining, MAX_RTP_PAYLOAD);
            bool last_fragment = (offset + payload_size >= frame_len);

            // 创建 RTP 包
            std::vector<uint8_t> packet;
            packet.reserve(12 + payload_size + 2); // 头 + 负载 + FU 头

            // 写入 RTP 头部
            RtpHeader header{};
            header.SetVersion(2);
            header.SetPadding(false);
            header.SetExtension(false);
            header.SetCsrcCount(0);
            header.SetMarker(last_fragment); // 最后一个片段设置 M 位
            header.SetPayloadType(payload_type_);
            header.SetSequence(sequence_++);
            header.SetTimestamp(timestamp);
            header.SetSsrc(ssrc_);

            packet.insert(packet.end(), 
                         reinterpret_cast<uint8_t*>(&header),
                         reinterpret_cast<uint8_t*>(&header) + 12);

            // 写入负载（这里简化处理，实际需要根据编码格式添加分片头）
            packet.insert(packet.end(),
                         frame + offset,
                         frame + offset + payload_size);

            packets.push_back(std::move(packet));
            offset += payload_size;
        }

        return !packets.empty();
    }

private:
    uint8_t payload_type_;
    uint32_t ssrc_;
    uint16_t sequence_;
};

} // namespace live

// H.264 NAL 单元类型
enum H264NalType {
    kNalSlice = 1,           // 非 IDR 片
    kNalDPA = 2,             // 数据分区 A
    kNalDPB = 3,             // 数据分区 B
    kNalDPC = 4,             // 数据分区 C
    kNalIDR = 5,             // IDR 片（关键帧）
    kNalSEI = 6,             // 补充增强信息
    kNalSPS = 7,             // 序列参数集
    kNalPPS = 8,             // 图像参数集
    kNalAUD = 9,             // 访问单元分隔符
    kNalEndOfSequence = 10,
    kNalEndOfStream = 11,
    kNalFiller = 12,
    kNalStapA = 24,          // 单时聚合包 A
    kNalFuA = 28,            // 分片单元 A
};

// FU-A 分片打包
void PackFuA(const uint8_t* nalu, size_t nalu_len, uint32_t timestamp,
             std::vector<std::vector<uint8_t>>& packets) {
    const size_t MAX_PAYLOAD = 1400;
    uint8_t nal_header = nalu[0]; // 原始 NAL 头部
    uint8_t nal_type = nal_header & 0x1F;
    uint8_t nri = nal_header & 0x60;

    size_t offset = 1; // 跳过 NAL 头部
    bool first = true;

    while (offset < nalu_len) {
        size_t remaining = nalu_len - offset;
        size_t payload_size = std::min(remaining, MAX_PAYLOAD);
        bool last = (offset + payload_size >= nalu_len);

        std::vector<uint8_t> packet;
        
        // 添加 RTP 头部（省略，同上）
        
        // FU 指示器：F(1) + NRI(2) + Type(5) = 28 (FU-A)
        uint8_t fu_indicator = nri | 28;
        packet.push_back(fu_indicator);

        // FU 头部：S(1) + E(1) + R(1) + Type(5)
        uint8_t fu_header = nal_type;
        if (first) fu_header |= 0x80; // S = 1
        if (last) fu_header |= 0x40;  // E = 1
        packet.push_back(fu_header);

        // 添加负载片段
        packet.insert(packet.end(), nalu + offset, 
                     nalu + offset + payload_size);

        packets.push_back(std::move(packet));
        
        offset += payload_size;
        first = false;
    }
}

// 计算丢包率
struct LossStats {
    uint32_t expected;      // 期望接收的包数
    uint32_t received;      // 实际接收的包数
    uint32_t lost;          // 丢失的包数
    uint8_t fraction_lost;  // 丢包率 (0-255, 255=100%)
};

LossStats CalculateLoss(uint16_t highest_seq, 
                        uint32_t cumulative_lost_prev,
                        uint32_t expected_prev) {
    LossStats stats;
    
    // 当前期望接收总数 = 最高序列号 - 初始序列号 + 1
    uint32_t expected_now = highest_seq + 1;
    uint32_t expected_interval = expected_now - expected_prev;
    
    // 实际接收数量（通过其他方式统计）
    uint32_t received_interval = /* 实际接收数 */;
    
    // 本周期丢包数
    int32_t lost_interval = expected_interval - received_interval;
    if (lost_interval < 0) lost_interval = 0;
    
    // 丢包率 (0-255)
    if (expected_interval > 0) {
        stats.fraction_lost = (lost_interval * 256) / expected_interval;
    }
    
    return stats;
}

// 抖动计算（RFC 3550 推荐算法）
class JitterCalculator {
public:
    void Update(uint32_t rtp_timestamp, 
                uint32_t arrival_time_ms) {
        // 传输时间差 = (到达时间 - RTP时间戳)
        int32_t transit = arrival_time_ms - 
                         (rtp_timestamp / 90); // 假设 90kHz
        
        if (first_packet_) {
            transit_prev_ = transit;
            first_packet_ = false;
            return;
        }
        
        // 本次与上次的差值
        int32_t d = transit - transit_prev_;
        if (d < 0) d = -d;
        
        // 指数加权移动平均：J = J + (|D| - J) / 16
        jitter_ += (d - jitter_) / 16;
        transit_prev_ = transit;
    }
    
    uint32_t GetJitter() const { return jitter_; }

private:
    bool first_packet_ = true;
    int32_t transit_prev_ = 0;
    uint32_t jitter_ = 0;
};

// ============================================
// RTCP 接收报告生成器
// ============================================
#pragma once
#include <cstdint>
#include <vector>
#include <cstring>

namespace live {

// RTCP 头部
struct RtcpHeader {
    uint8_t flags;      // V(2) + P(1) + RC(5)
    uint8_t packet_type;
    uint16_t length;    // 长度（32位字为单位）- 1

    void SetVersion(uint8_t v) { flags = (flags & 0x3F) | (v << 6); }
    void SetCount(uint8_t c) { flags = (flags & 0xC0) | (c & 0x1F); }
    void SetLength(uint16_t len) { length = htons(len); }
};

// 接收报告块
struct ReceiverReportBlock {
    uint32_t ssrc;          // 被报告源的 SSRC
    uint8_t fraction_lost;  // 丢包率
    uint8_t cumulative_lost[3]; // 累计丢包（24位）
    uint32_t highest_seq;   // 最高序列号
    uint32_t jitter;        // 抖动
    uint32_t lsr;           // 最后 SR 时间戳
    uint32_t dlsr;          // 自最后 SR 的延迟
};

class RtcpSender {
public:
    std::vector<uint8_t> CreateReceiverReport(
        uint32_t reporter_ssrc,
        const std::vector<ReceiverReportBlock>& blocks) {
        
        std::vector<uint8_t> packet;
        
        // RTCP 头部
        RtcpHeader header{};
        header.SetVersion(2);
        header.SetCount(blocks.size());
        header.packet_type = 201; // RR
        // 长度 = (4 + blocks.size() * 6) / 4 - 1 = 3 + blocks.size() * 6 / 4
        header.SetLength(3 + blocks.size() * 6 - 1);
        
        packet.push_back(header.flags);
        packet.push_back(header.packet_type);
        packet.push_back(header.length & 0xFF);
        packet.push_back((header.length >> 8) & 0xFF);
        
        // 报告者 SSRC
        uint32_t ssrc_net = htonl(reporter_ssrc);
        packet.insert(packet.end(), 
                     reinterpret_cast<uint8_t*>(&ssrc_net),
                     reinterpret_cast<uint8_t*>(&ssrc_net) + 4);
        
        // 报告块
        for (const auto& block : blocks) {
            AddReportBlock(packet, block);
        }
        
        return packet;
    }

private:
    void AddReportBlock(std::vector<uint8_t>& packet,
                       const ReceiverReportBlock& block) {
        uint32_t val;
        
        // SSRC
        val = htonl(block.ssrc);
        packet.insert(packet.end(),
                     reinterpret_cast<const uint8_t*>(&val),
                     reinterpret_cast<const uint8_t*>(&val) + 4);
        
        // 丢包率 + 累计丢包
        packet.push_back(block.fraction_lost);
        packet.push_back(block.cumulative_lost[0]);
        packet.push_back(block.cumulative_lost[1]);
        packet.push_back(block.cumulative_lost[2]);
        
        // 最高序列号
        val = htonl(block.highest_seq);
        packet.insert(packet.end(),
                     reinterpret_cast<const uint8_t*>(&val),
                     reinterpret_cast<const uint8_t*>(&val) + 4);
        
        // 抖动
        val = htonl(block.jitter);
        packet.insert(packet.end(),
                     reinterpret_cast<const uint8_t*>(&val),
                     reinterpret_cast<const uint8_t*>(&val) + 4);
        
        // LSR
        val = htonl(block.lsr);
        packet.insert(packet.end(),
                     reinterpret_cast<const uint8_t*>(&val),
                     reinterpret_cast<const uint8_t*>(&val) + 4);
        
        // DLSR
        val = htonl(block.dlsr);
        packet.insert(packet.end(),
                     reinterpret_cast<const uint8_t*>(&val),
                     reinterpret_cast<const uint8_t*>(&val) + 4);
    }
};

} // namespace live

// 基于丢包的带宽估计
class LossBasedBandwidthEstimator {
public:
    void Update(uint8_t fraction_lost) {
        // 丢包率 < 2%：网络良好，增加码率
        if (fraction_lost < 5) { // 约 2%
            bitrate_bps_ = static_cast<uint32_t>(bitrate_bps_ * 1.08);
        }
        // 丢包率 2%-10%：保持当前码率
        else if (fraction_lost < 26) { // 约 10%
            // 码率不变
        }
        // 丢包率 > 10%：网络拥塞，降低码率
        else {
            bitrate_bps_ = static_cast<uint32_t>(bitrate_bps_ * 0.85);
        }
        
        // 限制在合理范围
        bitrate_bps_ = std::min(bitrate_bps_, max_bitrate_bps_);
        bitrate_bps_ = std::max(bitrate_bps_, min_bitrate_bps_);
    }
    
    uint32_t GetEstimate() const { return bitrate_bps_; }

private:
    uint32_t bitrate_bps_ = 1000000;     // 初始 1Mbps
    uint32_t min_bitrate_bps_ = 150000;  // 最低 150kbps
    uint32_t max_bitrate_bps_ = 5000000; // 最高 5Mbps
};

// ============================================
// JitterBuffer 实现
// ============================================
#pragma once
#include <map>
#include <queue>
#include <chrono>
#include <functional>

namespace live {

struct JitterPacket {
    uint16_t sequence;
    uint32_t timestamp;
    std::vector<uint8_t> payload;
    std::chrono::steady_clock::time_point arrival_time;
    bool is_keyframe;
};

class JitterBuffer {
public:
    using FrameCallback = std::function<void(
        const JitterPacket& packet)>;

    explicit JitterBuffer(FrameCallback callback)
        : callback_(callback), target_delay_ms_(100) {}

    // 插入收到的数据包
    void InsertPacket(JitterPacket packet) {
        // 计算当前抖动
        UpdateJitterEstimate(packet);
        
        // 存储到缓冲区
        buffer_[packet.sequence] = std::move(packet);
        
        // 尝试输出
        TryOutput();
    }

    // 定期调用（如每 10ms）
    void Process() {
        TryOutput();
        
        // 动态调整目标延迟
        AdaptTargetDelay();
    }

private:
    void UpdateJitterEstimate(const JitterPacket& packet) {
        auto now = std::chrono::steady_clock::now();
        
        // 计算传输时间（简化为到达时间差 - 时间戳差）
        if (!last_arrival_.time_since_epoch().count()) {
            last_arrival_ = now;
            last_timestamp_ = packet.timestamp;
            return;
        }
        
        auto arrival_delta = std::chrono::duration_cast<
            std::chrono::milliseconds>(now - last_arrival_).count();
        int32_t timestamp_delta = static_cast<int32_t>(
            packet.timestamp - last_timestamp_) / 90; // 假设 90kHz
        
        int32_t d = arrival_delta - timestamp_delta;
        if (d < 0) d = -d;
        
        // 指数加权移动平均
        jitter_estimate_ms_ += (d - jitter_estimate_ms_) / 16;
        
        last_arrival_ = now;
        last_timestamp_ = packet.timestamp;
    }

    void TryOutput() {
        auto now = std::chrono::steady_clock::now();
        
        while (!buffer_.empty()) {
            auto it = buffer_.begin();
            const auto& packet = it->second;
            
            // 计算包龄（到达后的等待时间）
            auto age_ms = std::chrono::duration_cast<
                std::chrono::milliseconds>(now - packet.arrival_time).count();
            
            // 如果已达到目标延迟，输出
            if (age_ms >= target_delay_ms_) {
                if (callback_) {
                    callback_(packet);
                }
                buffer_.erase(it);
            } else {
                break; // 还没到输出时间
            }
        }
    }

    void AdaptTargetDelay() {
        // 目标延迟 = 当前抖动估计 + 安全余量
        int32_t new_target = jitter_estimate_ms_ + 50;
        
        // 限制范围
        new_target = std::max(new_target, 30);   // 最小 30ms
        new_target = std::min(new_target, 500);  // 最大 500ms
        
        // 平滑调整
        target_delay_ms_ += (new_target - target_delay_ms_) / 4;
    }

    std::map<uint16_t, JitterPacket> buffer_;
    FrameCallback callback_;
    
    int32_t jitter_estimate_ms_ = 0;
    int32_t target_delay_ms_ = 100;
    
    std::chrono::steady_clock::time_point last_arrival_;
    uint32_t last_timestamp_ = 0;
};

} // namespace live