#include "..\script_component.hpp"

/*
 * File: fnc_initAssignmentRepository.sqf
 * Author: IDSolutions
 * Date: 2026-03-30
 * Public: No
 *
 * Description:
 * Initializes the CAD assignment repository for contract assignment
 * state and dispatcher/group-leader task actions.
 *
 * Arguments:
 * None
 *
 * Return Value:
 * CAD assignment repository object [HASHMAP OBJECT]
 *
 * Example:
 * call forge_server_cad_fnc_initAssignmentRepository
 */

#pragma hemtt ignore_variables ["_self"]
GVAR(AssignmentRepositoryBaseClass) = compileFinal createHashMapFromArray [
    ["#type", "CadAssignmentRepositoryBaseClass"],
    ["#create", compileFinal {
        _self set ["assignmentRegistry", createHashMap];
    }],
    ["pruneAssignments", compileFinal {
        private _assignmentRegistry = _self getOrDefault ["assignmentRegistry", createHashMap];
        private _keysToRemove = [];

        {
            private _status = EGVAR(task,TaskStore) call ["getTaskStatus", [_x]];
            if !(_status in ["active", ""]) then {
                _keysToRemove pushBack _x;
            };
        } forEach _assignmentRegistry;

        {
            _assignmentRegistry deleteAt _x;
        } forEach _keysToRemove;

        _self set ["assignmentRegistry", _assignmentRegistry];
        count _keysToRemove
    }],
    ["getAssignments", compileFinal {
        values (_self getOrDefault ["assignmentRegistry", createHashMap])
    }],
    ["buildContracts", compileFinal {
        params [["_uid", "", [""]]];

        _self call ["pruneAssignments", []];

        private _assignmentRegistry = _self getOrDefault ["assignmentRegistry", createHashMap];
        private _contracts = [];
        private _permissionService = _self getOrDefault ["permissionService", createHashMap];
        private _groupRepository = _self getOrDefault ["groupRepository", createHashMap];
        private _canDispatch = _permissionService call ["canDispatch", [_uid]];
        private _playerGroupId = _groupRepository call ["getPlayerGroupId", [_uid]];

        {
            private _taskID = _x getOrDefault ["taskID", ""];
            if (_taskID isEqualTo "") then { continue; };

            private _assignment = _assignmentRegistry getOrDefault [_taskID, createHashMap];
            private _entry = +_x;
            _entry set ["taskId", _taskID];
            _entry set ["assignedGroupId", _assignment getOrDefault ["groupId", ""]];
            _entry set ["assignmentState", [_assignment getOrDefault ["state", ""], "unassigned"] select (_assignment isEqualTo createHashMap)];

            if (!_canDispatch) then {
                private _assignedGroupId = _entry getOrDefault ["assignedGroupId", ""];
                if (_assignedGroupId isEqualTo "") then { continue; };
                if (_assignedGroupId isNotEqualTo _playerGroupId) then { continue; };
            };

            _contracts pushBack _entry;
        } forEach (EGVAR(task,TaskStore) call ["getActiveTaskCatalog", []]);

        _contracts
    }],
    ["assignTaskToGroup", compileFinal {
        params [
            ["_requesterUid", "", [""]],
            ["_taskID", "", [""]],
            ["_groupID", "", [""]],
            ["_note", "", [""]]
        ];

        private _result = createHashMapFromArray [
            ["success", false],
            ["message", "Unable to assign task."],
            ["assignment", createHashMap]
        ];

        private _permissionService = _self getOrDefault ["permissionService", createHashMap];
        if !(_permissionService call ["canDispatch", [_requesterUid]]) exitWith {
            _result set ["message", "You are not authorized to assign contracts."];
            _result
        };

        if ((EGVAR(task,TaskStore) call ["getTaskStatus", [_taskID]]) isNotEqualTo "active") exitWith {
            _result set ["message", "Task is no longer active."];
            _result
        };

        private _groupRepository = _self getOrDefault ["groupRepository", createHashMap];
        private _groupRecord = _groupRepository call ["getGroupRecord", [_groupID]];
        if (_groupRecord isEqualTo createHashMap) exitWith {
            _result set ["message", "Selected group is unavailable."];
            _result
        };

        private _leaderUid = _groupRecord getOrDefault ["leaderUid", ""];
        if (_leaderUid isEqualTo "") exitWith {
            _result set ["message", "Selected group has no online leader."];
            _result
        };

        private _requesterPlayer = [_requesterUid] call EFUNC(common,getPlayer);
        private _assignmentRegistry = _self getOrDefault ["assignmentRegistry", createHashMap];
        private _assignment = createHashMapFromArray [
            ["taskId", _taskID],
            ["groupId", _groupID],
            ["assignedByUid", _requesterUid],
            ["assignedByName", ["Dispatcher", name _requesterPlayer] select (_requesterPlayer isNotEqualTo objNull)],
            ["assignedAt", serverTime],
            ["state", "assigned"],
            ["note", _note]
        ];

        _assignmentRegistry set [_taskID, _assignment];
        _self set ["assignmentRegistry", _assignmentRegistry];

        private _activityRepository = _self getOrDefault ["activityRepository", createHashMap];
        _activityRepository call ["appendActivity", [
            "task_assigned",
            format ["%1 assigned %2 to %3.", _assignment get "assignedByName", _taskID, _groupRecord getOrDefault ["callsign", _groupID]],
            _taskID,
            _groupID,
            _requesterUid
        ]];

        _result set ["success", true];
        _result set ["message", "Task assigned."];
        _result set ["assignment", _assignment];
        _result set ["leaderUid", _leaderUid];
        _result
    }],
    ["acknowledgeTask", compileFinal {
        params [["_requesterUid", "", [""]], ["_taskID", "", [""]]];

        private _result = createHashMapFromArray [
            ["success", false],
            ["message", "Unable to acknowledge task."],
            ["assignment", createHashMap]
        ];

        private _assignmentRegistry = _self getOrDefault ["assignmentRegistry", createHashMap];
        private _assignment = +(_assignmentRegistry getOrDefault [_taskID, createHashMap]);
        if (_assignment isEqualTo createHashMap) exitWith {
            _result set ["message", "Task is not assigned."];
            _result
        };

        private _groupID = _assignment getOrDefault ["groupId", ""];
        private _groupRepository = _self getOrDefault ["groupRepository", createHashMap];
        if !(_groupRepository call ["isGroupLeader", [_requesterUid, _groupID]]) exitWith {
            _result set ["message", "Only the assigned group leader can acknowledge this task."];
            _result
        };

        private _bindResult = EGVAR(task,TaskStore) call ["bindTaskOwnership", [_taskID, _requesterUid]];
        if !(_bindResult getOrDefault ["success", false]) exitWith {
            _result set ["message", _bindResult getOrDefault ["message", "Failed to bind task ownership."]];
            _result
        };

        _assignment set ["state", "acknowledged"];
        _assignment set ["acknowledgedAt", serverTime];
        _assignmentRegistry set [_taskID, _assignment];
        _self set ["assignmentRegistry", _assignmentRegistry];

        private _activityRepository = _self getOrDefault ["activityRepository", createHashMap];
        _activityRepository call ["appendActivity", [
            "task_acknowledged",
            format ["%1 acknowledged %2.", _requesterUid, _taskID],
            _taskID,
            _groupID,
            _requesterUid
        ]];

        _result set ["success", true];
        _result set ["message", "Task acknowledged."];
        _result set ["assignment", _assignment];
        _result
    }],
    ["declineTask", compileFinal {
        params [["_requesterUid", "", [""]], ["_taskID", "", [""]]];

        private _result = createHashMapFromArray [
            ["success", false],
            ["message", "Unable to decline task."],
            ["assignment", createHashMap]
        ];

        private _assignmentRegistry = _self getOrDefault ["assignmentRegistry", createHashMap];
        private _assignment = +(_assignmentRegistry getOrDefault [_taskID, createHashMap]);
        if (_assignment isEqualTo createHashMap) exitWith {
            _result set ["message", "Task is not assigned."];
            _result
        };

        private _groupID = _assignment getOrDefault ["groupId", ""];
        private _groupRepository = _self getOrDefault ["groupRepository", createHashMap];
        if !(_groupRepository call ["isGroupLeader", [_requesterUid, _groupID]]) exitWith {
            _result set ["message", "Only the assigned group leader can decline this task."];
            _result
        };

        _assignment set ["state", "declined"];
        _assignment set ["declinedAt", serverTime];
        _assignmentRegistry deleteAt _taskID;
        _self set ["assignmentRegistry", _assignmentRegistry];

        private _activityRepository = _self getOrDefault ["activityRepository", createHashMap];
        _activityRepository call ["appendActivity", [
            "task_declined",
            format ["%1 declined %2.", _requesterUid, _taskID],
            _taskID,
            _groupID,
            _requesterUid
        ]];

        _result set ["success", true];
        _result set ["message", "Task declined and returned to the contract board."];
        _result set ["assignment", _assignment];
        _result
    }]
];

createHashMapObject [GVAR(AssignmentRepositoryBaseClass)]