// rtmp_manager.cpp
#include "rtmp_manager.hpp"

#include <chrono>
#include <iostream>
#include <thread>

#include "logger.hpp"

static inline std::string stream_type_suffix(StreamType type) { return (type == StreamType::MAIN) ? "_main" : "_sub"; }

std::unordered_map<std::string, std::unique_ptr<RTMPManager::StreamContext>> RTMPManager::streams;
std::mutex RTMPManager::streams_mutex;
RTMPManager::StreamCallback RTMPManager::status_callback = nullptr;

std::string RTMPManager::make_stream_key(const std::string &cam_name, StreamType type)
{
    return cam_name + stream_type_suffix(type);
}

void RTMPManager::init()
{
    gst_init(nullptr, nullptr);
    LOG_INFO("[RTMP] GStreamer initialized.");
}

void RTMPManager::set_status_callback(StreamCallback cb) { status_callback = std::move(cb); }

void RTMPManager::update_status(const std::string &key, const StreamStatus &status)
{
    {
        std::lock_guard<std::mutex> lock(streams_mutex);
        auto it = streams.find(key);
        if (it != streams.end()) it->second->status = status;
    }
    if (status_callback) status_callback(key, status);
}

GstElement *RTMPManager::create_pipeline(const Camera &cam, StreamType type)
{
    int width = cam.width, height = cam.height, fps = cam.fps, bitrate = cam.bitrate;
    if (type == StreamType::SUB)
    {
        width = std::max(160, width / 2);
        height = std::max(120, height / 2);
        fps = std::max(10, fps / 2);
        bitrate = std::max(300000, bitrate / 2);
    }

    std::string stream_name = cam.name + stream_type_suffix(type);
    std::string pipeline_str = "v4l2src device=" + cam.device +
                               " ! video/x-raw,format=NV12,width=" + std::to_string(width) +
                               ",height=" + std::to_string(height) + ",framerate=" + std::to_string(fps) +
                               "/1 ! queue max-size-buffers=1 leaky=downstream "
                               "! mpph264enc bps=" +
                               std::to_string(bitrate) + " gop=" + std::to_string(fps) +
                               " ! h264parse ! flvmux streamable=true name=mux "
                               "! rtmpsink location=\"rtmp://127.0.0.1/live/" +
                               stream_name + " live=1\" sync=false";

    LOG_INFO("[RTMP] Creating pipeline for '" + stream_name + "': " + pipeline_str);

    GError *error = nullptr;
    GstElement *pipeline = gst_parse_launch(pipeline_str.c_str(), &error);
    if (error)
    {
        LOG_ERROR("[RTMP] Pipeline parse error: " + std::string(error->message));
        g_error_free(error);
        return nullptr;
    }
    return pipeline;
}

int get_camera_index(const std::string &name)
{
    for (size_t i = 0; i < g_app_config.cameras.size(); ++i)
        if (g_app_config.cameras[i].name == name) return static_cast<int>(i);
    return -1;
}

RTMPManager::StreamResultInfo RTMPManager::start_camera(const Camera &cam, StreamType type)
{
    StreamResultInfo res;
    res.loc = get_camera_index(cam.name);
    res.url = get_stream_url(cam.name, type);

    std::string key = make_stream_key(cam.name, type);

    try
    {
        auto ctx = std::make_unique<StreamContext>();
        StreamContext *ctx_ptr = ctx.get();

        {
            std::lock_guard<std::mutex> lock(streams_mutex);
            auto it = streams.find(key);
            if (it != streams.end() && it->second->running.load())
            {
                res.result = 0;
                res.reason = "Already streaming";
                return res;
            }

            ctx->running.store(true);
            streams[key] = std::move(ctx);
        }

        std::future<StreamResultInfo> fut = ctx_ptr->start_result.get_future();

        ctx_ptr->thread = std::thread([cam, type, ctx_ptr]() { RTMPManager::stream_loop(cam, type, ctx_ptr); });

        if (fut.wait_for(std::chrono::seconds(10)) == std::future_status::ready)
        {
            res = fut.get();
        }
        else
        {
            res.result = 1;
            res.reason = "Start timeout";
            // 超时时停止线程
            stop_camera(cam.name, type);
        }
    }
    catch (const std::exception &e)
    {
        LOG_ERROR("[RTMP] Exception in start_camera for " + key + ": " + e.what());
        res.result = 1;
        res.reason = "Start exception: " + std::string(e.what());
    }

    return res;
}

RTMPManager::StreamResultInfo RTMPManager::stop_camera(const std::string &cam_name, StreamType type)
{
    StreamResultInfo res;
    res.loc = get_camera_index(cam_name);
    res.url = get_stream_url(cam_name, type);

    std::unique_ptr<StreamContext> ctx;
    std::string key = make_stream_key(cam_name, type);

    {
        std::lock_guard<std::mutex> lock(streams_mutex);
        auto it = streams.find(key);
        if (it == streams.end())
        {
            res.result = 0;
            res.reason = "Not streaming";
            return res;
        }

        // 标记停止
        it->second->running.store(false);

        // 移交所有权给局部变量，避免在锁内 join
        ctx = std::move(it->second);
        streams.erase(it);
    }

    // 安全 join
    if (ctx->thread.joinable()) ctx->thread.join();

    res.result = 0;
    res.reason = "Stopped manually";
    return res;
}

void RTMPManager::stream_loop(Camera cam, StreamType type, StreamContext *ctx)
{
    constexpr int FIRST_FRAME_TIMEOUT_SEC = 5;

    StreamResultInfo res;
    res.loc = get_camera_index(cam.name);
    res.url = get_stream_url(cam.name, type);

    std::string key = make_stream_key(cam.name, type);
    LOG_INFO("[RTMP] Stream loop started for " + key);

    GstElement *pipeline = nullptr;
    GstBus *bus = nullptr;
    bool start_result_set = false;

    try
    {
        // 确保在异常情况下也能设置结果
        auto set_start_result = [&](const StreamResultInfo &r)
        {
            if (!start_result_set)
            {
                try
                {
                    ctx->start_result.set_value(r);
                    start_result_set = true;
                }
                catch (const std::future_error &e)
                {
                    LOG_ERROR("[RTMP] Failed to set start result: " + std::string(e.what()));
                }
            }
        };

        // 创建管道
        pipeline = create_pipeline(cam, type);
        if (!pipeline)
        {
            res.result = 1;
            res.reason = "Failed to create pipeline";
            set_start_result(res);
            return;
        }

        bus = gst_element_get_bus(pipeline);
        if (!bus)
        {
            res.result = 1;
            res.reason = "Failed to get pipeline bus";
            set_start_result(res);
            return;
        }

        // 设置管道状态
        GstStateChangeReturn state_ret = gst_element_set_state(pipeline, GST_STATE_PLAYING);
        if (state_ret == GST_STATE_CHANGE_FAILURE)
        {
            res.result = 1;
            res.reason = "Failed to set pipeline to playing state";
            set_start_result(res);
            return;
        }

        bool first_frame_received = false;
        auto start_time = std::chrono::steady_clock::now();

        while (true)
        {
            // 检查是否应该停止
            {
                std::lock_guard<std::mutex> lock(streams_mutex);
                auto it = streams.find(key);
                if (it == streams.end() || !it->second->running.load())
                {
                    LOG_INFO("[RTMP] Stream loop stopping for " + key);
                    break;
                }
            }

            // 检查第一帧超时
            if (!first_frame_received)
            {
                auto elapsed = std::chrono::steady_clock::now() - start_time;
                if (std::chrono::duration_cast<std::chrono::seconds>(elapsed).count() > FIRST_FRAME_TIMEOUT_SEC)
                {
                    res.result = 1;
                    res.reason = "No frames received within timeout";
                    set_start_result(res);
                    LOG_WARN("[RTMP] First frame timeout for " + key);
                    break;
                }
            }

            // 等待GStreamer消息
            GstMessage *msg = gst_bus_timed_pop_filtered(
                bus, 100 * GST_MSECOND,
                static_cast<GstMessageType>(GST_MESSAGE_ERROR | GST_MESSAGE_EOS | GST_MESSAGE_STATE_CHANGED |
                                            GST_MESSAGE_ELEMENT));

            if (!msg) continue;

            switch (GST_MESSAGE_TYPE(msg))
            {
                case GST_MESSAGE_ERROR:
                {
                    GError *err = nullptr;
                    gchar *debug = nullptr;
                    gst_message_parse_error(msg, &err, &debug);
                    std::string err_msg = err ? err->message : "Unknown GStreamer error";
                    res.result = 1;
                    res.reason = "Pipeline error: " + err_msg;
                    set_start_result(res);
                    LOG_ERROR("[RTMP] Pipeline error for " + key + ": " + err_msg);
                    if (err) g_error_free(err);
                    if (debug) g_free(debug);
                    gst_message_unref(msg);
                    goto cleanup;
                }
                case GST_MESSAGE_EOS:
                    res.result = 1;
                    res.reason = "EOS received";
                    set_start_result(res);
                    LOG_INFO("[RTMP] EOS received for " + key);
                    gst_message_unref(msg);
                    goto cleanup;
                case GST_MESSAGE_STATE_CHANGED:
                    // 可以添加状态变化的日志用于调试
                    break;
                case GST_MESSAGE_ELEMENT:
                    if (!first_frame_received)
                    {
                        first_frame_received = true;
                        res.result = 0;
                        res.reason = "First frame received, started OK";
                        set_start_result(res);
                        LOG_INFO("[RTMP] First frame received for " + key);
                    }
                    break;
                default:
                    break;
            }

            gst_message_unref(msg);
        }
    }
    catch (const std::exception &e)
    {
        LOG_ERROR("[RTMP] Exception in stream_loop for " + key + ": " + e.what());
        res.result = 1;
        res.reason = "Exception: " + std::string(e.what());
        if (!start_result_set)
        {
            try
            {
                ctx->start_result.set_value(res);
                start_result_set = true;
            }
            catch (const std::future_error &)
            {
                // 忽略future错误
            }
        }
    }
    catch (...)
    {
        LOG_ERROR("[RTMP] Unknown exception in stream_loop for " + key);
        res.result = 1;
        res.reason = "Unknown exception";
        if (!start_result_set)
        {
            try
            {
                ctx->start_result.set_value(res);
                start_result_set = true;
            }
            catch (const std::future_error &)
            {
                // 忽略future错误
            }
        }
    }

cleanup:
    // 清理GStreamer资源
    if (pipeline)
    {
        gst_element_set_state(pipeline, GST_STATE_NULL);
        gst_object_unref(pipeline);
    }
    if (bus)
    {
        gst_object_unref(bus);
    }

    // 确保start_result被设置
    if (!start_result_set)
    {
        try
        {
            res.result = 1;
            res.reason = "Stream loop exited unexpectedly";
            ctx->start_result.set_value(res);
        }
        catch (const std::future_error &)
        {
            // 忽略future错误
        }
    }

    // 从streams中移除
    {
        std::lock_guard<std::mutex> lock(streams_mutex);
        streams.erase(key);
    }

    LOG_INFO("[RTMP] Stream loop ended for " + key);
}

bool RTMPManager::is_streaming(const std::string &cam_name, StreamType type)
{
    std::lock_guard<std::mutex> lock(streams_mutex);
    auto it = streams.find(make_stream_key(cam_name, type));
    return it != streams.end() && it->second->running.load();
}

bool RTMPManager::is_any_streaming()
{
    std::lock_guard<std::mutex> lock(streams_mutex);
    for (auto &kv : streams)
        if (kv.second->running.load()) return true;
    return false;
}

void RTMPManager::stop_all()
{
    std::vector<std::unique_ptr<StreamContext>> ctxs;

    {
        std::lock_guard<std::mutex> lock(streams_mutex);
        for (auto &kv : streams) kv.second->running.store(false);  // 标记停止

        // 移交所有权给局部变量，避免在锁内 join
        for (auto &kv : streams) ctxs.push_back(std::move(kv.second));
        streams.clear();
    }

    // 安全 join
    for (auto &ctx : ctxs)
    {
        if (ctx->thread.joinable()) ctx->thread.join();
    }

    LOG_INFO("[RTMP] stop_all completed.");
}

std::string RTMPManager::get_stream_url(const std::string &cam_name, StreamType type)
{
    return "rtmp://127.0.0.1/live/" + make_stream_key(cam_name, type);
}