<?php
/**
 * WordPress Coding Standard.
 *
 * @package WPCS\WordPressCodingStandards
 * @link    https://github.com/WordPress/WordPress-Coding-Standards
 * @license https://opensource.org/licenses/MIT MIT
 */

namespace WordPressCS\WordPress\Sniffs\CodeAnalysis;

use PHP_CodeSniffer\Util\Tokens;
use PHPCSUtils\BackCompat\BCFile;
use PHPCSUtils\Utils\Parentheses;
use WordPressCS\WordPress\Sniff;

/**
 * Detects variable assignments being made within conditions.
 *
 * This is a typical code smell and more often than not a comparison was intended.
 *
 * Note: this sniff does not detect variable assignments in ternaries without parentheses!
 *
 * @since 0.14.0
 * @since 3.0.0  - The generic "assignment in condition" logic has been removed from the sniff
 *                 in favor of the upstream `Generic.CodeAnalysis.AssignmentInCondition` sniff.
 *               - The sniff has been renamed from `AssignmentInCondition` to `AssignmentInTernaryCondition`.
 *
 * @link https://github.com/squizlabs/PHP_CodeSniffer/pull/1594 Upstream sniff.
 */
final class AssignmentInTernaryConditionSniff extends Sniff {

    /**
     * Assignment tokens to trigger on.
     *
     * Set in the register() method.
     *
     * @since 0.14.0
     *
     * @var array
     */
    protected $assignment_tokens = array();

    /**
     * The tokens that indicate the start of a condition.
     *
     * @since 0.14.0
     *
     * @var array
     */
    protected $condition_start_tokens = array();

    /**
     * Registers the tokens that this sniff wants to listen for.
     *
     * @since 0.14.0
     *
     * @return array
     */
    public function register() {
        $this->assignment_tokens = Tokens::$assignmentTokens;
        unset( $this->assignment_tokens[ \T_DOUBLE_ARROW ] );

        $starters                        = Tokens::$booleanOperators;
        $starters[ \T_SEMICOLON ]        = \T_SEMICOLON;
        $starters[ \T_OPEN_PARENTHESIS ] = \T_OPEN_PARENTHESIS;
        $starters[ \T_INLINE_ELSE ]      = \T_INLINE_ELSE;

        $this->condition_start_tokens = $starters;

        return array(
            \T_INLINE_THEN,
        );
    }

    /**
     * Processes this test, when one of its tokens is encountered.
     *
     * @since 0.14.0
     *
     * @param int $stackPtr The position of the current token in the stack.
     *
     * @return void
     */
    public function process_token( $stackPtr ) {

        $token = $this->tokens[ $stackPtr ];

        // Check if the condition for the ternary is bracketed.
        $prev = $this->phpcsFile->findPrevious( Tokens::$emptyTokens, ( $stackPtr - 1 ), null, true );
        if ( \T_CLOSE_PARENTHESIS === $this->tokens[ $prev ]['code'] ) {
            if ( ! isset( $this->tokens[ $prev ]['parenthesis_opener'] ) ) {
                return;
            }

            $opener = $this->tokens[ $prev ]['parenthesis_opener'];
            $closer = $prev;
        } elseif ( isset( $token['nested_parenthesis'] ) ) {
            $opener = Parentheses::getLastOpener( $this->phpcsFile, $stackPtr );
            $closer = Parentheses::getLastCloser( $this->phpcsFile, $stackPtr );

            $next_statement_closer = BCFile::findEndOfStatement( $this->phpcsFile, $stackPtr, array( \T_COLON, \T_CLOSE_PARENTHESIS, \T_CLOSE_SQUARE_BRACKET ) );
            if ( false !== $next_statement_closer && $next_statement_closer < $closer ) {
                // Parentheses are unrelated to the ternary.
                return;
            }

            $prev_statement_closer = BCFile::findStartOfStatement( $this->phpcsFile, $stackPtr, array( \T_COLON, \T_OPEN_PARENTHESIS, \T_OPEN_SQUARE_BRACKET ) );
            if ( false !== $prev_statement_closer && $opener < $prev_statement_closer ) {
                // Parentheses are unrelated to the ternary.
                return;
            }

            if ( $closer > $stackPtr ) {
                $closer = $stackPtr;
            }
        } else {
            // No parenthesis found, can't determine where the conditional part of the ternary starts.
            return;
        }

        $startPos = $opener;

        do {
            $hasAssignment = $this->phpcsFile->findNext( $this->assignment_tokens, ( $startPos + 1 ), $closer );
            if ( false === $hasAssignment ) {
                return;
            }

            // Examine whether the left side is a variable.
            $hasVariable       = false;
            $conditionStart    = $startPos;
            $altConditionStart = $this->phpcsFile->findPrevious(
                $this->condition_start_tokens,
                ( $hasAssignment - 1 ),
                $startPos
            );
            if ( false !== $altConditionStart ) {
                $conditionStart = $altConditionStart;
            }

            for ( $i = $hasAssignment; $i > $conditionStart; $i-- ) {
                if ( isset( Tokens::$emptyTokens[ $this->tokens[ $i ]['code'] ] ) ) {
                    continue;
                }

                // If this is a variable or array, we've seen all we need to see.
                if ( \T_VARIABLE === $this->tokens[ $i ]['code']
                    || \T_CLOSE_SQUARE_BRACKET === $this->tokens[ $i ]['code']
                ) {
                    $hasVariable = true;
                    break;
                }

                // If this is a function call or something, we are OK.
                if ( \T_CLOSE_PARENTHESIS === $this->tokens[ $i ]['code'] ) {
                    break;
                }
            }

            if ( true === $hasVariable ) {
                $this->phpcsFile->addWarning(
                    'Variable assignment found within a condition. Did you mean to do a comparison?',
                    $hasAssignment,
                    'FoundInTernaryCondition'
                );
            }

            $startPos = $hasAssignment;

        } while ( $startPos < $closer );
    }
}