<?php declare(strict_types = 1);

namespace SlevomatCodingStandard\Sniffs\Namespaces;

use PHP_CodeSniffer\Files\File;
use PHP_CodeSniffer\Sniffs\Sniff;
use PHPStan\PhpDocParser\Ast\ConstExpr\ConstFetchNode;
use PHPStan\PhpDocParser\Ast\Type\IdentifierTypeNode;
use SlevomatCodingStandard\Helpers\AnnotationHelper;
use SlevomatCodingStandard\Helpers\DocCommentHelper;
use SlevomatCodingStandard\Helpers\FixerHelper;
use SlevomatCodingStandard\Helpers\NamespaceHelper;
use SlevomatCodingStandard\Helpers\PhpDocParserHelper;
use SlevomatCodingStandard\Helpers\ReferencedName;
use SlevomatCodingStandard\Helpers\SniffSettingsHelper;
use SlevomatCodingStandard\Helpers\TypeHelper;
use SlevomatCodingStandard\Helpers\TypeHintHelper;
use function in_array;
use function sprintf;
use function strtolower;
use const T_DOC_COMMENT_OPEN_TAG;

class FullyQualifiedClassNameInAnnotationSniff implements Sniff
{

	public const CODE_NON_FULLY_QUALIFIED_CLASS_NAME = 'NonFullyQualifiedClassName';

	/** @var list<string> */
	public $ignoredAnnotationNames = [];

	/**
	 * @return array<int, (int|string)>
	 */
	public function register(): array
	{
		return [
			T_DOC_COMMENT_OPEN_TAG,
		];
	}

	/**
	 * @phpcsSuppress SlevomatCodingStandard.TypeHints.ParameterTypeHint.MissingNativeTypeHint
	 * @param int $docCommentOpenPointer
	 */
	public function process(File $phpcsFile, $docCommentOpenPointer): void
	{
		$annotations = AnnotationHelper::getAnnotations($phpcsFile, $docCommentOpenPointer);
		$this->ignoredAnnotationNames = SniffSettingsHelper::normalizeArray($this->ignoredAnnotationNames);

		foreach ($annotations as $annotation) {
			/** @var list<IdentifierTypeNode> $identifierTypeNodes */
			$identifierTypeNodes = AnnotationHelper::getAnnotationNodesByType($annotation->getNode(), IdentifierTypeNode::class);

			$annotationName = $annotation->getName();

			foreach ($identifierTypeNodes as $typeHintNode) {
				$typeHint = $typeHintNode->name;

				$lowercasedTypeHint = strtolower($typeHint);
				if (
					TypeHintHelper::isSimpleTypeHint($lowercasedTypeHint)
					|| TypeHintHelper::isSimpleUnofficialTypeHints($lowercasedTypeHint)
					|| !TypeHelper::isTypeName($typeHint)
					|| TypeHintHelper::isTypeDefinedInAnnotation($phpcsFile, $docCommentOpenPointer, $typeHint)
				) {
					continue;
				}

				if (in_array($annotationName, $this->ignoredAnnotationNames, true)) {
					continue;
				}

				$fullyQualifiedTypeHint = TypeHintHelper::getFullyQualifiedTypeHint($phpcsFile, $docCommentOpenPointer, $typeHint);
				if ($fullyQualifiedTypeHint === $typeHint) {
					continue;
				}

				$fix = $phpcsFile->addFixableError(sprintf(
					'Class name %s in %s should be referenced via a fully qualified name.',
					$fullyQualifiedTypeHint,
					$annotationName
				), $annotation->getStartPointer(), self::CODE_NON_FULLY_QUALIFIED_CLASS_NAME);

				if (!$fix) {
					continue;
				}

				$parsedDocComment = DocCommentHelper::parseDocComment($phpcsFile, $docCommentOpenPointer);

				$fixedDocComment = AnnotationHelper::fixAnnotation(
					$parsedDocComment,
					$annotation,
					$typeHintNode,
					new IdentifierTypeNode($fullyQualifiedTypeHint)
				);

				$phpcsFile->fixer->beginChangeset();

				FixerHelper::change(
					$phpcsFile,
					$parsedDocComment->getOpenPointer(),
					$parsedDocComment->getClosePointer(),
					$fixedDocComment
				);

				$phpcsFile->fixer->endChangeset();
			}

			/** @var list<ConstFetchNode> $constantFetchNodes */
			$constantFetchNodes = AnnotationHelper::getAnnotationNodesByType($annotation->getNode(), ConstFetchNode::class);

			foreach ($constantFetchNodes as $constantFetchNode) {
				$isClassConstant = $constantFetchNode->className !== '';

				$typeHint = $isClassConstant
					? $constantFetchNode->className
					: $constantFetchNode->name;

				if ($typeHint === 'self') {
					continue;
				}

				$fullyQualifiedTypeHint = $isClassConstant
					? NamespaceHelper::resolveClassName($phpcsFile, $typeHint, $docCommentOpenPointer)
					: NamespaceHelper::resolveName($phpcsFile, $typeHint, ReferencedName::TYPE_CONSTANT, $docCommentOpenPointer);

				if ($fullyQualifiedTypeHint === $typeHint) {
					continue;
				}

				$fix = $phpcsFile->addFixableError(sprintf(
					'%s name %s in %s should be referenced via a fully qualified name.',
					$isClassConstant ? 'Class' : 'Constant',
					$fullyQualifiedTypeHint,
					$annotationName
				), $annotation->getStartPointer(), self::CODE_NON_FULLY_QUALIFIED_CLASS_NAME);

				if (!$fix) {
					continue;
				}

				$fixedConstantFetchNode = PhpDocParserHelper::cloneNode($constantFetchNode);
				if ($isClassConstant) {
					$fixedConstantFetchNode->className = $fullyQualifiedTypeHint;
				} else {
					$fixedConstantFetchNode->name = $fullyQualifiedTypeHint;
				}

				$parsedDocComment = DocCommentHelper::parseDocComment($phpcsFile, $docCommentOpenPointer);

				$fixedDocComment = AnnotationHelper::fixAnnotation(
					$parsedDocComment,
					$annotation,
					$constantFetchNode,
					$fixedConstantFetchNode
				);

				$phpcsFile->fixer->beginChangeset();

				FixerHelper::change(
					$phpcsFile,
					$parsedDocComment->getOpenPointer(),
					$parsedDocComment->getClosePointer(),
					$fixedDocComment
				);

				$phpcsFile->fixer->endChangeset();

			}
		}
	}

}
