#include <dmf-node/node_runner.hpp>
#include <dmf-node/control_server.hpp>

#include <mxl/flow.h>
#include <mxl/mxl.h>

#include <nlohmann/json.hpp>

#include <spdlog/spdlog.h>

#include <cstring>
#include <csignal>
#include <filesystem>
#include <thread>

namespace dmf_node {

static std::atomic<bool> g_running{true};

static void signal_handler(int /*signum*/) {
    g_running = false;
}

bool NodeRunner::parse_args(int argc, char* argv[]) {
    for (int i = 1; i < argc; ++i) {
        std::string arg = argv[i];
        if ((arg == "--node-id" || arg == "-n") && i + 1 < argc) {
            node_id_ = argv[++i];
        } else if ((arg == "--control-port" || arg == "-p") && i + 1 < argc) {
            control_port_ = static_cast<uint16_t>(std::stoi(argv[++i]));
        } else if ((arg == "--mxl-domain" || arg == "-d") && i + 1 < argc) {
            mxl_domain_ = argv[++i];
        } else if ((arg == "--config" || arg == "-c") && i + 1 < argc) {
            config_str_ = argv[++i];
        } else if (arg == "--help" || arg == "-h") {
            spdlog::info("Usage: {} [options]", argv[0]);
            spdlog::info("  --node-id, -n       Node instance ID");
            spdlog::info("  --control-port, -p  WebSocket control port");
            spdlog::info("  --mxl-domain, -d    MXL domain path (default: /dev/shm/mxl)");
            spdlog::info("  --config, -c        Node configuration JSON");
            return false;
        }
    }

    if (node_id_.empty()) {
        spdlog::error("--node-id is required");
        return false;
    }
    if (control_port_ == 0) {
        spdlog::error("--control-port is required");
        return false;
    }
    return true;
}

int NodeRunner::exec(std::unique_ptr<Node> node) {
    std::signal(SIGINT, signal_handler);
    std::signal(SIGTERM, signal_handler);

    spdlog::info("Starting node '{}' type='{}'", node_id_, node->type());

    if (!std::filesystem::exists(mxl_domain_)) {
        spdlog::error("MXL domain path does not exist: {}", mxl_domain_);
        return 1;
    }

    mxl_instance_ = mxlCreateInstance(mxl_domain_.c_str(), nullptr);
    if (!mxl_instance_) {
        spdlog::error("Failed to create MXL instance on domain: {}", mxl_domain_);
        return 1;
    }
    spdlog::info("MXL instance created on domain: {}", mxl_domain_);

    node->set_mxl_instance(mxl_instance_);

    mxlGarbageCollectFlows(mxl_instance_);

    if (!config_str_.empty()) {
        try {
            auto cfg = nlohmann::json::parse(config_str_);
            node->configure(cfg);
        } catch (const nlohmann::json::parse_error& e) {
            spdlog::error("Failed to parse config JSON: {}", e.what());
            mxlDestroyInstance(mxl_instance_);
            return 1;
        }
    }

    auto control_server = std::make_unique<ControlServer>(control_port_, [](const nlohmann::json& /*event*/) {});

    auto mk_ports = [](const std::vector<PortDef>& ports) {
        auto arr = nlohmann::json::array();
        for (const auto& p : ports) {
            arr.push_back({{"id", p.id}, {"direction", p.direction == PortDirection::Input ? "input" : "output"}, {"media_type", static_cast<int>(p.media_type)}});
        }
        return arr;
    };

    struct FlowResource {
        std::string port_id;
        mxlFlowWriter writer = nullptr;
        mxlFlowReader reader = nullptr;
    };
    std::vector<FlowResource> flow_resources;

    control_server->register_command("add_writer", [&](const nlohmann::json& msg) -> nlohmann::json {
        auto flow_id = msg["flow_id"].get<std::string>();
        auto port_id = msg["port_id"].get<std::string>();
        auto flow_def = msg["flow_def"].dump();

        mxlFlowWriter writer = nullptr;
        bool created = false;
        mxlFlowConfigInfo config_info{};
        auto status = mxlCreateFlowWriter(mxl_instance_, flow_def.c_str(), nullptr, &writer, &config_info, &created);
        if (status != MXL_STATUS_OK || !writer) {
            spdlog::error("Failed to create flow writer for flow {}: status={}", flow_id, static_cast<int>(status));
            return {{"ok", false}, {"error", "failed to create flow writer"}};
        }
spdlog::info("Created flow writer on port '{}' flow {} (created={})", port_id, flow_id, created);
        flow_resources.push_back({port_id, writer, nullptr});
        node->set_writer_config(port_id, config_info);
        node->on_add_writer(port_id, writer);
    });

    control_server->register_command("add_reader", [&](const nlohmann::json& msg) -> nlohmann::json {
        auto flow_id = msg["flow_id"].get<std::string>();
        auto port_id = msg["port_id"].get<std::string>();

        mxlFlowReader reader = nullptr;
        auto status = mxlCreateFlowReader(mxl_instance_, flow_id.c_str(), nullptr, &reader);
        if (status != MXL_STATUS_OK || !reader) {
            spdlog::error("Failed to create flow reader for flow {}: status={}", flow_id, static_cast<int>(status));
            return {{"ok", false}, {"error", "failed to create flow reader"}};
        }
spdlog::info("Created flow reader on port '{}' flow {}", port_id, flow_id);
        flow_resources.push_back({port_id, nullptr, reader});
        mxlFlowConfigInfo config{};
        mxlFlowReaderGetConfigInfo(reader, &config);
        node->set_reader_config(port_id, config);
        node->on_add_reader(port_id, reader);
    });

    control_server->register_command("remove_writer", [&](const nlohmann::json& msg) -> nlohmann::json {
        auto port_id = msg["port_id"].get<std::string>();
        node->on_remove_writer(port_id);
        for (auto it = flow_resources.begin(); it != flow_resources.end(); ++it) {
            if (it->port_id == port_id && it->writer) {
                mxlReleaseFlowWriter(mxl_instance_, it->writer);
                flow_resources.erase(it);
                break;
            }
        }
        spdlog::info("Removed writer on port '{}'", port_id);
        return {{"ok", true}};
    });

    control_server->register_command("remove_reader", [&](const nlohmann::json& msg) -> nlohmann::json {
        auto port_id = msg["port_id"].get<std::string>();
        node->on_remove_reader(port_id);
        for (auto it = flow_resources.begin(); it != flow_resources.end(); ++it) {
            if (it->port_id == port_id && it->reader) {
                mxlReleaseFlowReader(mxl_instance_, it->reader);
                flow_resources.erase(it);
                break;
            }
        }
        spdlog::info("Removed reader on port '{}'", port_id);
        return {{"ok", true}};
    });

    control_server->register_command("configure", [&](const nlohmann::json& msg) -> nlohmann::json {
        if (msg.contains("params")) {
            node->configure(msg["params"]);
            spdlog::info("Reconfigured node '{}'", node_id_);
        }
        return {{"ok", true}};
    });

    control_server->register_command("status", [&](const nlohmann::json& /*msg*/) -> nlohmann::json {
        nlohmann::json resp;
        resp["event"] = "status";
        resp["node_id"] = node_id_;
        resp["data"] = node->status();
        control_server->send_event(resp);
        return resp;
    });

    control_server->register_command("shutdown", [&](const nlohmann::json& /*msg*/) -> nlohmann::json {
        spdlog::info("Shutdown command received");
        g_running = false;
        return {{"ok", true}};
    });

    nlohmann::json ready_event;
    ready_event["event"] = "ready";
    ready_event["type"] = node->type();
    ready_event["node_id"] = node_id_;
    ready_event["ports"] = mk_ports(node->input_ports());
    for (const auto& p : node->output_ports()) {
        ready_event["ports"].push_back({{"id", p.id}, {"direction", "output"}, {"media_type", static_cast<int>(p.media_type)}});
    }
    control_server->send_event(ready_event);

    running_ = true;
    spdlog::info("Node '{}' entering process loop", node_id_);

    std::thread process_thread([&]() {
        while (g_running && running_) {
            node->process();
        }
    });

    while (g_running && running_) {
        control_server->poll(10);
    }

    running_ = false;
    process_thread.join();

    spdlog::info("Node '{}' shutting down", node_id_);

    for (auto& res : flow_resources) {
        if (res.writer) {
            mxlReleaseFlowWriter(mxl_instance_, res.writer);
        }
        if (res.reader) {
            mxlReleaseFlowReader(mxl_instance_, res.reader);
        }
    }
    flow_resources.clear();

    mxlDestroyInstance(mxl_instance_);
    return 0;
}

} // namespace dmf_node