#include <curl/curl.h>

// 下载回调：每收到一块数据就调用
size_t WriteCallback(void* contents, size_t size, size_t nmemb, void* userp) {
    size_t total_size = size * nmemb;
    auto* buffer = static_cast<RingBuffer*>(userp);
    buffer->Write(contents, total_size);
    return total_size;  // 返回处理的数据量
}

// 发起 HTTP 请求
void Download(const std::string& url, int64_t start_pos, RingBuffer* buffer) {
    CURL* curl = curl_easy_init();
    
    // 设置 URL
    curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
    
    // 设置 Range
    char range[64];
    snprintf(range, sizeof(range), "%ld-", start_pos);
    curl_easy_setopt(curl, CURLOPT_RANGE, range);
    
    // 设置回调
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, buffer);
    
    // 设置超时
    curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 10L);
    curl_easy_setopt(curl, CURLOPT_TIMEOUT, 0L);  // 无总超时（流式）
    
    // 执行请求
    CURLcode res = curl_easy_perform(curl);
    if (res != CURLE_OK) {
        fprintf(stderr, "Download failed: %s\n", curl_easy_strerror(res));
    }
    
    curl_easy_cleanup(curl);
}

// 发起一次请求，持续接收
curl_easy_setopt(curl, CURLOPT_RANGE, "0-");  // 从开始到结束
curl_easy_perform(curl);  // 阻塞直到连接断开

const int CHUNK_SIZE = 64 * 1024;  // 64KB

for (int i = 0; i < num_chunks; i++) {
    int64_t start = i * CHUNK_SIZE;
    int64_t end = start + CHUNK_SIZE - 1;
    
    char range[64];
    snprintf(range, sizeof(range), "%ld-%ld", start, end);
    curl_easy_setopt(curl, CURLOPT_RANGE, range);
    curl_easy_perform(curl);
}

#pragma once
#include <cstdint.h>
#include <stddef.h>
#include <mutex>
#include <condition_variable>

namespace live {

class RingBuffer {
public:
    explicit RingBuffer(size_t capacity);
    ~RingBuffer();

    // 禁止拷贝
    RingBuffer(const RingBuffer&) = delete;
    RingBuffer& operator=(const RingBuffer&) = delete;

    // 写入数据（下载线程调用）
    // 返回实际写入的字节数（可能小于请求，如果缓冲满）
    size_t Write(const void* data, size_t len);
    
    // 读取数据（解码线程调用）
    // 返回实际读取的字节数（可能小于请求，如果数据不足）
    size_t Read(void* out, size_t len);
    
    // 阻塞式读取（等待直到有足够数据）
    size_t ReadBlocking(void* out, size_t len);
    
    // 查询状态
    size_t Size() const;      // 当前已缓冲的数据量
    size_t Capacity() const;  // 总容量
    bool Empty() const;
    bool Full() const;
    
    // 控制
    void Clear();
    void Stop();  // 通知等待的线程退出

    // 用于 FFmpeg 的回调接口
    static int ReadCallback(void* opaque, uint8_t* buf, int buf_size);

private:
    uint8_t* buffer_;         // 底层缓冲区
    const size_t capacity_;   // 容量
    
    size_t read_pos_ = 0;     // 读位置
    size_t write_pos_ = 0;    // 写位置
    size_t size_ = 0;         // 当前数据量
    int64_t total_read_ = 0;  // 累计读取（用于 seek）
    
    mutable std::mutex mutex_;
    std::condition_variable not_full_;
    std::condition_variable not_empty_;
    std::atomic<bool> stopped_{false};
};

} // namespace live

// 写入数据
size_t RingBuffer::Write(const void* data, size_t len) {
    std::unique_lock<std::mutex> lock(mutex_);
    
    // 等待有空间（非阻塞模式直接返回）
    if (size_ >= capacity_) {
        return 0;  // 缓冲满
    }
    
    const uint8_t* src = static_cast<const uint8_t*>(data);
    size_t written = 0;
    
    while (len > 0 && size_ < capacity_) {
        // 计算本次可写入的长度
        size_t write_end = (write_pos_ >= read_pos_) ? capacity_ : read_pos_;
        size_t can_write = std::min(len, write_end - write_pos_);
        can_write = std::min(can_write, capacity_ - size_);
        
        if (can_write == 0) break;
        
        // 写入数据
        memcpy(buffer_ + write_pos_, src + written, can_write);
        write_pos_ = (write_pos_ + can_write) % capacity_;
        size_ += can_write;
        written += can_write;
        len -= can_write;
    }
    
    lock.unlock();
    not_empty_.notify_all();
    
    return written;
}

// 读取数据
size_t RingBuffer::Read(void* out, size_t len) {
    std::unique_lock<std::mutex> lock(mutex_);
    
    if (size_ == 0) {
        return 0;  // 缓冲空
    }
    
    uint8_t* dst = static_cast<uint8_t*>(out);
    size_t read = 0;
    
    while (len > 0 && size_ > 0) {
        // 计算本次可读取的长度
        size_t read_end = (read_pos_ >= write_pos_) ? capacity_ : write_pos_;
        size_t can_read = std::min(len, read_end - read_pos_);
        can_read = std::min(can_read, size_);
        
        if (can_read == 0) break;
        
        // 读取数据
        memcpy(dst + read, buffer_ + read_pos_, can_read);
        read_pos_ = (read_pos_ + can_read) % capacity_;
        size_ -= can_read;
        read += can_read;
        len -= can_read;
    }
    
    total_read_ += read;
    
    lock.unlock();
    not_full_.notify_all();
    
    return read;
}

// FFmpeg 读取回调
int RingBuffer::ReadCallback(void* opaque, uint8_t* buf, int buf_size) {
    auto* ring = static_cast<RingBuffer*>(opaque);
    return static_cast<int>(ring->ReadBlocking(buf, buf_size));
}

// 使用自定义 IO 打开网络流
AVFormatContext* OpenNetworkStream(RingBuffer* ring) {
    AVFormatContext* ctx = avformat_alloc_context();
    
    // 分配 AVIOContext
    int buffer_size = 32768;
    uint8_t* avio_buffer = static_cast<uint8_t*>(av_malloc(buffer_size));
    
    AVIOContext* avio = avio_alloc_context(
        avio_buffer, buffer_size, 0, ring,
        RingBuffer::ReadCallback, nullptr, nullptr);
    
    ctx->pb = avio;
    
    // 打开输入（从 RingBuffer 读取）
    avformat_open_input(&ctx, nullptr, nullptr, nullptr);
    
    return ctx;
}

#pragma once
#include "live/ring_buffer.h"
#include <string>
#include <thread>
#include <atomic>

namespace live {

struct DownloadConfig {
    std::string url;
    int64_t start_pos = 0;      // 起始位置（用于 seek）
    int connect_timeout = 10;   // 连接超时（秒）
    int speed_limit = 0;        // 限速（KB/s，0 表示不限）
};

class DownloadThread {
public:
    explicit DownloadThread(RingBuffer* buffer, const DownloadConfig& config);
    ~DownloadThread();

    DownloadThread(const DownloadThread&) = delete;
    DownloadThread& operator=(const DownloadThread&) = delete;

    bool Start();
    void Stop();
    bool IsRunning() const { return running_.load(); }
    
    // 获取下载统计
    int64_t GetDownloadedBytes() const { return downloaded_bytes_.load(); }
    double GetCurrentSpeed() const;  // KB/s

private:
    void Run();
    static size_t WriteCallback(void* contents, size_t size, size_t nmemb, void* userp);

    RingBuffer* ring_buffer_;
    DownloadConfig config_;
    
    std::thread thread_;
    std::atomic<bool> running_{false};
    std::atomic<bool> should_stop_{false};
    
    std::atomic<int64_t> downloaded_bytes_{0};
    std::atomic<int64_t> current_speed_{0};  // bytes/s
};

} // namespace live

#include "download_thread.h"
#include <curl/curl.h>
#include <iostream>
#include <chrono>

namespace live {

DownloadThread::DownloadThread(RingBuffer* buffer, const DownloadConfig& config)
    : ring_buffer_(buffer)
    , config_(config) {
}

DownloadThread::~DownloadThread() {
    Stop();
}

bool DownloadThread::Start() {
    if (running_.load()) return false;
    
    running_.store(true);
    should_stop_.store(false);
    thread_ = std::thread(&DownloadThread::Run, this);
    
    std::cout << "[Download] Thread started, url=" << config_.url << std::endl;
    return true;
}

void DownloadThread::Stop() {
    if (!running_.load()) return;
    
    std::cout << "[Download] Stopping..." << std::endl;
    
    should_stop_.store(true);
    ring_buffer_->Stop();
    
    if (thread_.joinable()) {
        thread_.join();
    }
    
    running_.store(false);
    std::cout << "[Download] Stopped, total=" << downloaded_bytes_.load() << " bytes" << std::endl;
}

size_t DownloadThread::WriteCallback(void* contents, size_t size, size_t nmemb, void* userp) {
    auto* self = static_cast<DownloadThread*>(userp);
    size_t total_size = size * nmemb;
    
    // 写入环形缓冲区
    size_t written = 0;
    while (written < total_size && !self->should_stop_.load()) {
        size_t n = self->ring_buffer_->Write(
            static_cast<uint8_t*>(contents) + written, 
            total_size - written);
        written += n;
        
        if (n == 0) {
            // 缓冲满，等待
            std::this_thread::sleep_for(std::chrono::milliseconds(10));
        }
    }
    
    self->downloaded_bytes_.fetch_add(written);
    return written;
}

void DownloadThread::Run() {
    CURL* curl = curl_easy_init();
    if (!curl) {
        std::cerr << "[Download] Failed to init curl" << std::endl;
        running_.store(false);
        return;
    }
    
    // 设置 URL
    curl_easy_setopt(curl, CURLOPT_URL, config_.url.c_str());
    
    // 设置 Range（支持断点续传/seek）
    if (config_.start_pos > 0) {
        char range[64];
        snprintf(range, sizeof(range), "%ld-", config_.start_pos);
        curl_easy_setopt(curl, CURLOPT_RANGE, range);
        std::cout << "[Download] Range: " << range << std::endl;
    }
    
    // 设置回调
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, this);
    
    // 设置超时
    curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, config_.connect_timeout);
    curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME, 30L);
    curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, 1000L);  // 1KB/s
    
    // 执行下载
    auto start_time = std::chrono::steady_clock::now();
    int64_t last_bytes = 0;
    
    CURLcode res = curl_easy_perform(curl);
    
    if (res != CURLE_OK) {
        std::cerr << "[Download] Error: " << curl_easy_strerror(res) << std::endl;
    }
    
    curl_easy_cleanup(curl);
    running_.store(false);
}

double DownloadThread::GetCurrentSpeed() const {
    return current_speed_.load() / 1024.0;  // KB/s
}

} // namespace live

// main.cpp
#include "live/ring_buffer.h"
#include "live/download_thread.h"
#include <SDL2/SDL.h>
#include <iostream>

extern "C" {
#include <libavformat/avformat.h>
#include <libavcodec/avcodec.h>
}

int main(int argc, char* argv[]) {
    if (argc < 2) {
        std::cerr << "用法: " << argv[0] << " <URL>" << std::endl;
        return 1;
    }

    const char* url = argv[1];
    
    // 1. 创建环形缓冲区 (4MB)
    live::RingBuffer ring_buffer(4 * 1024 * 1024);
    
    // 2. 启动下载线程
    live::DownloadConfig config;
    config.url = url;
    config.connect_timeout = 10;
    
    live::DownloadThread downloader(&ring_buffer, config);
    if (!downloader.Start()) {
        return 1;
    }
    
    // 3. 等待缓冲足够数据（预缓冲）
    std::cout << "[Main] 缓冲中..." << std::endl;
    while (ring_buffer.Size() < 1024 * 1024 && downloader.IsRunning()) {
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
    std::cout << "[Main] 开始播放" << std::endl;
    
    // 4. 使用自定义 IO 打开流
    AVFormatContext* fmt_ctx = avformat_alloc_context();
    
    int buffer_size = 32768;
    uint8_t* avio_buffer = static_cast<uint8_t*>(av_malloc(buffer_size));
    AVIOContext* avio = avio_alloc_context(
        avio_buffer, buffer_size, 0, &ring_buffer,
        live::RingBuffer::ReadCallback, nullptr, nullptr);
    
    fmt_ctx->pb = avio;
    
    if (avformat_open_input(&fmt_ctx, nullptr, nullptr, nullptr) < 0) {
        std::cerr << "无法打开输入" << std::endl;
        return 1;
    }
    
    // ... 后续解码渲染与第二章相同 ...
    
    // 5. 清理
    downloader.Stop();
    avformat_close_input(&fmt_ctx);
    av_freep(&avio_buffer);
    
    return 0;
}

cmake_minimum_required(VERSION 3.10)
project(network-player VERSION 3.0.0 LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 14)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

find_package(PkgConfig REQUIRED)
pkg_check_modules(FFMPEG REQUIRED
    libavformat libavcodec libavutil)
pkg_check_modules(CURL REQUIRED libcurl)
find_package(SDL2 REQUIRED)

add_executable(network-player
    src/main.cpp
    src/ring_buffer.cpp
    src/download_thread.cpp
)

target_include_directories(network-player PRIVATE
    ${CMAKE_CURRENT_SOURCE_DIR}/include
    ${FFMPEG_INCLUDE_DIRS}
    ${CURL_INCLUDE_DIRS}
    ${SDL2_INCLUDE_DIRS}
)

target_link_libraries(network-player
    ${FFMPEG_LIBRARIES}
    ${CURL_LIBRARIES}
    SDL2::SDL2
    pthread
)

class NetworkPlayer {
public:
    // Seek 到指定位置 (0.0 - 1.0)
    bool Seek(double position) {
        if (!file_size_.load()) return false;
        
        int64_t target_pos = static_cast<int64_t>(file_size_.load() * position);
        
        // 1. 停止当前播放
        Pause();
        
        // 2. 停止下载线程
        download_thread_->Stop();
        
        // 3. 清空缓冲区
        ring_buffer_->Clear();
        
        // 4. 重新创建下载线程
        DownloadConfig config;
        config.url = url_;
        config.start_pos = target_pos;
        download_thread_ = std::make_unique<DownloadThread>(ring_buffer_.get(), config);
        download_thread_->Start();
        
        // 5. 重置解码器上下文
        ResetDecoder();
        
        // 6. 恢复播放
        Resume();
        
        return true;
    }
    
private:
    void ResetDecoder() {
        // 关闭旧的
        avcodec_free_context(&codec_ctx_);
        avformat_close_input(&fmt_ctx_);
        
        // 创建新的（从环形缓冲区读取）
        fmt_ctx_ = avformat_alloc_context();
        // ... 设置 AVIOContext ...
        avformat_open_input(&fmt_ctx_, nullptr, nullptr, nullptr);
        // ... 重新查找流、初始化解码器 ...
    }
};

// 缓冲控制
void BufferControl() {
    const size_t BUFFER_MIN = 1 * 1024 * 1024;   // 1MB 开始播放
    const size_t BUFFER_MAX = 3 * 1024 * 1024;   // 3MB 暂停下载
    
    size_t buffered = ring_buffer->Size();
    
    if (buffered < BUFFER_MIN) {
        PausePlayback();  // 缓冲不足，暂停
    } else if (buffered > BUFFER_MAX) {
        PauseDownload();  // 缓冲充足，暂停下载
    } else {
        ResumePlayback();
        ResumeDownload();
    }
}

// 监测下载速度
if (download_speed < current_bitrate * 0.8) {
    // 网络不足，切换低码率
    SwitchToLowerBitrate();
}

void SwitchToLowerBitrate() {
    // 假设服务器提供多码率
    // - video_1080p.mp4
    // - video_720p.mp4
    // - video_480p.mp4
    
    current_quality--;
    std::string new_url = GetQualityUrl(current_quality);
    SeekToCurrentPosition(new_url);
}

# 第四章目标
./player rtmp://example.com/live/stream