<?php

namespace Bitrix\Bizproc\UI;

use Bitrix\Bizproc\Workflow\Entity\WorkflowUserCommentTable;
use Bitrix\Bizproc\Workflow\WorkflowState;
use Bitrix\Bizproc\WorkflowInstanceTable;
use Bitrix\Main\EO_User;
use Bitrix\Main\SystemException;
use Bitrix\Main\Type\Collection;
use Bitrix\Main\Type\DateTime;
use Bitrix\Main\UserTable;

class WorkflowUserView implements \JsonSerializable
{
	protected WorkflowState $workflow;
	private array $tasks;
	private array $myRunningTasks;
	private array $myCompletedTasks;
	protected int $userId;

	protected ?WorkflowFacesView $faces = null;
	protected ?bool $isCompleted = null;

	public function __construct(WorkflowState $workflow, int $userId)
	{
		$this->workflow = $workflow;
		$this->userId = $userId;

		$this->tasks = \CBPViewHelper::getWorkflowTasks($workflow['ID'], true, true);
		$this->myRunningTasks = $this->getMyWaitingTasks();
		$this->myCompletedTasks = $this->getMyCompletedTasks();
	}

	public function toArray(): array
	{
		return $this->jsonSerialize();
	}

	public function jsonSerialize(): array
	{
		return [
			'id' => $this->getId(),
			'data' => [
				'id' => $this->getId(),
				'typeName' => $this->getTypeName(),
				'itemName' => $this->getName(),
				'itemDescription' => $this->getDescription(),
				'itemTime' => $this->getTime(),
				'statusText' => $this->getStatusText(),
				'faces' => $this->getFaces(),
				'tasks' => $this->getTasks(),
				'authorId' => $this->getAuthorId(),
				'newCommentsCounter' => $this->getCommentCounter(),
				'result' => $this->getIsCompleted() ? $this->getWorkflowResult() : null,
			],
		];
	}

	public function getId(): string
	{
		return $this->workflow->getId();
	}

	public function getName(): mixed
	{
		if ($this->getTasks())
		{
			return current($this->getTasks())['name'];
		}

		if (!$this->isWorkflowAuthorView())
		{
			$task = current($this->getCompletedTasks());
			if ($task)
			{
				return $task['name'];
			}
		}

		$documentService = \CBPRuntime::getRuntime()->getDocumentService();

		return html_entity_decode(
			$documentService->getDocumentName($this->workflow->getComplexDocumentId()) ?? ''
		);
	}

	public function getDescription(): ?string
	{
		$task = false;
		if ($this->getTasks())
		{
			$task = current($this->getTasks());
		}
		elseif (!$this->isWorkflowAuthorView() && $this->getCompletedTasks())
		{
			$task = current($this->getCompletedTasks());
		}

		if ($task)
		{
			return trim($task['description']);
		}

		return null;
	}

	public function getStatusText(): mixed
	{
		return $this->workflow->getStateTitle();
	}

	public function getIsCompleted(): bool
	{
		if ($this->isCompleted === null)
		{
			$this->isCompleted = !WorkflowInstanceTable::exists($this->getId());
		}

		return $this->isCompleted;
	}

	public function getCommentCounter(): int
	{
		$row = WorkflowUserCommentTable::getList([
			'filter' => [
				'=WORKFLOW_ID' => $this->getId(),
				'=USER_ID' => $this->userId,
			],
			'select' => ['UNREAD_CNT'],
		])->fetch();

		return $row ? (int)$row['UNREAD_CNT'] : 0;
	}

	public function getTasks(): array
	{
		return $this->myRunningTasks;
	}

	public function getTaskById(int $taskId): ?array
	{
		foreach ($this->getTasks() as $task)
		{
			if ($task['id'] === $taskId)
			{
				return $task;
			}
		}

		foreach ($this->getCompletedTasks() as $task)
		{
			if ($task['id'] === $taskId)
			{
				return $task;
			}
		}

		$task = \CBPTaskService::getList(
			[],
			['ID' => $taskId, 'USER_ID' => $this->userId],
			false,
			false,
			[
				'ID',
				'MODIFIED',
				'NAME',
				'DESCRIPTION',
				'PARAMETERS',
				'STATUS',
				'IS_INLINE',
				'ACTIVITY',
				'ACTIVITY_NAME',
				'CREATED_DATE',
				'DELEGATION_TYPE',
				'OVERDUE_DATE',
			],
		)->getNext();

		if ($task)
		{
			$task['USERS'] = \CBPTaskService::getTaskUsers($taskId)[$taskId] ?? [];
			$preparedTasks = $this->prepareTasks([$task]);

			return $preparedTasks[0] ?? null;
		}

		return null;
	}

	public function getCompletedTasks(): array
	{
		return $this->myCompletedTasks;
	}

	public function getAuthorId(): mixed
	{
		return $this->workflow->getStartedBy();
	}

	protected function getTime(): string
	{
		return \CBPViewHelper::formatDateTime($this->workflow->getModified());
	}

	public function getOverdueDate(): ?DateTime
	{
		$task = $this->getTasks()[0] ?? null;
		if (!$task || !isset($task['overdueDate']))
		{
			return null;
		}

		return DateTime::createFromUserTime($task['overdueDate']);
	}

	public function getStartedBy(): ?EO_User
	{
		$currentUser = \Bitrix\Main\Engine\CurrentUser::get();
		$currentUserId = $currentUser->getId();
		if (!is_null($currentUserId) && (int)$currentUserId === $this->workflow->getStartedBy())
		{
			$rows = [
				'ID' => $currentUser->getId(),
				'LOGIN' => $currentUser->getLogin(),
				'NAME' => $currentUser->getFirstName(),
				'SECOND_NAME' => $currentUser->getSecondName(),
				'LAST_NAME' => $currentUser->getLastName(),
			];

			return UserTable::wakeUpObject($rows);
		}

		return \Bitrix\Main\UserTable::getByPrimary(
			$this->workflow->getStartedBy(),
			['select' => ['ID', 'LOGIN', 'NAME', 'SECOND_NAME', 'LAST_NAME']]
		)->fetchObject();
	}

	public function getFaces(): WorkflowFacesView
	{
		if (!$this->faces)
		{
			$task = $this->getFirstRunningTask();
			$this->faces = new WorkflowFacesView($this->getId(), $task ? $task['id'] : null);
		}

		return $this->faces;
	}

	private function getMyWaitingTasks(): array
	{
		$userId = $this->userId;

		$myTasks = array_filter(
			$this->tasks['RUNNING'],
			static function($task) use ($userId) {
				$waitingUsers = array_filter(
					$task['USERS'],
					static fn ($user) => ((int)$user['STATUS'] === \CBPTaskUserStatus::Waiting),
				);

				return in_array($userId, array_column($waitingUsers, 'USER_ID'));
			},
		);

		return $this->prepareTasks(array_values($myTasks));
	}

	private function getMyCompletedTasks(): array
	{
		$userId = $this->userId;

		$completedRunningTasks = array_filter(
			$this->tasks['RUNNING'],
			static function ($task) use ($userId) {
				$completedUsers = array_filter(
					$task['USERS'],
					static fn ($user) => ((int)$user['STATUS'] !== \CBPTaskUserStatus::Waiting),
				);

				$taskUserIds = array_column($completedUsers, 'USER_ID');
				Collection::normalizeArrayValuesByInt($taskUserIds);

				return in_array($userId, $taskUserIds, true);
			}
		);

		$completedTasks = array_filter(
			$this->tasks['COMPLETED'],
			static function ($task) use ($userId) {
				$taskUserIds = array_column($task['USERS'], 'USER_ID');
				Collection::normalizeArrayValuesByInt($taskUserIds);

				return in_array($userId, $taskUserIds, true);
			}
		);

		return $this->prepareTasks(array_values(array_merge($completedRunningTasks, $completedTasks)));
	}

	protected function prepareTasks(array $myTasks): array
	{
		$isRpa = $this->workflow->getModuleId() === 'rpa';
		$userId = $this->userId;

		$tasks = [];
		foreach ($myTasks as $task)
		{
			$isRunning = (int)$task['STATUS'] === \CBPTaskStatus::Running;
			if ($isRunning)
			{
				$users = array_filter(
					$task['USERS'] ?? [],
					static function ($user) use ($userId) {
						return (int)$user['USER_ID'] === $userId;
					},
				);
				if ($users)
				{
					$user = current($users);
					$isRunning = (int)$user['STATUS'] === \CBPTaskUserStatus::Waiting;
				}
			}

			$controls = $isRunning ? \CBPDocument::getTaskControls($task, $userId) : [];
			$buttons = $controls['BUTTONS'] ?? null;
			if (!empty($buttons))
			{
				foreach ($buttons as &$button)
				{
					if (!empty($button['TEXT']))
					{
						$button['TEXT'] = html_entity_decode(htmlspecialcharsback($button['TEXT']));
					}
				}

				unset($button);
			}

			$taskId = (int)$task['ID'];
			$tasks[] = [
				'id' => $taskId,
				'name' => html_entity_decode($task['~NAME']),
				'description' => $task['~DESCRIPTION'],
				'isInline' => \CBPHelper::getBool($task['IS_INLINE']),
				'controls' => [
					'buttons' => $buttons,
					'fields' => $controls['FIELDS'] ?? null,
				],
				'createdDate' => $task['~CREATED_DATE'] ?? null,
				'delegationType' => $task['~DELEGATION_TYPE'] ?? null,
				'overdueDate' => $task['~OVERDUE_DATE'] ?? null,
				'url' => $isRpa
					? "/rpa/task/id/$taskId/"
					: sprintf(
						'/company/personal/bizproc/%s/?USER_ID=%d',
						$taskId,
						$this->userId
					)
				,
				'userId' => $userId,
				'isRunning' => $isRunning,
			];
		}

		return $tasks;
	}

	public function getTypeName(): mixed
	{
		$this->workflow->fillTemplate();
		if (
			$this->workflow->getModuleId() !== 'lists'
			&& !empty($this->workflow->getTemplate()?->getName())
		)
		{
			return $this->workflow->getTemplate()?->getName();
		}

		$documentService = \CBPRuntime::getRuntime()->getDocumentService();

		$complexDocumentType = null;
		try
		{
			$complexDocumentType = $documentService->getDocumentType($this->workflow->getComplexDocumentId());
		}
		catch (SystemException | \Exception $exception)
		{}

		return $complexDocumentType ? $documentService->getDocumentTypeCaption($complexDocumentType) : null;
	}

	public function getWorkflowResult(): ?array
	{
		return \CBPViewHelper::getWorkflowResult($this->getId(), $this->userId);
	}

	protected function isWorkflowAuthorView(): bool
	{
		return $this->getAuthorId() === $this->userId;
	}

	private function formatDateTime(string $format, $datetime): ?string
	{
		if ($datetime instanceof DateTime)
		{
			$datetime = (string)$datetime;
		}

		if (is_string($datetime) && DateTime::isCorrect($datetime))
		{
			$timestamp = (new DateTime($datetime))->getTimestamp();

			return FormatDate($format, $timestamp);
		}

		return null;
	}

	protected function getAuthorView(): ?UserView
	{
		return \Bitrix\Bizproc\UI\UserView::createFromId($this->getAuthorId());
	}

	protected function getDocumentUrl(): ?string
	{
		$complexDocumentId = $this->workflow->getComplexDocumentId();

		return \CBPDocument::getDocumentAdminPage($complexDocumentId);
	}

	public function getFirstRunningTask(): ?array
	{
		return $this->getTasks()[0] ?? null;
	}

	protected function isRunningTaskUser(array $task): bool
	{
		$taskUsers = $task['USERS'] ?? [];

		foreach ($taskUsers as $user)
		{
			if ((int)$user['USER_ID'] === $this->userId)
			{
				return (int)$user['STATUS'] === \CBPTaskUserStatus::Waiting;
			}
		}

		return false;
	}

	protected function getTaskControls(array $task): array
	{
		$controls = \CBPDocument::getTaskControls($task, $this->userId);
		$buttons = $controls['BUTTONS'] ?? null;
		if (!empty($buttons))
		{
			foreach ($buttons as &$button)
			{
				if (!empty($button['TEXT']))
				{
					$button['TEXT'] = html_entity_decode(htmlspecialcharsback($button['TEXT']));
				}
			}

			unset($button);
		}

		return [
			'buttons' => $buttons,
			'fields' => $controls['FIELDS'] ?? null,
		];
	}
}