<?php

/**

 * Zend Framework

 *

 * LICENSE

 *

 * This source file is subject to the new BSD license that is bundled

 * with this package in the file LICENSE.txt.

 * It is also available through the world-wide-web at this URL:

 * http://framework.zend.com/license/new-bsd

 * If you did not receive a copy of the license and are unable to

 * obtain it through the world-wide-web, please send an email

 * to license@zend.com so we can send you a copy immediately.

 *

 * @category  Zend

 * @package   Zend_Date

 * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)

 * @license   http://framework.zend.com/license/new-bsd     New BSD License

 * @version   $Id: Date.php 24880 2012-06-12 20:35:18Z matthew $

 */

/**

 * Include needed Date classes

 */

require_once 'Zend/Date/DateObject.php';

require_once 'Zend/Locale.php';

require_once 'Zend/Locale/Format.php';

require_once 'Zend/Locale/Math.php';

/**

 * @category  Zend

 * @package   Zend_Date

 * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)

 * @license   http://framework.zend.com/license/new-bsd     New BSD License

 */

class Zend_Date extends Zend_Date_DateObject

{

    private $_locale  = null;

    // Fractional second variables

    private $_fractional = 0;

    private $_precision  = 3;

    private static $_options = array(

        'format_type'  => 'iso',      // format for date strings 'iso' or 'php'

        'fix_dst'      => true,       // fix dst on summer/winter time change

        'extend_month' => false,      // false - addMonth like SQL, true like excel

        'cache'        => null,       // cache to set

        'timesync'     => null        // timesync server to set

    );

    // Class wide Date Constants

    const DAY               = 'dd';

    const DAY_SHORT         = 'd';

    const DAY_SUFFIX        = 'SS';

    const DAY_OF_YEAR       = 'D';

    const WEEKDAY           = 'EEEE';

    const WEEKDAY_SHORT     = 'EEE';

    const WEEKDAY_NARROW    = 'E';

    const WEEKDAY_NAME      = 'EE';

    const WEEKDAY_8601      = 'eee';

    const WEEKDAY_DIGIT     = 'e';

    const WEEK              = 'ww';

    const MONTH             = 'MM';

    const MONTH_SHORT       = 'M';

    const MONTH_DAYS        = 'ddd';

    const MONTH_NAME        = 'MMMM';

    const MONTH_NAME_SHORT  = 'MMM';

    const MONTH_NAME_NARROW = 'MMMMM';

    const YEAR              = 'y';

    const YEAR_SHORT        = 'yy';

    const YEAR_8601         = 'Y';

    const YEAR_SHORT_8601   = 'YY';

    const LEAPYEAR          = 'l';

    const MERIDIEM          = 'a';

    const SWATCH            = 'B';

    const HOUR              = 'HH';

    const HOUR_SHORT        = 'H';

    const HOUR_AM           = 'hh';

    const HOUR_SHORT_AM     = 'h';

    const MINUTE            = 'mm';

    const MINUTE_SHORT      = 'm';

    const SECOND            = 'ss';

    const SECOND_SHORT      = 's';

    const MILLISECOND       = 'S';

    const TIMEZONE_NAME     = 'zzzz';

    const DAYLIGHT          = 'I';

    const GMT_DIFF          = 'Z';

    const GMT_DIFF_SEP      = 'ZZZZ';

    const TIMEZONE          = 'z';

    const TIMEZONE_SECS     = 'X';

    const ISO_8601          = 'c';

    const RFC_2822          = 'r';

    const TIMESTAMP         = 'U';

    const ERA               = 'G';

    const ERA_NAME          = 'GGGG';

    const ERA_NARROW        = 'GGGGG';

    const DATES             = 'F';

    const DATE_FULL         = 'FFFFF';

    const DATE_LONG         = 'FFFF';

    const DATE_MEDIUM       = 'FFF';

    const DATE_SHORT        = 'FF';

    const TIMES             = 'WW';

    const TIME_FULL         = 'TTTTT';

    const TIME_LONG         = 'TTTT';

    const TIME_MEDIUM       = 'TTT';

    const TIME_SHORT        = 'TT';

    const DATETIME          = 'K';

    const DATETIME_FULL     = 'KKKKK';

    const DATETIME_LONG     = 'KKKK';

    const DATETIME_MEDIUM   = 'KKK';

    const DATETIME_SHORT    = 'KK';

    const ATOM              = 'OOO';

    const COOKIE            = 'CCC';

    const RFC_822           = 'R';

    const RFC_850           = 'RR';

    const RFC_1036          = 'RRR';

    const RFC_1123          = 'RRRR';

    const RFC_3339          = 'RRRRR';

    const RSS               = 'SSS';

    const W3C               = 'WWW';

    /**

     * Generates the standard date object, could be a unix timestamp, localized date,

     * string, integer, array and so on. Also parts of dates or time are supported

     * Always set the default timezone: http://php.net/date_default_timezone_set

     * For example, in your bootstrap: date_default_timezone_set('America/Los_Angeles');

     * For detailed instructions please look in the docu.

     *

     * @param  string|integer|Zend_Date|array  $date    OPTIONAL Date value or value of date part to set

     *                                                 ,depending on $part. If null the actual time is set

     * @param  string                          $part    OPTIONAL Defines the input format of $date

     * @param  string|Zend_Locale              $locale  OPTIONAL Locale for parsing input

     * @return Zend_Date

     * @throws Zend_Date_Exception

     */

    public function __construct($date = null, $part = null, $locale = null)

    {

        if (is_object($date) and !($date instanceof Zend_TimeSync_Protocol) and

            !($date instanceof Zend_Date)) {

            if ($locale instanceof Zend_Locale) {

                $locale = $date;

                $date   = null;

                $part   = null;

            } else {

                $date = (string) $date;

            }

        }

        if (($date !== null) and !is_array($date) and !($date instanceof Zend_TimeSync_Protocol) and

            !($date instanceof Zend_Date) and !defined($date) and Zend_Locale::isLocale($date, true, false)) {

            $locale = $date;

            $date   = null;

            $part   = null;

        } else if (($part !== null) and !defined($part) and Zend_Locale::isLocale($part, true, false)) {

            $locale = $part;

            $part   = null;

        }

        $this->setLocale($locale);

        if (is_string($date) && ($part === null) && (strlen($date) <= 5)) {

            $part = $date;

            $date = null;

        }

        if ($date === null) {

            if ($part === null) {

                $date = time();

            } else if ($part !== self::TIMESTAMP) {

                $date = self::now($locale);

                $date = $date->get($part);

            }

        }

        if ($date instanceof Zend_TimeSync_Protocol) {

            $date = $date->getInfo();

            $date = $this->_getTime($date['offset']);

            $part = null;

        } else if (parent::$_defaultOffset != 0) {

            $date = $this->_getTime(parent::$_defaultOffset);

        }

        // set the timezone and offset for $this

        $zone = @date_default_timezone_get();

        $this->setTimezone($zone);

        // try to get timezone from date-string

        if (!is_int($date)) {

            $zone = $this->getTimezoneFromString($date);

            $this->setTimezone($zone);

        }

        // set datepart

        if (($part !== null && $part !== self::TIMESTAMP) or (!is_numeric($date))) {

            // switch off dst handling for value setting

            $this->setUnixTimestamp($this->getGmtOffset());

            $this->set($date, $part, $this->_locale);

            // DST fix

            if (is_array($date) === true) {

                if (!isset($date['hour'])) {

                    $date['hour'] = 0;

                }

                $hour = $this->toString('H', 'iso', true);

                $hour = $date['hour'] - $hour;

                switch ($hour) {

                    case 1 :

                    case -23 :

                        $this->addTimestamp(3600);

                        break;

                    case -1 :

                    case 23 :

                        $this->subTimestamp(3600);

                        break;

                    case 2 :

                    case -22 :

                        $this->addTimestamp(7200);

                        break;

                    case -2 :

                    case 22 :

                        $this->subTimestamp(7200);

                        break;

                }

            }

        } else {

            $this->setUnixTimestamp($date);

        }

    }

    /**

     * Sets class wide options, if no option was given, the actual set options will be returned

     *

     * @param  array  $options  Options to set

     * @throws Zend_Date_Exception

     * @return Options array if no option was given

     */

    public static function setOptions(array $options = array())

    {

        if (empty($options)) {

            return self::$_options;

        }

        foreach ($options as $name => $value) {

            $name  = strtolower($name);

            if (array_key_exists($name, self::$_options)) {

                switch($name) {

                    case 'format_type' :

                        if ((strtolower($value) != 'php') && (strtolower($value) != 'iso')) {

                            require_once 'Zend/Date/Exception.php';

                            throw new Zend_Date_Exception("Unknown format type ($value) for dates, only 'iso' and 'php' supported", 0, null, $value);

                        }

                        break;

                    case 'fix_dst' :

                        if (!is_bool($value)) {

                            require_once 'Zend/Date/Exception.php';

                            throw new Zend_Date_Exception("'fix_dst' has to be boolean", 0, null, $value);

                        }

                        break;

                    case 'extend_month' :

                        if (!is_bool($value)) {

                            require_once 'Zend/Date/Exception.php';

                            throw new Zend_Date_Exception("'extend_month' has to be boolean", 0, null, $value);

                        }

                        break;

                    case 'cache' :

                        if ($value === null) {

                            parent::$_cache = null;

                        } else {

                            if (!$value instanceof Zend_Cache_Core) {

                                require_once 'Zend/Date/Exception.php';

                                throw new Zend_Date_Exception("Instance of Zend_Cache expected");

                            }

                            parent::$_cache = $value;

                            parent::$_cacheTags = Zend_Date_DateObject::_getTagSupportForCache();

                            Zend_Locale_Data::setCache($value);

                        }

                        break;

                    case 'timesync' :

                        if ($value === null) {

                            parent::$_defaultOffset = 0;

                        } else {

                            if (!$value instanceof Zend_TimeSync_Protocol) {

                                require_once 'Zend/Date/Exception.php';

                                throw new Zend_Date_Exception("Instance of Zend_TimeSync expected");

                            }

                            $date = $value->getInfo();

                            parent::$_defaultOffset = $date['offset'];

                        }

                        break;

                }

                self::$_options[$name] = $value;

            }

            else {

                require_once 'Zend/Date/Exception.php';

                throw new Zend_Date_Exception("Unknown option: $name = $value");

            }

        }

    }

    /**

     * Returns this object's internal UNIX timestamp (equivalent to Zend_Date::TIMESTAMP).

     * If the timestamp is too large for integers, then the return value will be a string.

     * This function does not return the timestamp as an object.

     * Use clone() or copyPart() instead.

     *

     * @return integer|string  UNIX timestamp

     */

    public function getTimestamp()

    {

        return $this->getUnixTimestamp();

    }

    /**

     * Returns the calculated timestamp

     * HINT: timestamps are always GMT

     *

     * @param  string                          $calc    Type of calculation to make

     * @param  string|integer|array|Zend_Date  $stamp   Timestamp to calculate, when null the actual timestamp is calculated

     * @return Zend_Date|integer

     * @throws Zend_Date_Exception

     */

    private function _timestamp($calc, $stamp)

    {

        if ($stamp instanceof Zend_Date) {

            // extract timestamp from object

            $stamp = $stamp->getTimestamp();

        }

        if (is_array($stamp)) {

            if (isset($stamp['timestamp']) === true) {

                $stamp = $stamp['timestamp'];

            } else {

                require_once 'Zend/Date/Exception.php';

                throw new Zend_Date_Exception('no timestamp given in array');

            }

        }

        if ($calc === 'set') {

            $return = $this->setUnixTimestamp($stamp);

        } else {

            $return = $this->_calcdetail($calc, $stamp, self::TIMESTAMP, null);

        }

        if ($calc != 'cmp') {

            return $this;

        }

        return $return;

    }

    /**

     * Sets a new timestamp

     *

     * @param  integer|string|array|Zend_Date  $timestamp  Timestamp to set

     * @return Zend_Date Provides fluid interface

     * @throws Zend_Date_Exception

     */

    public function setTimestamp($timestamp)

    {

        return $this->_timestamp('set', $timestamp);

    }

    /**

     * Adds a timestamp

     *

     * @param  integer|string|array|Zend_Date  $timestamp  Timestamp to add

     * @return Zend_Date Provides fluid interface

     * @throws Zend_Date_Exception

     */

    public function addTimestamp($timestamp)

    {

        return $this->_timestamp('add', $timestamp);

    }

    /**

     * Subtracts a timestamp

     *

     * @param  integer|string|array|Zend_Date  $timestamp  Timestamp to sub

     * @return Zend_Date Provides fluid interface

     * @throws Zend_Date_Exception

     */

    public function subTimestamp($timestamp)

    {

        return $this->_timestamp('sub', $timestamp);

    }

    /**

     * Compares two timestamps, returning the difference as integer

     *

     * @param  integer|string|array|Zend_Date  $timestamp  Timestamp to compare

     * @return integer  0 = equal, 1 = later, -1 = earlier

     * @throws Zend_Date_Exception

     */

    public function compareTimestamp($timestamp)

    {

        return $this->_timestamp('cmp', $timestamp);

    }

    /**

     * Returns a string representation of the object

     * Supported format tokens are:

     * G - era, y - year, Y - ISO year, M - month, w - week of year, D - day of year, d - day of month

     * E - day of week, e - number of weekday (1-7), h - hour 1-12, H - hour 0-23, m - minute, s - second

     * A - milliseconds of day, z - timezone, Z - timezone offset, S - fractional second, a - period of day

     *

     * Additionally format tokens but non ISO conform are:

     * SS - day suffix, eee - php number of weekday(0-6), ddd - number of days per month

     * l - Leap year, B - swatch internet time, I - daylight saving time, X - timezone offset in seconds

     * r - RFC2822 format, U - unix timestamp

     *

     * Not supported ISO tokens are

     * u - extended year, Q - quarter, q - quarter, L - stand alone month, W - week of month

     * F - day of week of month, g - modified julian, c - stand alone weekday, k - hour 0-11, K - hour 1-24

     * v - wall zone

     *

     * @param  string              $format  OPTIONAL Rule for formatting output. If null the default date format is used

     * @param  string              $type    OPTIONAL Type for the format string which overrides the standard setting

     * @param  string|Zend_Locale  $locale  OPTIONAL Locale for parsing input

     * @return string

     */

    public function toString($format = null, $type = null, $locale = null)

    {

        if (is_object($format)) {

            if ($format instanceof Zend_Locale) {

                $locale = $format;

                $format = null;

            } else {

                $format = (string) $format;

            }

        }

        if (is_object($type)) {

            if ($type instanceof Zend_Locale) {

                $locale = $type;

                $type   = null;

            } else {

                $type = (string) $type;

            }

        }

        if (($format !== null) && !defined($format)

            && ($format != 'ee') && ($format != 'ss') && ($format != 'GG') && ($format != 'MM') && ($format != 'EE') && ($format != 'TT')

            && Zend_Locale::isLocale($format, null, false)) {

            $locale = $format;

            $format = null;

        }

        if (($type !== null) and ($type != 'php') and ($type != 'iso') and

            Zend_Locale::isLocale($type, null, false)) {

            $locale = $type;

            $type = null;

        }

        if ($locale === null) {

            $locale = $this->getLocale();

        }

        if ($format === null) {

            $format = Zend_Locale_Format::getDateFormat($locale) . ' ' . Zend_Locale_Format::getTimeFormat($locale);

        } else if (((self::$_options['format_type'] == 'php') && ($type === null)) or ($type == 'php')) {

            $format = Zend_Locale_Format::convertPhpToIsoFormat($format);

        }

        return $this->date($this->_toToken($format, $locale), $this->getUnixTimestamp(), false);

    }

    /**

     * Returns a string representation of the date which is equal with the timestamp

     *

     * @return string

     */

    public function __toString()

    {

        return $this->toString(null, $this->_locale);

    }

    /**

     * Returns a integer representation of the object

     * But returns false when the given part is no value f.e. Month-Name

     *

     * @param  string|integer|Zend_Date  $part  OPTIONAL Defines the date or datepart to return as integer

     * @return integer|false

     */

    public function toValue($part = null)

    {

        $result = $this->get($part);

        if (is_numeric($result)) {

          return intval("$result");

        } else {

          return false;

        }

    }

    /**

     * Returns an array representation of the object

     *

     * @return array

     */

    public function toArray()

    {

        return array('day'       => $this->toString(self::DAY_SHORT, 'iso'),

                     'month'     => $this->toString(self::MONTH_SHORT, 'iso'),

                     'year'      => $this->toString(self::YEAR, 'iso'),

                     'hour'      => $this->toString(self::HOUR_SHORT, 'iso'),

                     'minute'    => $this->toString(self::MINUTE_SHORT, 'iso'),

                     'second'    => $this->toString(self::SECOND_SHORT, 'iso'),

                     'timezone'  => $this->toString(self::TIMEZONE, 'iso'),

                     'timestamp' => $this->toString(self::TIMESTAMP, 'iso'),

                     'weekday'   => $this->toString(self::WEEKDAY_8601, 'iso'),

                     'dayofyear' => $this->toString(self::DAY_OF_YEAR, 'iso'),

                     'week'      => $this->toString(self::WEEK, 'iso'),

                     'gmtsecs'   => $this->toString(self::TIMEZONE_SECS, 'iso'));

    }

    /**

     * Returns a representation of a date or datepart

     * This could be for example a localized monthname, the time without date,

     * the era or only the fractional seconds. There are about 50 different supported date parts.

     * For a complete list of supported datepart values look into the docu

     *

     * @param  string              $part    OPTIONAL Part of the date to return, if null the timestamp is returned

     * @param  string|Zend_Locale  $locale  OPTIONAL Locale for parsing input

     * @return string  date or datepart

     */

    public function get($part = null, $locale = null)

    {