<?php

/*

 * This file is part of the Symfony package.

 *

 * (c) Fabien Potencier <fabien@symfony.com>

 *

 * For the full copyright and license information, please view the LICENSE

 * file that was distributed with this source code.

 */

namespace Symfony\Component\Locale\Stub;

use Symfony\Component\Locale\Stub\StubLocale;

use Symfony\Component\Locale\Exception\NotImplementedException;

use Symfony\Component\Locale\Exception\MethodNotImplementedException;

use Symfony\Component\Locale\Exception\MethodArgumentNotImplementedException;

use Symfony\Component\Locale\Exception\MethodArgumentValueNotImplementedException;

/**

 * Provides a stub NumberFormatter for the 'en' locale.

 *

 * @author Eriksen Costa <eriksen.costa@infranology.com.br>

 */

class StubNumberFormatter

{

    /**

     * Constants defined by the intl extension, not class constants in NumberFormatter

     * TODO: remove if the Form component drop the call to the intl_is_failure() function

     *

     * @see StubNumberFormatter::getErrorCode()

     * @see StubNumberFormatter::getErrorMessage()

     */

    const U_ZERO_ERROR = 0;

    const U_ZERO_ERROR_MESSAGE = 'U_ZERO_ERROR';

    /** Format style constants */

    const PATTERN_DECIMAL   = 0;

    const DECIMAL           = 1;

    const CURRENCY          = 2;

    const PERCENT           = 3;

    const SCIENTIFIC        = 4;

    const SPELLOUT          = 5;

    const ORDINAL           = 6;

    const DURATION          = 7;

    const PATTERN_RULEBASED = 9;

    const IGNORE            = 0;

    const DEFAULT_STYLE     = 1;

    /** Format type constants */

    const TYPE_DEFAULT  = 0;

    const TYPE_INT32    = 1;

    const TYPE_INT64    = 2;

    const TYPE_DOUBLE   = 3;

    const TYPE_CURRENCY = 4;

    /** Numeric attribute constants */

    const PARSE_INT_ONLY          = 0;

    const GROUPING_USED           = 1;

    const DECIMAL_ALWAYS_SHOWN    = 2;

    const MAX_INTEGER_DIGITS      = 3;

    const MIN_INTEGER_DIGITS      = 4;

    const INTEGER_DIGITS          = 5;

    const MAX_FRACTION_DIGITS     = 6;

    const MIN_FRACTION_DIGITS     = 7;

    const FRACTION_DIGITS         = 8;

    const MULTIPLIER              = 9;

    const GROUPING_SIZE           = 10;

    const ROUNDING_MODE           = 11;

    const ROUNDING_INCREMENT      = 12;

    const FORMAT_WIDTH            = 13;

    const PADDING_POSITION        = 14;

    const SECONDARY_GROUPING_SIZE = 15;

    const SIGNIFICANT_DIGITS_USED = 16;

    const MIN_SIGNIFICANT_DIGITS  = 17;

    const MAX_SIGNIFICANT_DIGITS  = 18;

    const LENIENT_PARSE           = 19;

    /** Text attribute constants */

    const POSITIVE_PREFIX   = 0;

    const POSITIVE_SUFFIX   = 1;

    const NEGATIVE_PREFIX   = 2;

    const NEGATIVE_SUFFIX   = 3;

    const PADDING_CHARACTER = 4;

    const CURRENCY_CODE     = 5;

    const DEFAULT_RULESET   = 6;

    const PUBLIC_RULESETS   = 7;

    /** Format symbol constants */

    const DECIMAL_SEPARATOR_SYMBOL           = 0;

    const GROUPING_SEPARATOR_SYMBOL          = 1;

    const PATTERN_SEPARATOR_SYMBOL           = 2;

    const PERCENT_SYMBOL                     = 3;

    const ZERO_DIGIT_SYMBOL                  = 4;

    const DIGIT_SYMBOL                       = 5;

    const MINUS_SIGN_SYMBOL                  = 6;

    const PLUS_SIGN_SYMBOL                   = 7;

    const CURRENCY_SYMBOL                    = 8;

    const INTL_CURRENCY_SYMBOL               = 9;

    const MONETARY_SEPARATOR_SYMBOL          = 10;

    const EXPONENTIAL_SYMBOL                 = 11;

    const PERMILL_SYMBOL                     = 12;

    const PAD_ESCAPE_SYMBOL                  = 13;

    const INFINITY_SYMBOL                    = 14;

    const NAN_SYMBOL                         = 15;

    const SIGNIFICANT_DIGIT_SYMBOL           = 16;

    const MONETARY_GROUPING_SEPARATOR_SYMBOL = 17;

    /** Rounding mode values used by NumberFormatter::setAttribute() with NumberFormatter::ROUNDING_MODE attribute */

    const ROUND_CEILING  = 0;

    const ROUND_FLOOR    = 1;

    const ROUND_DOWN     = 2;

    const ROUND_UP       = 3;

    const ROUND_HALFEVEN = 4;

    const ROUND_HALFDOWN = 5;

    const ROUND_HALFUP   = 6;

    /** Pad position values used by NumberFormatter::setAttribute() with NumberFormatter::PADDING_POSITION attribute */

    const PAD_BEFORE_PREFIX = 0;

    const PAD_AFTER_PREFIX  = 1;

    const PAD_BEFORE_SUFFIX = 2;

    const PAD_AFTER_SUFFIX  = 3;

    /**

     * Default values for the en locale

     * @var array

     */

    private $attributes = array(

        self::FRACTION_DIGITS => 0,

        self::GROUPING_USED   => 1,

        self::ROUNDING_MODE   => self::ROUND_HALFEVEN

    );

    /**

     * Holds the initialized attributes code

     * @var array

     */

    private $initializedAttributes = array();

    /**

     * The supported styles to the constructor $styles argument

     * @var array

     */

    static private $supportedStyles = array(

        'CURRENCY' => self::CURRENCY,

        'DECIMAL'  => self::DECIMAL

    );

    /**

     * Supported attributes to the setAttribute() $attr argument

     * @var array

     */

    static private $supportedAttributes = array(

        'FRACTION_DIGITS' => self::FRACTION_DIGITS,

        'GROUPING_USED'   => self::GROUPING_USED,

        'ROUNDING_MODE'   => self::ROUNDING_MODE

    );

    /**

     * The available rounding modes for setAttribute() usage with

     * StubNumberFormatter::ROUNDING_MODE. StubNumberFormatter::ROUND_DOWN

     * and StubNumberFormatter::ROUND_UP does not have a PHP only equivalent

     *

     * @var array

     */

    static private $roundingModes = array(

        'ROUND_HALFEVEN' => self::ROUND_HALFEVEN,

        'ROUND_HALFDOWN' => self::ROUND_HALFDOWN,

        'ROUND_HALFUP'   => self::ROUND_HALFUP

    );

    /**

     * The mapping between NumberFormatter rounding modes to the available

     * modes in PHP's round() function.

     *

     * @see http://www.php.net/manual/en/function.round.php

     * @var array

     */

    static private $phpRoundingMap = array(

        self::ROUND_HALFDOWN => \PHP_ROUND_HALF_DOWN,

        self::ROUND_HALFEVEN => \PHP_ROUND_HALF_EVEN,

        self::ROUND_HALFUP   => \PHP_ROUND_HALF_UP

    );

    /**

     * The maximum values of the integer type in 32 bit platforms.

     * @var array

     */

    static private $intRange = array(

        'positive' => 2147483647,

        'negative' => -2147483648

    );

    /**

     * @var string

     */

    private $locale = null;

    /**

     * @var int

     */

    private $style = null;

    /**

     * Constructor

     *

     * @param  string  $locale   The locale code

     * @param  int     $style    Style of the formatting, one of the format style constants

     * @param  string  $pattern  A pattern string in case $style is NumberFormat::PATTERN_DECIMAL or

     *                           NumberFormat::PATTERN_RULEBASED. It must conform to  the syntax

     *                           described in the ICU DecimalFormat or ICU RuleBasedNumberFormat documentation

     * @see    http://www.php.net/manual/en/numberformatter.create.php

     * @see    http://www.icu-project.org/apiref/icu4c/classDecimalFormat.html#_details

     * @see    http://www.icu-project.org/apiref/icu4c/classRuleBasedNumberFormat.html#_details

     * @throws MethodArgumentValueNotImplementedException  When $locale different than 'en' is passed

     * @throws MethodArgumentValueNotImplementedException  When the $style is not supported

     * @throws MethodArgumentNotImplementedException       When the pattern value is different than null

     */

    public function __construct($locale = 'en', $style = null, $pattern = null)

    {

        if ('en' != $locale) {

            throw new MethodArgumentValueNotImplementedException(__METHOD__, 'locale', $locale, 'Only the \'en\' locale is supported');

        }

        if (!in_array($style, self::$supportedStyles)) {

            $message = sprintf('The available styles are: %s.', implode(', ', array_keys(self::$supportedStyles)));

            throw new MethodArgumentValueNotImplementedException(__METHOD__, 'style', $style, $message);

        }

        if (null !== $pattern) {

            throw new MethodArgumentNotImplementedException(__METHOD__, 'pattern');

        }

        $this->locale = $locale;

        $this->style  = $style;

    }

    /**

     * Static constructor

     *

     * @param  string  $locale   The locale code

     * @param  int     $style    Style of the formatting, one of the format style constants

     * @param  string  $pattern  A pattern string in case $style is NumberFormat::PATTERN_DECIMAL or

     *                           NumberFormat::PATTERN_RULEBASED. It must conform to  the syntax

     *                           described in the ICU DecimalFormat or ICU RuleBasedNumberFormat documentation

     * @see    http://www.php.net/manual/en/numberformatter.create.php

     * @see    http://www.icu-project.org/apiref/icu4c/classDecimalFormat.html#_details

     * @see    http://www.icu-project.org/apiref/icu4c/classRuleBasedNumberFormat.html#_details

     * @throws MethodArgumentValueNotImplementedException  When $locale different than 'en' is passed

     * @throws MethodArgumentValueNotImplementedException  When the $style is not supported

     * @throws MethodArgumentNotImplementedException       When the pattern value is different than null

     */

    static public function create($locale = 'en', $style = null, $pattern = null)

    {

        return new self($locale, $style, $pattern);

    }

    /**

     * Format a currency value

     *

     * @param  float   $value     The numeric currency value

     * @param  string  $currency  The 3-letter ISO 4217 currency code indicating the currency to use

     * @return string             The formatted currency value

     * @see    http://www.php.net/manual/en/numberformatter.formatcurrency.php

     * @see    http://www.iso.org/iso/support/faqs/faqs_widely_used_standards/widely_used_standards_other/currency_codes/currency_codes_list-1.htm

     */

    public function formatCurrency($value, $currency)

    {

        if ($this->style == self::DECIMAL) {

            return $this->format($value);

        }

        $symbol = $this->getCurrencySymbol($currency);

        $fractionDigits = $this->getCurrencyFractionDigits($currency);

        $value = $this->roundCurrency($value, $currency);

        $negative = false;

        if (0 > $value) {

            $negative = true;

            $value *= -1;

        }

        $value = $this->formatNumber($value, $fractionDigits);

        $ret = $symbol.$value;

        return $negative ? '('.$ret.')' : $ret;

    }

    /**

     * Format a number

     *

     * @param  number      $value                     The value to format

     * @param  int         $type                      Type of the formatting, one of the format type constants

     * @return Boolean|string                         The formatted value or false on error

     * @see    http://www.php.net/manual/en/numberformatter.format.php

     * @throws RuntimeException                       If the method is called with the class $style 'CURRENCY'

     * @throws MethodArgumentNotImplementedException  If the $type is different than TYPE_DEFAULT

     */

    public function format($value, $type = self::TYPE_DEFAULT)

    {

        // The original NumberFormatter does not support this format type

        if ($type == self::TYPE_CURRENCY) {

            trigger_error(__METHOD__.'(): Unsupported format type '.$type, \E_USER_WARNING);

            return false;

        }

        if ($this->style == self::CURRENCY) {

            throw new \RuntimeException(sprintf(

                '%s() method does not support the formatting of currencies (instance with CURRENCY style). %s',

                __METHOD__, NotImplementedException::INTL_INSTALL_MESSAGE

            ));

        }

        // Only the default type is supported.

        if ($type != self::TYPE_DEFAULT) {

            throw new MethodArgumentValueNotImplementedException(__METHOD__, 'type', $type, 'Only TYPE_DEFAULT is supported');

        }

        $fractionDigits = $this->getAttribute(self::FRACTION_DIGITS);

        $value = $this->round($value, $fractionDigits);

        return $this->formatNumber($value, $fractionDigits);

    }

    /**

     * Returns an attribute value

     *

     * @param  int       $attr   An attribute specifier, one of the numeric attribute constants

     * @return Boolean|int       The attribute value on success or false on error

     * @see    http://www.php.net/manual/en/numberformatter.getattribute.php

     */

    public function getAttribute($attr)

    {

        return isset($this->attributes[$attr]) ? $this->attributes[$attr] : null;

    }

    /**

     * Returns formatter's last error code. Always returns the U_ZERO_ERROR class constant value

     *

     * @return int  The error code from last formatter call

     * @see    http://www.php.net/manual/en/numberformatter.geterrorcode.php

     */

    public function getErrorCode()

    {

        return self::U_ZERO_ERROR;

    }

    /**

     * Returns formatter's last error message. Always returns the U_ZERO_ERROR_MESSAGE class constant value

     *

     * @return string  The error message from last formatter call

     * @see    http://www.php.net/manual/en/numberformatter.geterrormessage.php

     */

    public function getErrorMessage()

    {

        return self::U_ZERO_ERROR_MESSAGE;

    }

    /**

     * Returns the formatter's locale

     *

     * @param  int      $type     The locale name type to return between valid or actual (StubLocale::VALID_LOCALE or StubLocale::ACTUAL_LOCALE, respectively)

     * @return string             The locale name used to create the formatter

     * @see    http://www.php.net/manual/en/numberformatter.getlocale.php

     */

    public function getLocale($type = StubLocale::ACTUAL_LOCALE)

    {

        return $this->locale;

    }

    /**

     * Returns the formatter's pattern

     *

     * @return Boolean|string     The pattern string used by the formatter or false on error

     * @see    http://www.php.net/manual/en/numberformatter.getpattern.php

     * @throws MethodNotImplementedException

     */

    public function getPattern()

    {

        throw new MethodNotImplementedException(__METHOD__);

    }

    /**

     * Returns a formatter symbol value

     *

     * @param  int           $attr   A symbol specifier, one of the format symbol constants

     * @return Boolean|string        The symbol value or false on error

     * @see    http://www.php.net/manual/en/numberformatter.getsymbol.php

     * @throws MethodNotImplementedException

     */

    public function getSymbol($attr)

    {

        throw new MethodNotImplementedException(__METHOD__);

    }

    /**

     * Returns a formatter text attribute value

     *

     * @param  int           $attr   An attribute specifier, one of the text attribute constants

     * @return Boolean|string        The attribute value or false on error

     * @see    http://www.php.net/manual/en/numberformatter.gettextattribute.php

     * @throws MethodNotImplementedException

     */

    public function getTextAttribute($attr)

    {

        throw new MethodNotImplementedException(__METHOD__);

    }

    /**

     * Parse a currency number

     *

     * @param  string       $value      The value to parse

     * @param  string       $currency   Parameter to receive the currency name (reference)

     * @param  int          $position   Offset to begin the parsing on return this value will hold the offset at which the parsing ended

     * @return Boolean|string           The parsed numeric value of false on error

     * @see    http://www.php.net/manual/en/numberformatter.parsecurrency.php

     * @throws MethodNotImplementedException

     */

    public function parseCurrency($value, &$currency, &$position = null)

    {

        throw new MethodNotImplementedException(__METHOD__);

    }

    /**

     * Parse a number

     *

     * @param  string       $value                          The value to parse

     * @param  string       $type                           Type of the formatting, one of the format type constants. NumberFormatter::TYPE_DOUBLE by default

     * @param  int          $position                       Offset to begin the parsing on return this value will hold the offset at which the parsing ended

     * @return Boolean|string                               The parsed value of false on error

     * @see    http://www.php.net/manual/en/numberformatter.parse.php

     * @throws MethodArgumentValueNotImplementedException   When $type equals to TYPE_INT64, behavior not implemented

     * @throws MethodArgumentNotImplementedException        When $position different than null, behavior not implemented

     */

    public function parse($value, $type = self::TYPE_DOUBLE, &$position = null)

    {

        if ($type == self::TYPE_DEFAULT || $type == self::TYPE_CURRENCY) {

            trigger_error(__METHOD__.'(): Unsupported format type '.$type, \E_USER_WARNING);

            return false;

        }