---@diagnostic disable: deprecated
local it = require "util.iterators";
local json = require "util.json";
local array = require "util.array";
local iterators = require "util.iterators";
local jid = require "util.jid";

local async_handler_wrapper = module:require "util".async_handler_wrapper;
local get_room_from_jid = module:require "util".get_room_from_jid;
local muc_domain_prefix = module:get_option_string("muc_mapper_domain_prefix", "conference");
local domain_name = "meet.jitsi"


function get_participants_for_room(room_name)

    local room_address = jid.join(room_name, muc_domain_prefix .. "." .. domain_name);
    local room = get_room_from_jid(room_address);
    local occupants_json = array();
    if room then
        local occupants = room._occupants;
        if occupants then
            participant_count = iterators.count(room:each_occupant());
            for _, occupant in room:each_occupant() do
                -- filter focus as we keep it as hidden participant
                if string.sub(occupant.nick, -string.len("/focus")) ~= "/focus" then
                    for _, pr in occupant:each_session() do
                        local nick = pr:get_child_text("nick", "http://jabber.org/protocol/nick") or "";
                        local email = pr:get_child_text("email") or "";
                        local avatarURL = pr:get_child_text("avatarURL") or "" -- does not work :(
                        occupants_json:push({
                            jid = tostring(occupant.nick),
                            email = tostring(email),
                            displayName = tostring(nick),
                            avatarURL = tostring(avatarURL)
                        });
                    end
                end
            end
        end
        log("debug",
            "there are %s occupants in room", tostring(participant_count));
        return occupants_json
    else
        log("debug", "no such room exists");
    end
    return occupants_json
end

function get_all_rooms_with_participants()

    local sessions = prosody.full_sessions;

    local someTable = (it.join(it.keys(sessions)));
    local actual_rooms = someTable[1][2]

    local roomNames = {}
    for _, v in pairs(actual_rooms) do
        local roomName = v["jitsi_web_query_room"]
        if (roomName ~= nil) then
            roomNames[roomName] = true;
        end
    end

    local rooms_with_participants = array();
    for room_name, _ in pairs(roomNames) do
        local room = { roomName = room_name, participants = get_participants_for_room(room_name) }
        rooms_with_participants:push(room)
    end
    return json.encode(rooms_with_participants)
end

--- Handles request for retrieving the room participants details
-- @param event the http event, holds the request query
-- @return GET response, containing a json with participants details
function handle_get_sessions(event)
    handle_room_event()
    return { status_code = 200; body = get_all_rooms_with_participants() };
end

function module.load()
    -- Ensure that mod_http is loaded:
    --
    module:depends("http");

    -- Now publish our HTTP 'app':
    module:log("info", "Hello! You can reach me at: %s", module:http_url());
    module:provides("http", {
        route = {
            ["GET"] = function(event) return async_handler_wrapper(event, handle_get_sessions) end;

        };
    });
end

-------- event stuff
--
--
--
--
--
--
--
--
--

local http = require "net.http";
local is_healthcheck_room = module:require "util".is_healthcheck_room;
--- Start non-blocking HTTP call
-- @param url URL to call
-- @param options options table as expected by net.http where we provide optional headers, body or method.
local function async_http_request(url, options)
    local completed = false;
    local timed_out = false;

    local function cb_(response_body, response_code)
        if not timed_out then -- request completed before timeout
            completed = true;

            module:log("debug", "%s %s returned code %s", options.method, url, response_code);
        end
    end

    http.request(url, options, cb_);
end

--- Checks if event is triggered by healthchecks or focus user.
function is_system_event(event)

    if event == nil or event.room == nil or event.room.jid == nil then
        return true;
    end

    if is_healthcheck_room(event.room.jid) then
        return true;
    end

    if event.occupant and jid.node(event.occupant.jid) == "focus" then
        return true;
    end

    return false;
end

function handle_room_event(event)
    module:log('info', "hallo irgendwas ist passiert");
    if is_system_event(event) then
        return;
    end

    async_http_request("http://192.168.2.116:8081/roomdata",
        {
            method = "POST",
            body = get_all_rooms_with_participants()
        })

end

--Helper function to wait till a component is loaded before running the given callback
function run_when_component_loaded(component_host_name, callback)
    local function trigger_callback()
        module:log('info', 'Component loaded %s', component_host_name);
        callback(module:context(component_host_name), component_host_name);
    end

    if prosody.hosts[component_host_name] == nil then
        module:log('debug', 'Host %s not yet loaded. Will trigger when it is loaded.', component_host_name);
        prosody.events.add_handler('host-activated', function(host)
            if host == component_host_name then
                trigger_callback();
            end
        end);
    else
        trigger_callback();
    end
end

-- Helper function to wait till a component's muc module is loaded before running the given callback
function run_when_muc_module_loaded(component_host_module, component_host_name, callback)
    local function trigger_callback()
        module:log('info', 'MUC module loaded for %s', component_host_name);
        callback(prosody.hosts[component_host_name].modules.muc, component_host_module);
    end

    if prosody.hosts[component_host_name].modules.muc == nil then
        module:log('debug', 'MUC module for %s not yet loaded. Will trigger when it is loaded.', component_host_name);
        prosody.hosts[component_host_name].events.add_handler('module-loaded', function(event)
            if (event.module == 'muc') then
                trigger_callback();
            end
        end);
    else
        trigger_callback()
    end
end

local main_muc_component_host = muc_domain_prefix .. "." .. domain_name
-- Handle events on main muc module
run_when_component_loaded(main_muc_component_host, function(host_module, host_name)
    run_when_muc_module_loaded(host_module, host_name, function(main_muc, main_module)
        main_muc_service = main_muc; -- so it can be accessed from breakout muc event handlers

        -- the following must run after speakerstats (priority -1)
        main_module:hook("muc-room-created", handle_room_event, -3); -- must run after handle_main_room_created
        main_module:hook("muc-occupant-joined", handle_room_event, -2);
        main_module:hook("muc-occupant-left", handle_room_event, -2);
        main_module:hook("muc-room-destroyed", handle_room_event, -2);
    end);
end);