forge/arma/client/addons/garage/functions/fnc_initUIBridge.sqf

#include "..\script_component.hpp"

/*
 * File: fnc_initUIBridge.sqf
 * Author: IDSolutions
 * Date: 2026-03-14
 * Public: No
 *
 * Description:
 * Initializes the garage UI bridge for browser control state and retrieve/store actions.
 */

#pragma hemtt ignore_variables ["_self"]
private _webUIDeclarations = call EFUNC(common,initWebUIBridge);
private _webUIBridgeDeclaration = _webUIDeclarations get "bridgeDeclaration";

GVAR(GarageUIBridgeBaseClass) = compileFinal createHashMapFromArray [
    ["#base", _webUIBridgeDeclaration],
    ["#type", "GarageUIBridgeBaseClass"],
    ["#create", compileFinal {
        _self set ["pendingStoreVehicle", objNull];
        _self set ["pendingRetrieve", createHashMap];
    }],
    ["getActiveBrowserControl", compileFinal {
        private _display = uiNamespace getVariable ["RscGarage", displayNull];
        if (isNull _display) exitWith {
            _self call ["setActiveBrowserControl", [controlNull]];
            controlNull
        };

        private _control = _display displayCtrl 1006;
        _self call ["setActiveBrowserControl", [_control]];
        _control
    }],
    ["handleReady", compileFinal {
        params [["_control", controlNull, [controlNull]], ["_data", createHashMap, [createHashMap]]];

        private _screen = _self call ["getScreen", []];
        _screen call ["setControl", [_control]];
        _screen call ["markReady", [true]];

        _self call ["flushPendingEvents", []];
        _self call ["sendEvent", ["garage::hydrate", GVAR(GarageSessionService) call ["buildPayload", []], _control]];
    }],
    ["refreshGarage", compileFinal {
        private _control = _self call ["getActiveBrowserControl", []];
        if (isNull _control) exitWith { false };

        _self call ["sendEvent", ["garage::sync", GVAR(GarageSessionService) call ["buildPayload", []], _control]]
    }],
    ["handleRetrieveRequest", compileFinal {
        params [["_data", createHashMap, [createHashMap]]];

        private _plate = _data getOrDefault ["plate", ""];
        if (_plate isEqualTo "") exitWith {
            _self call ["sendEvent", ["garage::retrieve::failure", createHashMapFromArray [
                ["message", "Select a stored vehicle to retrieve."]
            ]]];
        };

        private _garageMap = if (isNil QGVAR(GarageClass)) then {
            createHashMap
        } else {
            GVAR(GarageClass) call ["getGarageState", []]
        };
        private _vehicleData = _garageMap getOrDefault [_plate, createHashMap];
        if (_vehicleData isEqualTo createHashMap) exitWith {
            _self call ["sendEvent", ["garage::retrieve::failure", createHashMapFromArray [
                ["message", "Stored vehicle record could not be found."]
            ]]];
        };

        private _context = GVAR(GarageSessionService) call ["getContext", []];
        private _spawnPosition = _context getOrDefault ["spawnPosition", getPosATL player];
        private _spawnHeading = _context getOrDefault ["spawnHeading", getDir player];
        private _spawnRadius = _context getOrDefault ["spawnRadius", 6];
        private _blockingVehicles = [];
        {
            _blockingVehicles pushBackUnique _x;
        } forEach (_spawnPosition nearEntities [["Car", "Tank", "Air", "Ship"], _spawnRadius]);
        {
            _blockingVehicles pushBackUnique _x;
        } forEach (nearestObjects [_spawnPosition, ["Car", "Tank", "Air", "Ship"], _spawnRadius]);
        if (_blockingVehicles isNotEqualTo []) exitWith {
            _self call ["sendEvent", ["garage::retrieve::failure", createHashMapFromArray [
                ["message", "The garage spawn area is blocked."]
            ]]];
        };

        private _className = _vehicleData getOrDefault ["classname", ""];
        if (_className isEqualTo "") exitWith {
            _self call ["sendEvent", ["garage::retrieve::failure", createHashMapFromArray [
                ["message", "Stored vehicle record is missing a classname."]
            ]]];
        };

        private _vehicle = createVehicle [_className, _spawnPosition, [], 0, "CAN_COLLIDE"];
        _vehicle setDir _spawnHeading;
        _vehicle setFuel (_vehicleData getOrDefault ["fuel", 0]);
        _vehicle setDamage (_vehicleData getOrDefault ["damage", 0]);

        private _hitPoints = _vehicleData getOrDefault ["hit_points", createHashMap];
        private _hitPointNames = _hitPoints getOrDefault ["names", []];
        private _hitPointValues = _hitPoints getOrDefault ["values", []];
        for "_index" from 0 to ((count _hitPointNames) - 1) do {
            _vehicle setHitPointDamage [_hitPointNames param [_index, ""], _hitPointValues param [_index, 0]];
        };

        _vehicle setVariable ["forge_garage_plate", _plate, true];
        _vehicle setVariable ["forge_garage_owner_uid", getPlayerUID player, true];

        _self set ["pendingRetrieve", createHashMapFromArray [
            ["plate", _plate],
            ["vehicle", _vehicle]
        ]];

        [SRPC(garage,requestRetrieveVehicle), [getPlayerUID player, _plate]] call CFUNC(serverEvent);
    }],
    ["handleStoreRequest", compileFinal {
        params [["_data", createHashMap, [createHashMap]]];

        private _netId = _data getOrDefault ["netId", ""];
        if (_netId isEqualTo "") exitWith {
            _self call ["sendEvent", ["garage::store::failure", createHashMapFromArray [
                ["message", "Select a nearby vehicle to store."]
            ]]];
        };

        private _vehicle = objectFromNetId _netId;
        if (isNull _vehicle) exitWith {
            _self call ["sendEvent", ["garage::store::failure", createHashMapFromArray [
                ["message", "The selected vehicle is no longer available."]
            ]]];
        };

        if (crew _vehicle isNotEqualTo []) exitWith {
            _self call ["sendEvent", ["garage::store::failure", createHashMapFromArray [
                ["message", "All crew must exit the vehicle before storing it."]
            ]]];
        };

        private _rawHitPoints = getAllHitPointsDamage _vehicle;
        private _hitPointsJson = toJSON (createHashMapFromArray [
            ["names", _rawHitPoints param [0, []]],
            ["selections", _rawHitPoints param [1, []]],
            ["values", _rawHitPoints param [2, []]]
        ]);

        _self set ["pendingStoreVehicle", _vehicle];
        [SRPC(garage,requestStoreVehicle), [
            getPlayerUID player,
            typeOf _vehicle,
            fuel _vehicle,
            damage _vehicle,
            _hitPointsJson
        ]] call CFUNC(serverEvent);
    }],
    ["handleActionResponse", compileFinal {
        params [["_payload", createHashMap, [createHashMap]]];

        private _action = _payload getOrDefault ["action", ""];
        private _success = _payload getOrDefault ["success", false];
        private _message = _payload getOrDefault ["message", "Garage action failed."];

        switch (_action) do {
            case "retrieve": {
                private _pendingRetrieve = _self getOrDefault ["pendingRetrieve", createHashMap];
                private _vehicle = _pendingRetrieve getOrDefault ["vehicle", objNull];

                if (!_success && { !isNull _vehicle }) then {
                    deleteVehicle _vehicle;
                };

                _self set ["pendingRetrieve", createHashMap];
                _self call ["sendEvent", [[
                    "garage::retrieve::failure",
                    "garage::retrieve::success"
                ] select _success, createHashMapFromArray [["message", _message]]]];
            };
            case "store": {
                private _vehicle = _self getOrDefault ["pendingStoreVehicle", objNull];

                if (_success && { !isNull _vehicle }) then {
                    deleteVehicle _vehicle;
                };

                _self set ["pendingStoreVehicle", objNull];
                _self call ["sendEvent", [[
                    "garage::store::failure",
                    "garage::store::success"
                ] select _success, createHashMapFromArray [["message", _message]]]];
            };
        };

        [] spawn {
            sleep 0.05;
            if !(isNil QGVAR(GarageUIBridge)) then {
                GVAR(GarageUIBridge) call ["refreshGarage", []];
            };
        };
    }]
];

GVAR(GarageUIBridge) = createHashMapObject [GVAR(GarageUIBridgeBaseClass)];
GVAR(GarageUIBridge)