<?php

namespace Composer\Semver\Constraint;

/**
 * Defines a conjunctive or disjunctive set of constraints.
 */
class MultiConstraint implements ConstraintInterface
{
	/**
	 * @var ConstraintInterface[]
	 * @phpstan-var non-empty-array<ConstraintInterface>
	 */
	protected $constraints;

	/** @var string|null */
	protected $prettyString;

	/** @var string|null */
	protected $string;

	/** @var bool */
	protected $conjunctive;

	/** @var Bound|null */
	protected $lowerBound;

	/** @var Bound|null */
	protected $upperBound;


	/**
	 * @param ConstraintInterface[] $constraints A set of constraints
	 * @param bool                  $conjunctive Whether the constraints should be treated as conjunctive or disjunctive
	 *
	 * @throws \InvalidArgumentException If less than 2 constraints are passed
	 */
	public function __construct(array $constraints, $conjunctive = true)
	{
		if (\count($constraints) < 2) {
		    throw new \InvalidArgumentException(
		        'Must provide at least two constraints for a MultiConstraint. Use '.
		        'the regular Constraint class for one constraint only or MatchAllConstraint for none. You may use '.
		        'MultiConstraint::create() which optimizes and handles those cases automatically.'
		    );
		}

		$this->constraints = $constraints;
		$this->conjunctive = $conjunctive;
	}


	/**
	 * @return ConstraintInterface[]
	 */
	public function getConstraints()
	{
		return $this->constraints;
	}


	/**
	 * @return bool
	 */
	public function isConjunctive()
	{
		return $this->conjunctive;
	}


	/**
	 * @return bool
	 */
	public function isDisjunctive()
	{
		return !$this->conjunctive;
	}


	/**
	 * {@inheritDoc}
	 */
	public function compile($otherOperator)
	{
		$parts = array();
		foreach ($this->constraints as $constraint) {
		    $code = $constraint->compile($otherOperator);
		    if ($code === 'true') {
		        if (!$this->conjunctive) {
		            return 'true';
		        }
		    } elseif ($code === 'false') {
		        if ($this->conjunctive) {
		            return 'false';
		        }
		    } else {
		        $parts[] = '('.$code.')';
		    }
		}

		if (!$parts) {
		    return $this->conjunctive ? 'true' : 'false';
		}

		return $this->conjunctive ? implode('&&', $parts) : implode('||', $parts);
	}


	/**
	 * @param ConstraintInterface $provider
	 *
	 * @return bool
	 */
	public function matches(ConstraintInterface $provider)
	{
		if (false === $this->conjunctive) {
		    foreach ($this->constraints as $constraint) {
		        if ($provider->matches($constraint)) {
		            return true;
		        }
		    }

		    return false;
		}

		// when matching a conjunctive and a disjunctive multi constraint we have to iterate over the disjunctive one
		// otherwise we'd return true if different parts of the disjunctive constraint match the conjunctive one
		// which would lead to incorrect results, e.g. [>1 and <2] would match [<1 or >2] although they do not intersect
		if ($provider instanceof MultiConstraint && $provider->isDisjunctive()) {
		    return $provider->matches($this);
		}

		foreach ($this->constraints as $constraint) {
		    if (!$provider->matches($constraint)) {
		        return false;
		    }
		}

		return true;
	}


	/**
	 * {@inheritDoc}
	 */
	public function setPrettyString($prettyString)
	{
		$this->prettyString = $prettyString;
	}


	/**
	 * {@inheritDoc}
	 */
	public function getPrettyString()
	{
		if ($this->prettyString) {
		    return $this->prettyString;
		}

		return (string) $this;
	}


	/**
	 * {@inheritDoc}
	 */
	public function __toString()
	{
		if ($this->string !== null) {
		    return $this->string;
		}

		$constraints = array();
		foreach ($this->constraints as $constraint) {
		    $constraints[] = (string) $constraint;
		}

		return $this->string = '[' . implode($this->conjunctive ? ' ' : ' || ', $constraints) . ']';
	}


	/**
	 * {@inheritDoc}
	 */
	public function getLowerBound()
	{
		$this->extractBounds();

		if (null === $this->lowerBound) {
		    throw new \LogicException('extractBounds should have populated the lowerBound property');
		}

		return $this->lowerBound;
	}


	/**
	 * {@inheritDoc}
	 */
	public function getUpperBound()
	{
		$this->extractBounds();

		if (null === $this->upperBound) {
		    throw new \LogicException('extractBounds should have populated the upperBound property');
		}

		return $this->upperBound;
	}


	/**
	 * Tries to optimize the constraints as much as possible, meaning
	 * reducing/collapsing congruent constraints etc.
	 * Does not necessarily return a MultiConstraint instance if
	 * things can be reduced to a simple constraint
	 *
	 * @param ConstraintInterface[] $constraints A set of constraints
	 * @param bool                  $conjunctive Whether the constraints should be treated as conjunctive or disjunctive
	 *
	 * @return ConstraintInterface
	 */
	public static function create(array $constraints, $conjunctive = true)
	{
		if (0 === \count($constraints)) {
		    return new MatchAllConstraint();
		}

		if (1 === \count($constraints)) {
		    return $constraints[0];
		}

		$optimized = self::optimizeConstraints($constraints, $conjunctive);
		if ($optimized !== null) {
		    list($constraints, $conjunctive) = $optimized;
		    if (\count($constraints) === 1) {
		        return $constraints[0];
		    }
		}

		return new self($constraints, $conjunctive);
	}


	/**
	 * @param  ConstraintInterface[] $constraints
	 * @param  bool                  $conjunctive
	 * @return ?array
	 *
	 * @phpstan-return array{0: list<ConstraintInterface>, 1: bool}|null
	 */
	private static function optimizeConstraints(array $constraints, $conjunctive)
	{
		if (!$conjunctive) {
		    $left = $constraints[0];
		    $mergedConstraints = array();
		    $optimized = false;
		    for ($i = 1, $l = \count($constraints); $i < $l; $i++) {
		        $right = $constraints[$i];
		        if (
		            $left instanceof self
		            && $left->conjunctive
		            && $right instanceof self
		            && $right->conjunctive
		            && \count($left->constraints) === 2
		            && \count($right->constraints) === 2
		            && ($left0 = (string) $left->constraints[0])
		            && $left0[0] === '>' && $left0[1] === '='
		            && ($left1 = (string) $left->constraints[1])
		            && $left1[0] === '<'
		            && ($right0 = (string) $right->constraints[0])
		            && $right0[0] === '>' && $right0[1] === '='
		            && ($right1 = (string) $right->constraints[1])
		            && $right1[0] === '<'
		            && substr($left1, 2) === substr($right0, 3)
		        ) {
		            $optimized = true;
		            $left = new MultiConstraint(
		                array(
		                    $left->constraints[0],
		                    $right->constraints[1],
		                ),
		                true);
		        } else {
		            $mergedConstraints[] = $left;
		            $left = $right;
		        }
		    }
		    if ($optimized) {
		        $mergedConstraints[] = $left;
		        return array($mergedConstraints, false);
		    }
		}

		// TODO: Here's the place to put more optimizations

		return null;
	}


	/**
	 * @return void
	 */
	private function extractBounds()
	{
		if (null !== $this->lowerBound) {
		    return;
		}

		foreach ($this->constraints as $constraint) {
		    if (null === $this->lowerBound || null === $this->upperBound) {
		        $this->lowerBound = $constraint->getLowerBound();
		        $this->upperBound = $constraint->getUpperBound();
		        continue;
		    }

		    if ($constraint->getLowerBound()->compareTo($this->lowerBound, $this->isConjunctive() ? '>' : '<')) {
		        $this->lowerBound = $constraint->getLowerBound();
		    }

		    if ($constraint->getUpperBound()->compareTo($this->upperBound, $this->isConjunctive() ? '<' : '>')) {
		        $this->upperBound = $constraint->getUpperBound();
		    }
		}
	}
}
__halt_compiler();----SIGNATURE:----OaOwho4UH7YXLEHMzD3Qy1BIlwdhK0H+mLntJalgsChLMXtQtTwyFwqeLfgnQybkuYIs7QGZ4CISYrB9r3AnY5GipgudLwQMVo54lrHd/AZSS8nNhFUGnrVU1omCCA6Sm9TT22IN7PAPSourgAa5PKnG9lQEUdJ4JW3nrI57e3DhybVDFSSdJo0mTVA+x/1FQg3qR6KwXje7AJ/GMZOsKexRAmZWfAHOCAltIAnPeOZbbxOjmxFMHHmMrecNQjYyI6WeiWTF4kE0wXyMHNd/PYzE4ywli7ZBujGEjXeZgXUjt24A0VXBDNWG/J1EhBdQ57UZnU1joVTWPJUIFFbWehILWixNzrhmKpv6XPoSnjgwsmec58IBZwWWfL/U3ym5HA/5+aT3EsluUQ2uOQGs8QhbYps60Q4z2xT4WeZFua3duGto3VMl8GUS6Lj9AlUk9VYWRAtKlIKVgN6NfwI5nJnLpy4YrFaFYdUK8XaOLNXoMHvPF2JrxqxW8KgQbdSJZgaxPossxC4vAIl1tJjrJbAR0WbW4AX8F40kOzpMyTdrIgQ54TBeQynAqlzbvYvGSa/toPUvY/Ow9rFUks6ofbgQPpcgPifE+nJg24ZCRpq/vH5ppuYWerPZv+lBUxC5db9pKEFyyLxby+kDsN9GlmWmaYJAU5U1bQo2bnsBb58=----ATTACHMENT:----MTgwMDA5MjUzMzg3NzQ3NCAzMDg3ODI2Nzk5NTQ4MDc2IDExMDQ3MTcyNTQwNzgwOTA=