<?php

namespace Bitrix\Bizproc\Controller\Workflow;

use Bitrix\Bizproc\Api\Request\WorkflowTemplateService\PrepareParametersRequest;
use Bitrix\Bizproc\Api\Request\WorkflowTemplateService\PrepareStartParametersRequest;
use Bitrix\Bizproc\Api\Request\WorkflowTemplateService\SetConstantsRequest;
use Bitrix\Bizproc\Api\Request\WorkflowService\StartWorkflowRequest;
use Bitrix\Bizproc\Api\Service\WorkflowService;
use Bitrix\Bizproc\Api\Service\WorkflowTemplateService;
use Bitrix\Bizproc\Error;
use Bitrix\Main\Localization\Loc;

class Starter extends \Bitrix\Bizproc\Controller\Base
{
	public function getTemplatesAction(): ?array
	{
		if (!$this->checkBizprocFeature())
		{
			return null;
		}

		$complexDocumentType = $this->getComplexDocumentType();
		if (!$complexDocumentType)
		{
			return null;
		}

		$complexDocumentId = null;
		if ($this->getRequest()->get('signedDocumentId'))
		{
			$complexDocumentId = $this->getComplexDocumentId();
			if (!$complexDocumentId)
			{
				return null;
			}

			if (!$this->checkDocumentTypeMatchDocumentId($complexDocumentType, $complexDocumentId))
			{
				return null;
			}
		}

		return [
			'templates' => (
				\CBPDocument::getTemplatesForStart($this->getCurrentUserId(), $complexDocumentType, $complexDocumentId)
			),
		];
	}

	public function startWorkflowAction(int $templateId, ?int $startDuration = null): ?array
	{
		if (!$this->checkBizprocFeature())
		{
			return null;
		}

		$complexDocumentType = $this->getComplexDocumentType();
		if (!$complexDocumentType)
		{
			return null;
		}

		$complexDocumentId = $this->getComplexDocumentId();
		if (!$complexDocumentId)
		{
			return null;
		}

		if (!$this->checkDocumentTypeMatchDocumentId($complexDocumentType, $complexDocumentId))
		{
			return null;
		}

		$templateService = new WorkflowTemplateService();
		$workflowParameters = $templateService->prepareStartParameters(
			new PrepareStartParametersRequest(
				templateId: $templateId,
				complexDocumentType: $complexDocumentType,
				requestParameters: array_merge(
					$this->getRequest()->toArray(),
					$this->getRequest()->getFileList()->toArray()
				),
				targetUserId: $this->getCurrentUserId(),
			)
		);

		if (!$workflowParameters->isSuccess())
		{
			$this->addErrors($workflowParameters->getErrors());

			return null;
		}

		$workflowService = new WorkflowService();
		$startWorkflow = $workflowService->startWorkflow(
			new StartWorkflowRequest(
				userId: $this->getCurrentUserId(),
				targetUserId: $this->getCurrentUserId(),
				templateId: $templateId,
				complexDocumentId: $complexDocumentId,
				parameters: $workflowParameters->getParameters(),
				startDuration: $startDuration >= 0 ? $startDuration : null,
			)
		);

		if (!$startWorkflow->isSuccess())
		{
			$this->addErrors($startWorkflow->getErrors());

			return null;
		}

		return ['workflowId' => $startWorkflow->getWorkflowId()];
	}

	public function checkParametersAction(int $autoExecuteType): ?array
	{
		if (!$this->checkBizprocFeature())
		{
			return null;
		}

		if ($autoExecuteType < 0)
		{
			$this->addError(new Error(
				Loc::getMessage('BIZPROC_LIB_API_CONTROLLER_WORKFLOW_STARTER_ERROR_INCORRECT_AUTO_EXECUTE_TYPE') ?? ''
			));

			return null;
		}

		$parametersDocumentType = $this->getComplexDocumentType();
		if (!$parametersDocumentType)
		{
			return null;
		}

		$canStart = false;
		if ($this->getRequest()->get('signedDocumentId'))
		{
			$canStart = \CBPDocument::canUserOperateDocument(
				\CBPCanUserOperateOperation::StartWorkflow,
				$this->getCurrentUserId(),
				$this->getComplexDocumentId(),
			);
		}

		if (!$canStart
			&& !\CBPDocument::canUserOperateDocumentType(
				\CBPCanUserOperateOperation::StartWorkflow,
				$this->getCurrentUserId(),
				$parametersDocumentType,
			)
		)
		{
			$this->addError(new Error(
				Loc::getMessage('BIZPROC_LIB_API_CONTROLLER_WORKFLOW_STARTER_ERROR_ACCESS_DENIED') ?? ''
			));

			return null;
		}

		$parameters = [];
		$hasErrors = false;
		foreach (\CBPWorkflowTemplateLoader::getDocumentTypeStates($parametersDocumentType, $autoExecuteType) as $template)
		{
			if (is_array($template['TEMPLATE_PARAMETERS']) && $template['TEMPLATE_PARAMETERS'])
			{
				$parameters[$template['TEMPLATE_ID']] =
					$this->prepareWorkflowParameters(
						$template['TEMPLATE_PARAMETERS'],
						$parametersDocumentType,
						"bizproc{$template['TEMPLATE_ID']}_",
					)
				;

				if ($parameters[$template['TEMPLATE_ID']] === null)
				{
					$hasErrors = true;
				}
			}
		}

		if ($hasErrors)
		{
			return null;
		}

		return ['parameters' => \CBPDocument::signParameters($parameters)];
	}

	public function setConstantsAction(int $templateId): ?array
	{
		if (!$this->checkBizprocFeature())
		{
			return null;
		}

		$parametersDocumentType = $this->getComplexDocumentType();
		if (!$parametersDocumentType)
		{
			return null;
		}

		$request = $this->getRequest();

		$response =
			(new WorkflowTemplateService())
				->setConstants(
					new SetConstantsRequest(
						templateId: $templateId,
						requestConstants: array_merge($request->toArray(), $request->getFileList()->toArray()),
						complexDocumentType: $parametersDocumentType,
						userId: $this->getCurrentUserId(),
					)
				)
		;

		if ($response->isSuccess())
		{
			return ['success' => true];
		}

		$this->addErrors($response->getErrors());

		return null;
	}

	private function getComplexDocumentType(): ?array
	{
		$request = $this->getRequest();

		$signedDocumentType = $request->get('signedDocumentType');
		if (!is_string($signedDocumentType))
		{
			$this->addError(new Error(
				Loc::getMessage('BIZPROC_LIB_API_CONTROLLER_WORKFLOW_STARTER_ERROR_INCORRECT_DOCUMENT_TYPE') ?? ''
			));

			return null;
		}

		$parametersDocumentType = \CBPDocument::unSignDocumentType($signedDocumentType);

		try
		{
			\CBPHelper::parseDocumentId($parametersDocumentType);
		}
		catch (\CBPArgumentNullException $e)
		{
			$this->addError(Error::createFromThrowable($e));

			return null;
		}

		return $parametersDocumentType;
	}

	private function getComplexDocumentId(): ?array
	{
		$request = $this->getRequest();

		$signedDocumentId = $request->get('signedDocumentId');
		if (!is_string($signedDocumentId))
		{
			$this->addError(new Error(
				Loc::getMessage('BIZPROC_LIB_API_CONTROLLER_WORKFLOW_STARTER_ERROR_INCORRECT_DOCUMENT_ID') ?? ''
			));

			return null;
		}

		$parametersDocumentId = \CBPDocument::unSignDocumentType($signedDocumentId);

		try
		{
			\CBPHelper::parseDocumentId($parametersDocumentId);
		}
		catch (\CBPArgumentNullException $e)
		{
			$this->addError(Error::createFromThrowable($e));

			return null;
		}

		return $parametersDocumentId;
	}

	private function checkDocumentTypeMatchDocumentId(array $parametersDocumentType, array $parametersDocumentId): bool
	{
		if (
			$parametersDocumentType[0] === $parametersDocumentId[0]
			&& $parametersDocumentType[1] === $parametersDocumentId[1]
		)
		{
			return true;
		}

		$this->addError(new Error(
			Loc::getMessage('BIZPROC_LIB_API_CONTROLLER_WORKFLOW_STARTER_ERROR_DOC_TYPE_DONT_MATCH_DOC_ID') ?? ''
		));

		return false;
	}

	private function checkBizprocFeature(): bool
	{
		if (!\CBPRuntime::isFeatureEnabled())
		{
			$this->addError(new Error(
				Loc::getMessage('BIZPROC_LIB_API_CONTROLLER_WORKFLOW_STARTER_ERROR_BIZPROC_FEATURE_DISABLED') ?? '')
			);

			return false;
		}

		return true;
	}

	private function getCurrentUserId(): int
	{
		return (int)($this->getCurrentUser()?->getId());
	}

	private function prepareWorkflowParameters(
		array $templateParameters,
		array $parametersDocumentType,
		string $keyPrefix = '',
	): ?array
	{
		$request = $this->getRequest();
		$allRequestParameters = array_merge($request->toArray(), $request->getFileList()->toArray());

		$requestParameters = [];
		foreach($templateParameters as $key => $property)
		{
			$searchKey = $keyPrefix . $key;
			$requestParameters[$key] = $allRequestParameters[$searchKey] ?? null;
		}

		$parameters = (new WorkflowTemplateService())
			->prepareParameters(
				new PrepareParametersRequest(
					templateParameters: $templateParameters,
					requestParameters: $requestParameters,
					complexDocumentType: $parametersDocumentType,
				)
			)
		;

		if ($parameters->isSuccess())
		{
			return $parameters->getParameters();
		}

		$this->addErrors($parameters->getErrors());

		return null;
	}
}