<?php

namespace LWVendor\PhpOffice\PhpSpreadsheet\Calculation\LookupRef;

use LWVendor\PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
use LWVendor\PhpOffice\PhpSpreadsheet\Calculation\Exception;
use LWVendor\PhpOffice\PhpSpreadsheet\Calculation\Functions;
use LWVendor\PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;
use LWVendor\PhpOffice\PhpSpreadsheet\Calculation\Internal\WildcardMatch;
use LWVendor\PhpOffice\PhpSpreadsheet\Shared\StringHelper;
class ExcelMatch
{
    use ArrayEnabled;
    public const MATCHTYPE_SMALLEST_VALUE = -1;
    public const MATCHTYPE_FIRST_VALUE = 0;
    public const MATCHTYPE_LARGEST_VALUE = 1;
    /**
     * MATCH.
     *
     * The MATCH function searches for a specified item in a range of cells
     *
     * Excel Function:
     *        =MATCH(lookup_value, lookup_array, [match_type])
     *
     * @param mixed $lookupValue The value that you want to match in lookup_array
     * @param mixed $lookupArray The range of cells being searched
     * @param mixed $matchType The number -1, 0, or 1. -1 means above, 0 means exact match, 1 means below.
     *                         If match_type is 1 or -1, the list has to be ordered.
     *
     * @return array|int|string The relative position of the found item
     */
    public static function MATCH($lookupValue, $lookupArray, $matchType = self::MATCHTYPE_LARGEST_VALUE)
    {
        if (\is_array($lookupValue)) {
            return self::evaluateArrayArgumentsIgnore([self::class, __FUNCTION__], 1, $lookupValue, $lookupArray, $matchType);
        }
        $lookupArray = Functions::flattenArray($lookupArray);
        try {
            // Input validation
            self::validateLookupValue($lookupValue);
            $matchType = self::validateMatchType($matchType);
            self::validateLookupArray($lookupArray);
            $keySet = \array_keys($lookupArray);
            if ($matchType == self::MATCHTYPE_LARGEST_VALUE) {
                // If match_type is 1 the list has to be processed from last to first
                $lookupArray = \array_reverse($lookupArray);
                $keySet = \array_reverse($keySet);
            }
            $lookupArray = self::prepareLookupArray($lookupArray, $matchType);
        } catch (Exception $e) {
            return $e->getMessage();
        }
        // MATCH() is not case sensitive, so we convert lookup value to be lower cased if it's a string type.
        if (\is_string($lookupValue)) {
            $lookupValue = StringHelper::strToLower($lookupValue);
        }
        $valueKey = null;
        switch ($matchType) {
            case self::MATCHTYPE_LARGEST_VALUE:
                $valueKey = self::matchLargestValue($lookupArray, $lookupValue, $keySet);
                break;
            case self::MATCHTYPE_FIRST_VALUE:
                $valueKey = self::matchFirstValue($lookupArray, $lookupValue);
                break;
            case self::MATCHTYPE_SMALLEST_VALUE:
            default:
                $valueKey = self::matchSmallestValue($lookupArray, $lookupValue);
        }
        if ($valueKey !== null) {
            return ++$valueKey;
        }
        // Unsuccessful in finding a match, return #N/A error value
        return ExcelError::NA();
    }
    /**
     * @param mixed $lookupValue
     *
     * @return mixed
     */
    private static function matchFirstValue(array $lookupArray, $lookupValue)
    {
        if (\is_string($lookupValue)) {
            $valueIsString = \true;
            $wildcard = WildcardMatch::wildcard($lookupValue);
        } else {
            $valueIsString = \false;
            $wildcard = '';
        }
        $valueIsNumeric = \is_int($lookupValue) || \is_float($lookupValue);
        foreach ($lookupArray as $i => $lookupArrayValue) {
            if ($valueIsString && \is_string($lookupArrayValue)) {
                if (WildcardMatch::compare($lookupArrayValue, $wildcard)) {
                    return $i;
                    // wildcard match
                }
            } else {
                if ($lookupArrayValue === $lookupValue) {
                    return $i;
                    // exact match
                }
                if ($valueIsNumeric && (\is_float($lookupArrayValue) || \is_int($lookupArrayValue)) && $lookupArrayValue == $lookupValue) {
                    return $i;
                    // exact match
                }
            }
        }
        return null;
    }
    /**
     * @param mixed $lookupValue
     *
     * @return mixed
     */
    private static function matchLargestValue(array $lookupArray, $lookupValue, array $keySet)
    {
        if (\is_string($lookupValue)) {
            if (Functions::getCompatibilityMode() === Functions::COMPATIBILITY_OPENOFFICE) {
                $wildcard = WildcardMatch::wildcard($lookupValue);
                foreach (\array_reverse($lookupArray) as $i => $lookupArrayValue) {
                    if (\is_string($lookupArrayValue) && WildcardMatch::compare($lookupArrayValue, $wildcard)) {
                        return $i;
                    }
                }
            } else {
                foreach ($lookupArray as $i => $lookupArrayValue) {
                    if ($lookupArrayValue === $lookupValue) {
                        return $keySet[$i];
                    }
                }
            }
        }
        $valueIsNumeric = \is_int($lookupValue) || \is_float($lookupValue);
        foreach ($lookupArray as $i => $lookupArrayValue) {
            if ($valueIsNumeric && (\is_int($lookupArrayValue) || \is_float($lookupArrayValue))) {
                if ($lookupArrayValue <= $lookupValue) {
                    return \array_search($i, $keySet);
                }
            }
            $typeMatch = \gettype($lookupValue) === \gettype($lookupArrayValue);
            if ($typeMatch && $lookupArrayValue <= $lookupValue) {
                return \array_search($i, $keySet);
            }
        }
        return null;
    }
    /**
     * @param mixed $lookupValue
     *
     * @return mixed
     */
    private static function matchSmallestValue(array $lookupArray, $lookupValue)
    {
        $valueKey = null;
        if (\is_string($lookupValue)) {
            if (Functions::getCompatibilityMode() === Functions::COMPATIBILITY_OPENOFFICE) {
                $wildcard = WildcardMatch::wildcard($lookupValue);
                foreach ($lookupArray as $i => $lookupArrayValue) {
                    if (\is_string($lookupArrayValue) && WildcardMatch::compare($lookupArrayValue, $wildcard)) {
                        return $i;
                    }
                }
            }
        }
        $valueIsNumeric = \is_int($lookupValue) || \is_float($lookupValue);
        // The basic algorithm is:
        // Iterate and keep the highest match until the next element is smaller than the searched value.
        // Return immediately if perfect match is found
        foreach ($lookupArray as $i => $lookupArrayValue) {
            $typeMatch = \gettype($lookupValue) === \gettype($lookupArrayValue);
            $bothNumeric = $valueIsNumeric && (\is_int($lookupArrayValue) || \is_float($lookupArrayValue));
            if ($lookupArrayValue === $lookupValue) {
                // Another "special" case. If a perfect match is found,
                // the algorithm gives up immediately
                return $i;
            }
            if ($bothNumeric && $lookupValue == $lookupArrayValue) {
                return $i;
                // exact match, as above
            }
            if (($typeMatch || $bothNumeric) && $lookupArrayValue >= $lookupValue) {
                $valueKey = $i;
            } elseif ($typeMatch && $lookupArrayValue < $lookupValue) {
                //Excel algorithm gives up immediately if the first element is smaller than the searched value
                break;
            }
        }
        return $valueKey;
    }
    /**
     * @param mixed $lookupValue
     */
    private static function validateLookupValue($lookupValue) : void
    {
        // Lookup_value type has to be number, text, or logical values
        if (!\is_numeric($lookupValue) && !\is_string($lookupValue) && !\is_bool($lookupValue)) {
            throw new Exception(ExcelError::NA());
        }
    }
    /**
     * @param mixed $matchType
     */
    private static function validateMatchType($matchType) : int
    {
        // Match_type is 0, 1 or -1
        // However Excel accepts other numeric values,
        //  including numeric strings and floats.
        //  It seems to just be interested in the sign.
        if (!\is_numeric($matchType)) {
            throw new Exception(ExcelError::Value());
        }
        if ($matchType > 0) {
            return self::MATCHTYPE_LARGEST_VALUE;
        }
        if ($matchType < 0) {
            return self::MATCHTYPE_SMALLEST_VALUE;
        }
        return self::MATCHTYPE_FIRST_VALUE;
    }
    private static function validateLookupArray(array $lookupArray) : void
    {
        // Lookup_array should not be empty
        $lookupArraySize = \count($lookupArray);
        if ($lookupArraySize <= 0) {
            throw new Exception(ExcelError::NA());
        }
    }
    /**
     * @param mixed $matchType
     */
    private static function prepareLookupArray(array $lookupArray, $matchType) : array
    {
        // Lookup_array should contain only number, text, or logical values, or empty (null) cells
        foreach ($lookupArray as $i => $value) {
            //    check the type of the value
            if (!\is_numeric($value) && !\is_string($value) && !\is_bool($value) && $value !== null) {
                throw new Exception(ExcelError::NA());
            }
            // Convert strings to lowercase for case-insensitive testing
            if (\is_string($value)) {
                $lookupArray[$i] = StringHelper::strToLower($value);
            }
            if ($value === null && ($matchType == self::MATCHTYPE_LARGEST_VALUE || $matchType == self::MATCHTYPE_SMALLEST_VALUE)) {
                unset($lookupArray[$i]);
            }
        }
        return $lookupArray;
    }
}