<?php

namespace Bitrix\Bizproc\Api\Service;

use Bitrix\Bizproc\Api\Data\TaskService\TasksToGet;
use Bitrix\Bizproc\Api\Data\TaskService\TasksToBeDelegated;
use Bitrix\Bizproc\Api\Request\TaskService\DelegateTasksRequest;
use Bitrix\Bizproc\Api\Request\TaskService\DoInlineTasksRequest;
use Bitrix\Bizproc\Api\Request\TaskService\DoTaskRequest;
use Bitrix\Bizproc\Api\Request\TaskService\GetUserTaskRequest;
use Bitrix\Bizproc\Api\Request\TaskService\GetUserTaskListRequest;
use Bitrix\Bizproc\Api\Request\TaskService\GetUserTaskByWorkflowIdRequest;
use Bitrix\Bizproc\Api\Response;
use Bitrix\Bizproc\Api\Response\TaskService\DelegateTasksResponse;
use Bitrix\Bizproc\Api\Response\TaskService\GetUserTaskListResponse;
use Bitrix\Bizproc\Api\Response\TaskService\GetUserTaskByWorkflowIdResponse;
use Bitrix\Bizproc\Result;
use Bitrix\Bizproc\Workflow\Task\TaskTable;
use Bitrix\Main\ArgumentException;
use Bitrix\Main\ArgumentOutOfRangeException;
use Bitrix\Main\Error;
use Bitrix\Main\Localization\Loc;

class TaskService
{
	private const TASK_ALREADY_DONE_ERROR_CODE = 'TASK_ALREADY_DONE';
	private const TASK_USER_NOT_MEMBER_ERROR_CODE = 'TASK_USER_NOT_MEMBER';
	private const TASK_NOT_FOUND_ERROR_CODE = 'TASK_NOT_FOUND';

	public function __construct(
		private TaskAccessService $accessService
	)
	{}

	public function delegateTasks(DelegateTasksRequest $request): DelegateTasksResponse
	{
		$delegateResponse = new DelegateTasksResponse();

		$tasksToDelegate = null;
		try
		{
			$tasksToDelegate = TasksToBeDelegated::createFromRequest($request);
		}
		catch (ArgumentOutOfRangeException $e)
		{
			$errorMessage =
				in_array($e->getParameter(), ['fromUserId', 'toUserId'], true)
					? Loc::getMessage('BIZPROC_LIB_API_TASK_SERVICE_DELEGATE_TASK_ERROR_INCORRECT_USER_ID')
					: $e->getMessage()
			;
			$delegateResponse->addError(new Error($errorMessage));
		}
		catch (ArgumentException $e)
		{
			$delegateResponse->addError(
				new Error(Loc::getMessage('BIZPROC_LIB_API_TASK_SERVICE_DELEGATE_TASK_ERROR_NO_TASKS'))
			);
		}
		if (!$tasksToDelegate || !$delegateResponse->isSuccess())
		{
			return $delegateResponse;
		}

		$checkAccessResult = $this->accessService->checkDelegateTask(
			$tasksToDelegate->getToUserId(),
			$tasksToDelegate->getFromUserId()
		);
		if (!$checkAccessResult->isSuccess())
		{
			return $delegateResponse->addErrors($checkAccessResult->getErrors());
		}

		$allowedDelegationType = $checkAccessResult->getAllowedDelegationTypes();

		$errors = [];
		$isDelegated = \CBPDocument::delegateTasks(
			$tasksToDelegate->getFromUserId(),
			$tasksToDelegate->getToUserId(),
			$tasksToDelegate->getTaskIds(),
			$errors,
			$allowedDelegationType
		);

		if (!$isDelegated && !$errors)
		{
			$errors = [Loc::getMessage('BIZPROC_LIB_API_TASK_SERVICE_DELEGATE_TASK_ERROR_TASKS_NOT_FOUND')];
		}
		foreach ($errors as $errorMessage)
		{
			$delegateResponse->addError(new Error($errorMessage));
		}

		if ($delegateResponse->isSuccess())
		{
			$delegateResponse->setData([
				'successMessage' => Loc::getMessage(
					'BIZPROC_LIB_API_TASK_SERVICE_DELEGATE_TASK_SUCCESS_MESSAGE',
					['#USER_NAME#' => \CBPHelper::convertUserToPrintableForm($tasksToDelegate->getToUserId(), '', false)]
				),
			]);
		}

		return $delegateResponse;
	}

	public function getTasks(GetUserTaskListRequest $request): GetUserTaskListResponse
	{
		$getTasksResponse = new GetUserTaskListResponse();

		$tasksToGet = null;
		try
		{
			$tasksToGet = TasksToGet::createFromRequest($request);
		}
		catch (ArgumentOutOfRangeException $exception)
		{
			// todo: user friendly error message
			// use ::createError?
			$getTasksResponse->addError(new Error($exception->getMessage()));
		}
		if (!$tasksToGet || !$getTasksResponse->isSuccess())
		{
			return $getTasksResponse;
		}

		$checkAccessResult = $this->accessService->checkViewTasks($tasksToGet->getTargetUserId());
		if (!$checkAccessResult->isSuccess())
		{
			return $getTasksResponse->addErrors($checkAccessResult->getErrors());
		}

		$tasksIterator = \CBPTaskService::getList(
			$tasksToGet->getSort(),
			$tasksToGet->getFilter(),
			false,
			[
				'nPageSize' => $tasksToGet->getLimit(),
				'iNumPage' => (int)($tasksToGet->getOffset() / $tasksToGet->getLimit()) + 1,
			],
			$tasksToGet->buildSelectFields()
		);
		$taskList = [];
		while ($task = $tasksIterator->fetch())
		{
			$taskList[] = $this->prepareTaskInfo($task, $tasksToGet->getTargetUserId());
		}

		return $getTasksResponse->setData(['tasks' => $taskList]);
	}

	public function doTask(DoTaskRequest $request)
	{
		$result = new Response\TaskService\DoTaskResponse();
		$task = false;

		$checkAccessResult = $this->accessService->checkDoTasks($request->userId);
		if (!$checkAccessResult->isSuccess())
		{
			return $result->addErrors($checkAccessResult->getErrors());
		}

		if ($request->taskId > 0)
		{
			$task = \CBPTaskService::GetList(
				[],
				[
					'ID' => $request->taskId,
					'USER_ID' => $request->userId
				],
				false,
				false,
				[
					'ID',
					'WORKFLOW_ID',
					'ACTIVITY',
					'ACTIVITY_NAME',
					'MODIFIED',
					'OVERDUE_DATE',
					'NAME',
					'DESCRIPTION',
					'PARAMETERS',
					'USER_STATUS',
				]
			)->fetch();
		}

		if (!$task)
		{
			$this->addUserTaskNotFoundError($result, $request->taskId, $request->userId);

			return $result;
		}

		if ((int)$task['USER_STATUS'] !== \CBPTaskUserStatus::Waiting)
		{
			return $result->addError(
				new Error(
					Loc::getMessage('BIZPROC_LIB_API_TASK_SERVICE_DO_TASK_ERROR_ALREADY_DONE'),
					self::TASK_ALREADY_DONE_ERROR_CODE
				)
			);
		}

		$task['PARAMETERS']['DOCUMENT_ID'] = \CBPStateService::GetStateDocumentId($task['WORKFLOW_ID']);
		$task['MODULE_ID'] = $task['PARAMETERS']['DOCUMENT_ID'][0];
		$task['ENTITY'] = $task['PARAMETERS']['DOCUMENT_ID'][1];
		$task['DOCUMENT_ID'] = $task['PARAMETERS']['DOCUMENT_ID'][2];

		if (!\CBPDocument::PostTaskForm($task, $request->userId, $request->taskRequest, $errors))
		{
			$error = reset($errors);
			if ($task['MODULE_ID'] === 'rpa' && $error['code'] === \CBPRuntime::EXCEPTION_CODE_INSTANCE_TERMINATED)
			{
				return $result;
			}

			if (!empty($error['customData']))
			{
				foreach ($errors as $error)
				{
					$result->addError(new Error($error['message'], 0, $error['customData']));
				}

				return $result;
			}

			$result->addError(new Error($error['message']));
		}

		return $result;
	}

	public function doInlineTasks(DoInlineTasksRequest $request): Response\TaskService\DoInlineTaskResponse
	{
		$taskIds = [];
		foreach ($request->taskIds as $id)
		{
			// TODO - throw argument or return error if $id not integer?
			if (is_int($id))
			{
				$taskIds[] = $id;
			}
		}

		$result = new Response\TaskService\DoInlineTaskResponse();
		if ($taskIds)
		{
			$errors = [];
			\CBPDocument::setTasksUserStatus($request->userId, $request->newTaskStatusId, $taskIds, $errors);

			if ($errors)
			{
				foreach ($errors as $errorMessage)
				{
					$result->addError(new \Bitrix\Bizproc\Error($errorMessage));
				}
			}
		}

		return $result;
	}

	public function getUserTask(GetUserTaskRequest $request): Response\TaskService\GetUserTaskResponse
	{
		$response = new Response\TaskService\GetUserTaskResponse();

		if ($request->taskId <= 0 || $request->userId <= 0)
		{
			$this->addUserTaskNotFoundError($response, 0, $request->userId);

			return $response;
		}

		$checkAccessResult = $this->accessService->checkViewTasks($request->userId);
		if (!$checkAccessResult->isSuccess())
		{
			return $response->addErrors($checkAccessResult->getErrors());
		}

		$task = \CBPTaskService::getList(
			[],
			['ID' => $request->taskId, 'USER_ID' => $request->userId],
			false,
			false,
			[
				'ID',
				'USER_ID',
				'NAME',
				'DESCRIPTION',
				'WORKFLOW_ID',
				'ACTIVITY',
				'STATUS',
				'USER_STATUS',
				'IS_INLINE',
				'PARAMETERS',
				'DELEGATION_TYPE',
			],
		)->fetch();

		if (!$task)
		{
			$this->addUserTaskNotFoundError($response, $request->taskId, $request->userId);

			return $response;
		}

		$task = $this->prepareTaskInfo($task, $request->userId);

		return $response->setTask($task);
	}

	public function getUserTaskByWorkflowId(GetUserTaskByWorkflowIdRequest $request): GetUserTaskByWorkflowIdResponse
	{
		$response = new GetUserTaskByWorkflowIdResponse();
		$renderer = new \Bitrix\Bizproc\Controller\Response\RenderControlCollectionContent();
		$task = false;
		$taskQuery = null;

		if ($request->workflowId)
		{
			$taskQuery =
				\Bitrix\Bizproc\Workflow\Task\TaskTable::query()
					->setSelect([
						'ID',
						'ACTIVITY',
						'ACTIVITY_NAME',
						'NAME',
						'DESCRIPTION',
						'PARAMETERS',
						'TEMPLATE_ID' => 'WORKFLOW_STATE.WORKFLOW_TEMPLATE_ID',
					])
					->setFilter([
						'=WORKFLOW_ID' => $request->workflowId,
						'=TASK_USERS.USER_ID' => $request->userId,
						'=TASK_USERS.STATUS' => \CBPTaskUserStatus::Waiting,
					])
					->setOrder(['ID' => 'DESC'])
					->exec()
			;
			$task = $taskQuery->fetch();
		}

		if (!$task)
		{
			$response->setContent($renderer);

			return $response;
		}

		$task['saveVariables'] = $task['PARAMETERS']['SaveVariables'] ?? false;
		$controls = \CBPDocument::getTaskControls($task, $request->userId);

		$task['BUTTONS'] = $controls['BUTTONS'] ?? null;
		$task['FIELDS'] = $controls['FIELDS'] ?? null;
		if (isset($task['DESCRIPTION']))
		{
			$task['DESCRIPTION'] = \CBPViewHelper::prepareTaskDescription(
				\CBPHelper::convertBBtoText(
					preg_replace('|\n+|', "\n", trim($task['DESCRIPTION']))
				)
			);
		}

		if ($taskQuery?->fetch())
		{
			$task['IS_LAST_TASK_FOR_USER'] = false;
		}
		else
		{
			$task['IS_LAST_TASK_FOR_USER'] = \CBPTaskService::isLastTaskForUserByActivity(
				$task['ACTIVITY_NAME'],
				$request->userId,
				$task['TEMPLATE_ID']
			);
		}
		$response->setTask($task);

		$documentService = \CBPRuntime::getRuntime()->getDocumentService();
		$documentType = $documentService->getDocumentType($task['PARAMETERS']['DOCUMENT_ID']);
		if (isset($task['FIELDS']) && is_array($task['FIELDS']))
		{
			foreach ($task['FIELDS'] as $parameter)
			{
				$params['Field'] = $parameter['FieldId'] ?? $parameter['Id'];
				$params['Value'] = $parameter['Default'] ?? null;
				$params['Als'] = false;
				$params['RenderMode'] = 'public';

				$renderer->addProperty($documentType, $parameter, $params);
			}
		}
		$response->setContent($renderer);

		return $response;
	}

	private function addUserTaskNotFoundError(Result $response, int $taskId, int $userId): void
	{
		if ($taskId > 0)
		{
			$task = TaskTable::getByPrimary($taskId)->fetch();
			if ($task)
			{
				if ((int)$task['STATUS'] !== \CBPTaskStatus::Running)
				{
					$response->addError(
						new Error(
							Loc::getMessage('BIZPROC_LIB_API_TASK_SERVICE_ERROR_TASK_ALREADY_DONE'),
							self::TASK_ALREADY_DONE_ERROR_CODE
						)
					);
				}
				elseif ($this->accessService->isCurrentUser($userId))
				{
					$response->addError(
						new Error(
							Loc::getMessage('BIZPROC_LIB_API_TASK_SERVICE_ERROR_CURRENT_USER_NOT_MEMBER'),
							self::TASK_USER_NOT_MEMBER_ERROR_CODE,
						)
					);
				}
				else
				{
					$response->addError(
						new Error(
							Loc::getMessage('BIZPROC_LIB_API_TASK_SERVICE_ERROR_TARGET_USER_NOT_MEMBER'),
							self::TASK_USER_NOT_MEMBER_ERROR_CODE,
						)
					);
				}

				return;
			}
		}

		$response->addError(
			new Error(
				Loc::getMessage('BIZPROC_LIB_API_TASK_SERVICE_DO_TASK_ERROR_NO_TASK'),
				self::TASK_NOT_FOUND_ERROR_CODE
			)
		);
	}

	private function prepareTaskInfo(array $task, int $userId = 0): array
	{
		$task['STATUS'] = (int)$task['STATUS'];

		if (isset($task['MODIFIED']))
		{
			$task['MODIFIED'] = FormatDateFromDB($task['MODIFIED']);
		}

		$documentId =
			is_array($task['PARAMETERS']['DOCUMENT_ID'] ?? null)
				? $task['PARAMETERS']['DOCUMENT_ID']
				: null
		;
		$task['DOCUMENT_URL'] = $documentId ? \CBPDocument::getDocumentAdminPage($documentId) : '';

		$task['MODULE_ID'] = $documentId ? $documentId[0] : '';
		$task['ENTITY'] = $documentId ? $documentId[1] : '';
		$task['DOCUMENT_ID'] = $documentId ? $documentId[2] : '';
		$task['COMPLEX_DOCUMENT_ID'] = $documentId;

		if (isset($task['WORKFLOW_TEMPLATE_NAME']))
		{
			$task['WORKFLOW_NAME'] = $task['WORKFLOW_TEMPLATE_NAME']; // compatibility
		}
		if (isset($task['WORKFLOW_STARTED']))
		{
			$task['WORKFLOW_STARTED'] = FormatDateFromDB($task['WORKFLOW_STARTED']);
		}

		$controls = \CBPDocument::getTaskControls($task, $userId);

		$task['BUTTONS'] = $controls['BUTTONS'] ?? null;
		$task['FIELDS'] = $controls['FIELDS'] ?? null;

		if (isset($task['DELEGATION_TYPE']))
		{
			$task['DELEGATION_TYPE'] = (int)$task['DELEGATION_TYPE'];
		}

		return $task;
	}
}