<?php

namespace PhpOffice\PhpSpreadsheet\Shared;


> use DateTime;


use DateTimeInterface;
use DateTimeZone;

< use PhpOffice\PhpSpreadsheet\Calculation\DateTime;



> use PhpOffice\PhpSpreadsheet\Calculation\DateTimeExcel;


use PhpOffice\PhpSpreadsheet\Calculation\Functions;
use PhpOffice\PhpSpreadsheet\Cell\Cell;

> use PhpOffice\PhpSpreadsheet\Exception;


use PhpOffice\PhpSpreadsheet\Exception as PhpSpreadsheetException;

> use PhpOffice\PhpSpreadsheet\Shared\Date as SharedDate;


use PhpOffice\PhpSpreadsheet\Style\NumberFormat;

class Date
{
    /** constants */
    const CALENDAR_WINDOWS_1900 = 1900; //    Base date of 1st Jan 1900 = 1.0
    const CALENDAR_MAC_1904 = 1904; //    Base date of 2nd Jan 1904 = 1.0

    /**
     * Names of the months of the year, indexed by shortname
     * Planned usage for locale settings.
     *
     * @var string[]
     */
    public static $monthNames = [
        'Jan' => 'January',
        'Feb' => 'February',
        'Mar' => 'March',
        'Apr' => 'April',
        'May' => 'May',
        'Jun' => 'June',
        'Jul' => 'July',
        'Aug' => 'August',
        'Sep' => 'September',
        'Oct' => 'October',
        'Nov' => 'November',
        'Dec' => 'December',
    ];

    /**
     * @var string[]
     */
    public static $numberSuffixes = [
        'st',
        'nd',
        'rd',
        'th',
    ];

    /**
     * Base calendar year to use for calculations
     * Value is either CALENDAR_WINDOWS_1900 (1900) or CALENDAR_MAC_1904 (1904).
     *
     * @var int
     */
    protected static $excelCalendar = self::CALENDAR_WINDOWS_1900;

    /**
     * Default timezone to use for DateTime objects.
     *
     * @var null|DateTimeZone
     */
    protected static $defaultTimeZone;

    /**
     * Set the Excel calendar (Windows 1900 or Mac 1904).
     *

<      * @param int $baseDate Excel base date (1900 or 1904)



>      * @param int $baseYear Excel base date (1900 or 1904)


     *
     * @return bool Success or failure
     */

<     public static function setExcelCalendar($baseDate)



>     public static function setExcelCalendar($baseYear)


    {
        if (

<             ($baseDate == self::CALENDAR_WINDOWS_1900) ||
<             ($baseDate == self::CALENDAR_MAC_1904)



>             ($baseYear == self::CALENDAR_WINDOWS_1900) ||
>             ($baseYear == self::CALENDAR_MAC_1904)


        ) {

<             self::$excelCalendar = $baseDate;



>             self::$excelCalendar = $baseYear;



            return true;
        }

        return false;
    }

    /**
     * Return the Excel calendar (Windows 1900 or Mac 1904).
     *
     * @return int Excel base date (1900 or 1904)
     */
    public static function getExcelCalendar()
    {
        return self::$excelCalendar;
    }

    /**
     * Set the Default timezone to use for dates.
     *

<      * @param DateTimeZone|string $timeZone The timezone to set for all Excel datetimestamp to PHP DateTime Object conversions



>      * @param null|DateTimeZone|string $timeZone The timezone to set for all Excel datetimestamp to PHP DateTime Object conversions


     *
     * @return bool Success or failure
     */
    public static function setDefaultTimezone($timeZone)
    {
        try {
            $timeZone = self::validateTimeZone($timeZone);
            self::$defaultTimeZone = $timeZone;
            $retval = true;
        } catch (PhpSpreadsheetException $e) {
            $retval = false;
        }

        return $retval;
    }

    /**

<      * Return the Default timezone being used for dates.
<      *
<      * @return DateTimeZone The timezone being used as default for Excel timestamp to PHP DateTime object



>      * Return the Default timezone, or UTC if default not set.
>      */
>     public static function getDefaultTimezone(): DateTimeZone
>     {
>         return self::$defaultTimeZone ?? new DateTimeZone('UTC');
>     }
> 
>     /**
>      * Return the Default timezone, or local timezone if default is not set.


     */

<     public static function getDefaultTimezone()



>     public static function getDefaultOrLocalTimezone(): DateTimeZone


    {

<         if (self::$defaultTimeZone === null) {
<             self::$defaultTimeZone = new DateTimeZone('UTC');



>         return self::$defaultTimeZone ?? new DateTimeZone(date_default_timezone_get());


        }


>     /**
        return self::$defaultTimeZone;
>      * Return the Default timezone even if null.
    }
>      */

>     public static function getDefaultTimezoneOrNull(): ?DateTimeZone
    /**
>     {


     * Validate a timezone.
     *

<      * @param DateTimeZone|string $timeZone The timezone to validate, either as a timezone string or object



>      * @param null|DateTimeZone|string $timeZone The timezone to validate, either as a timezone string or object


     *

<      * @return DateTimeZone The timezone as a timezone object



>      * @return ?DateTimeZone The timezone as a timezone object


     */
    private static function validateTimeZone($timeZone)
    {

<         if ($timeZone instanceof DateTimeZone) {



>         if ($timeZone instanceof DateTimeZone || $timeZone === null) {


            return $timeZone;
        }
        if (in_array($timeZone, DateTimeZone::listIdentifiers(DateTimeZone::ALL_WITH_BC))) {
            return new DateTimeZone($timeZone);
        }

        throw new PhpSpreadsheetException('Invalid timezone');
    }

    /**

>      * @param mixed $value Converts a date/time in ISO-8601 standard format date string to an Excel
     * Convert a MS serialized datetime value from Excel to a PHP Date/Time object.
>      *                         serialized timestamp.
     *
>      *                     See https://en.wikipedia.org/wiki/ISO_8601 for details of the ISO-8601 standard format.
     * @param float|int $excelTimestamp MS Excel serialized date/time value
>      *
     * @param null|DateTimeZone|string $timeZone The timezone to assume for the Excel timestamp,
>      * @return float|int
     *                                                                        if you don't want to treat it as a UTC value
>      */
     *                                                                    Use the default (UST) unless you absolutely need a conversion
>     public static function convertIsoDate($value)
     *
>     {
     * @return \DateTime PHP date/time object
>         if (!is_string($value)) {
     */
>             throw new Exception('Non-string value supplied for Iso Date conversion');
    public static function excelToDateTimeObject($excelTimestamp, $timeZone = null)
>         }
    {
> 
        $timeZone = ($timeZone === null) ? self::getDefaultTimezone() : self::validateTimeZone($timeZone);
>         $date = new DateTime($value);
        if (Functions::getCompatibilityMode() == Functions::COMPATIBILITY_EXCEL) {
>         $dateErrors = DateTime::getLastErrors();
            if ($excelTimestamp < 1.0) {
> 
                // Unix timestamp base date
>         if (is_array($dateErrors) && ($dateErrors['warning_count'] > 0 || $dateErrors['error_count'] > 0)) {
                $baseDate = new \DateTime('1970-01-01', $timeZone);
>             throw new Exception("Invalid string $value supplied for datatype Date");
            } else {
>         }
                // MS Excel calendar base dates
> 
                if (self::$excelCalendar == self::CALENDAR_WINDOWS_1900) {
>         $newValue = SharedDate::PHPToExcel($date);
                    // Allow adjustment for 1900 Leap Year in MS Excel
>         if ($newValue === false) {
                    $baseDate = ($excelTimestamp < 60) ? new \DateTime('1899-12-31', $timeZone) : new \DateTime('1899-12-30', $timeZone);
>             throw new Exception("Invalid string $value supplied for datatype Date");
                } else {
>         }
                    $baseDate = new \DateTime('1904-01-01', $timeZone);
> 
                }
>         if (preg_match('/^\\s*\\d?\\d:\\d\\d(:\\d\\d([.]\\d+)?)?\\s*(am|pm)?\\s*$/i', $value) == 1) {
            }
>             $newValue = fmod($newValue, 1.0);
        } else {
>         }
            $baseDate = new \DateTime('1899-12-30', $timeZone);
> 
        }
>         return $newValue;

>     }
        $days = floor($excelTimestamp);
> 
        $partDay = $excelTimestamp - $days;
>     /**



<      *                                                                    Use the default (UST) unless you absolutely need a conversion



>      *                                           Use the default (UTC) unless you absolutely need a conversion



<      * @return \DateTime PHP date/time object



>      * @return DateTime PHP date/time object



<             if ($excelTimestamp < 1.0) {



>             if ($excelTimestamp < 1 && self::$excelCalendar === self::CALENDAR_WINDOWS_1900) {



<                 $baseDate = new \DateTime('1970-01-01', $timeZone);



>                 $baseDate = new DateTime('1970-01-01', $timeZone);



<                     $baseDate = ($excelTimestamp < 60) ? new \DateTime('1899-12-31', $timeZone) : new \DateTime('1899-12-30', $timeZone);



>                     $baseDate = ($excelTimestamp < 60) ? new DateTime('1899-12-31', $timeZone) : new DateTime('1899-12-30', $timeZone);



<                     $baseDate = new \DateTime('1904-01-01', $timeZone);



>                     $baseDate = new DateTime('1904-01-01', $timeZone);



<             $baseDate = new \DateTime('1899-12-30', $timeZone);



>             $baseDate = new DateTime('1899-12-30', $timeZone);


            $days = '+' . $days;
        }
        $interval = $days . ' days';

        return $baseDate->modify($interval)
            ->setTime((int) $hours, (int) $minutes, (int) $seconds);
    }

    /**
     * Convert a MS serialized datetime value from Excel to a unix timestamp.

>      * The use of Unix timestamps, and therefore this function, is discouraged.
     *
>      * They are not Y2038-safe on a 32-bit system, and have no timezone info.


     * @param float|int $excelTimestamp MS Excel serialized date/time value
     * @param null|DateTimeZone|string $timeZone The timezone to assume for the Excel timestamp,
     *                                                                        if you don't want to treat it as a UTC value

<      *                                                                    Use the default (UST) unless you absolutely need a conversion



>      *                                               Use the default (UTC) unless you absolutely need a conversion


     *
     * @return int Unix timetamp for this date/time
     */
    public static function excelToTimestamp($excelTimestamp, $timeZone = null)
    {
        return (int) self::excelToDateTimeObject($excelTimestamp, $timeZone)
            ->format('U');
    }

    /**
     * Convert a date from PHP to an MS Excel serialized date/time value.
     *

<      * @param mixed $dateValue Unix Timestamp or PHP DateTime object or a string



>      * @param mixed $dateValue PHP DateTime object or a string - Unix timestamp is also permitted, but discouraged;
>      *    not Y2038-safe on a 32-bit system, and no timezone info


     *

<      * @return bool|float Excel date/time value



>      * @return false|float Excel date/time value


     *                                  or boolean FALSE on failure
     */
    public static function PHPToExcel($dateValue)
    {
        if ((is_object($dateValue)) && ($dateValue instanceof DateTimeInterface)) {
            return self::dateTimeToExcel($dateValue);
        } elseif (is_numeric($dateValue)) {
            return self::timestampToExcel($dateValue);
        } elseif (is_string($dateValue)) {
            return self::stringToExcel($dateValue);
        }

        return false;
    }

    /**
     * Convert a PHP DateTime object to an MS Excel serialized date/time value.
     *
     * @param DateTimeInterface $dateValue PHP DateTime object
     *
     * @return float MS Excel serialized date/time value
     */
    public static function dateTimeToExcel(DateTimeInterface $dateValue)
    {
        return self::formattedPHPToExcel(
            (int) $dateValue->format('Y'),
            (int) $dateValue->format('m'),
            (int) $dateValue->format('d'),
            (int) $dateValue->format('H'),
            (int) $dateValue->format('i'),
            (int) $dateValue->format('s')
        );
    }

    /**
     * Convert a Unix timestamp to an MS Excel serialized date/time value.

>      * The use of Unix timestamps, and therefore this function, is discouraged.
     *
>      * They are not Y2038-safe on a 32-bit system, and have no timezone info.



<      * @param int $dateValue Unix Timestamp



>      * @param float|int|string $unixTimestamp Unix Timestamp


     *

<      * @return float MS Excel serialized date/time value



>      * @return false|float MS Excel serialized date/time value


     */

<     public static function timestampToExcel($dateValue)



>     public static function timestampToExcel($unixTimestamp)


    {

<         if (!is_numeric($dateValue)) {



>         if (!is_numeric($unixTimestamp)) {


            return false;
        }


<         return self::dateTimeToExcel(new \DateTime('@' . $dateValue));



>         return self::dateTimeToExcel(new DateTime('@' . $unixTimestamp));


    }

    /**
     * formattedPHPToExcel.
     *
     * @param int $year
     * @param int $month
     * @param int $day
     * @param int $hours
     * @param int $minutes
     * @param int $seconds
     *
     * @return float Excel date/time value
     */
    public static function formattedPHPToExcel($year, $month, $day, $hours = 0, $minutes = 0, $seconds = 0)
    {
        if (self::$excelCalendar == self::CALENDAR_WINDOWS_1900) {
            //
            //    Fudge factor for the erroneous fact that the year 1900 is treated as a Leap Year in MS Excel
            //    This affects every date following 28th February 1900
            //
            $excel1900isLeapYear = true;
            if (($year == 1900) && ($month <= 2)) {
                $excel1900isLeapYear = false;
            }
            $myexcelBaseDate = 2415020;
        } else {
            $myexcelBaseDate = 2416481;
            $excel1900isLeapYear = false;
        }

        //    Julian base date Adjustment
        if ($month > 2) {
            $month -= 3;
        } else {
            $month += 9;
            --$year;
        }

        //    Calculate the Julian Date, then subtract the Excel base date (JD 2415020 = 31-Dec-1899 Giving Excel Date of 0)

<         $century = substr($year, 0, 2);
<         $decade = substr($year, 2, 2);



>         $century = (int) substr((string) $year, 0, 2);
>         $decade = (int) substr((string) $year, 2, 2);


        $excelDate = floor((146097 * $century) / 4) + floor((1461 * $decade) / 4) + floor((153 * $month + 2) / 5) + $day + 1721119 - $myexcelBaseDate + $excel1900isLeapYear;

        $excelTime = (($hours * 3600) + ($minutes * 60) + $seconds) / 86400;

        return (float) $excelDate + $excelTime;
    }

    /**
     * Is a given cell a date/time?
     *

>      * @param mixed $value
     * @return bool
>      *


     */

<     public static function isDateTime(Cell $pCell)



>     public static function isDateTime(Cell $cell, $value = null, bool $dateWithoutTimeOkay = true)


    {

<         return is_numeric($pCell->getCalculatedValue()) &&



>         $result = false;
>         $worksheet = $cell->getWorksheetOrNull();
>         $spreadsheet = ($worksheet === null) ? null : $worksheet->getParent();
>         if ($worksheet !== null && $spreadsheet !== null) {
>             $index = $spreadsheet->getActiveSheetIndex();
>             $selected = $worksheet->getSelectedCells();
> 
>             try {
>                 $result = is_numeric($value ?? $cell->getCalculatedValue()) &&


            self::isDateTimeFormat(

<                 $pCell->getWorksheet()->getStyle(
<                     $pCell->getCoordinate()
<                 )->getNumberFormat()



>                         $worksheet->getStyle(
>                             $cell->getCoordinate()
>                         )->getNumberFormat(),
>                         $dateWithoutTimeOkay


            );

>             } catch (Exception $e) {
    }
>                 // Result is already false, so no need to actually do anything here

>             }
    /**
>             $worksheet->setSelectedCells($selected);
     * Is a given number format a date/time?
>             $spreadsheet->setActiveSheetIndex($index);
     *
>         }
     * @return bool
> 
     */
>         return $result;



<      * Is a given number format a date/time?



>      * Is a given NumberFormat code a date/time format code?



<     public static function isDateTimeFormat(NumberFormat $pFormat)



>     public static function isDateTimeFormat(NumberFormat $excelFormatCode, bool $dateWithoutTimeOkay = true)



<         return self::isDateTimeFormatCode($pFormat->getFormatCode());



>         return self::isDateTimeFormatCode((string) $excelFormatCode->getFormatCode(), $dateWithoutTimeOkay);


    }


<     private static $possibleDateFormatCharacters = 'eymdHs';



>     private const POSSIBLE_DATETIME_FORMAT_CHARACTERS = 'eymdHs';
>     private const POSSIBLE_TIME_FORMAT_CHARACTERS = 'Hs'; // note - no 'm' due to ambiguity



    /**
     * Is a given number format code a date/time?
     *

<      * @param string $pFormatCode



>      * @param string $excelFormatCode


     *
     * @return bool
     */

<     public static function isDateTimeFormatCode($pFormatCode)



>     public static function isDateTimeFormatCode($excelFormatCode, bool $dateWithoutTimeOkay = true)


    {

<         if (strtolower($pFormatCode) === strtolower(NumberFormat::FORMAT_GENERAL)) {



>         if (strtolower($excelFormatCode) === strtolower(NumberFormat::FORMAT_GENERAL)) {


            //    "General" contains an epoch letter 'e', so we trap for it explicitly here (case-insensitive check)
            return false;
        }

<         if (preg_match('/[0#]E[+-]0/i', $pFormatCode)) {



>         if (preg_match('/[0#]E[+-]0/i', $excelFormatCode)) {


            //    Scientific format
            return false;
        }

        // Switch on formatcode

<         switch ($pFormatCode) {
<             //    Explicitly defined date formats
<             case NumberFormat::FORMAT_DATE_YYYYMMDD:
<             case NumberFormat::FORMAT_DATE_YYYYMMDD2:
<             case NumberFormat::FORMAT_DATE_DDMMYYYY:
<             case NumberFormat::FORMAT_DATE_DMYSLASH:
<             case NumberFormat::FORMAT_DATE_DMYMINUS:
<             case NumberFormat::FORMAT_DATE_DMMINUS:
<             case NumberFormat::FORMAT_DATE_MYMINUS:
<             case NumberFormat::FORMAT_DATE_DATETIME:
<             case NumberFormat::FORMAT_DATE_TIME1:
<             case NumberFormat::FORMAT_DATE_TIME2:
<             case NumberFormat::FORMAT_DATE_TIME3:
<             case NumberFormat::FORMAT_DATE_TIME4:
<             case NumberFormat::FORMAT_DATE_TIME5:
<             case NumberFormat::FORMAT_DATE_TIME6:
<             case NumberFormat::FORMAT_DATE_TIME7:
<             case NumberFormat::FORMAT_DATE_TIME8:
<             case NumberFormat::FORMAT_DATE_YYYYMMDDSLASH:
<             case NumberFormat::FORMAT_DATE_XLSX14:
<             case NumberFormat::FORMAT_DATE_XLSX15:
<             case NumberFormat::FORMAT_DATE_XLSX16:
<             case NumberFormat::FORMAT_DATE_XLSX17:
<             case NumberFormat::FORMAT_DATE_XLSX22:
<                 return true;



>         if (in_array($excelFormatCode, NumberFormat::DATE_TIME_OR_DATETIME_ARRAY, true)) {
>             return $dateWithoutTimeOkay || in_array($excelFormatCode, NumberFormat::TIME_OR_DATETIME_ARRAY);


        }

        //    Typically number, currency or accounting (or occasionally fraction) formats

<         if ((substr($pFormatCode, 0, 1) == '_') || (substr($pFormatCode, 0, 2) == '0 ')) {



>         if ((substr($excelFormatCode, 0, 1) == '_') || (substr($excelFormatCode, 0, 2) == '0 ')) {


            return false;
        }
        // Some "special formats" provided in German Excel versions were detected as date time value,
        // so filter them out here - "\C\H\-00000" (Switzerland) and "\D-00000" (Germany).

<         if (\strpos($pFormatCode, '-00000') !== false) {



>         if (\strpos($excelFormatCode, '-00000') !== false) {


            return false;
        }

>         $possibleFormatCharacters = $dateWithoutTimeOkay ? self::POSSIBLE_DATETIME_FORMAT_CHARACTERS : self::POSSIBLE_TIME_FORMAT_CHARACTERS;


        // Try checking for any of the date formatting characters that don't appear within square braces

<         if (preg_match('/(^|\])[^\[]*[' . self::$possibleDateFormatCharacters . ']/i', $pFormatCode)) {



>         if (preg_match('/(^|\])[^\[]*[' . $possibleFormatCharacters . ']/i', $excelFormatCode)) {


            //    We might also have a format mask containing quoted strings...
            //        we don't want to test for any of our characters within the quoted blocks

<             if (strpos($pFormatCode, '"') !== false) {



>             if (strpos($excelFormatCode, '"') !== false) {


                $segMatcher = false;

<                 foreach (explode('"', $pFormatCode) as $subVal) {



>                 foreach (explode('"', $excelFormatCode) as $subVal) {


                    //    Only test in alternate array entries (the non-quoted blocks)

>                     $segMatcher = $segMatcher === false;


                    if (

<                         ($segMatcher = !$segMatcher) &&
<                         (preg_match('/(^|\])[^\[]*[' . self::$possibleDateFormatCharacters . ']/i', $subVal))



>                         $segMatcher &&
>                         (preg_match('/(^|\])[^\[]*[' . $possibleFormatCharacters . ']/i', $subVal))


                    ) {
                        return true;
                    }
                }

                return false;
            }

            return true;
        }

        // No date...
        return false;
    }

    /**
     * Convert a date/time string to Excel time.
     *
     * @param string $dateValue Examples: '2009-12-31', '2009-12-31 15:59', '2009-12-31 15:59:10'
     *
     * @return false|float Excel date/time serial value
     */
    public static function stringToExcel($dateValue)
    {
        if (strlen($dateValue) < 2) {
            return false;
        }
        if (!preg_match('/^(\d{1,4}[ \.\/\-][A-Z]{3,9}([ \.\/\-]\d{1,4})?|[A-Z]{3,9}[ \.\/\-]\d{1,4}([ \.\/\-]\d{1,4})?|\d{1,4}[ \.\/\-]\d{1,4}([ \.\/\-]\d{1,4})?)( \d{1,2}:\d{1,2}(:\d{1,2})?)?$/iu', $dateValue)) {
            return false;
        }


<         $dateValueNew = DateTime::DATEVALUE($dateValue);



>         $dateValueNew = DateTimeExcel\DateValue::fromString($dateValue);




<         if ($dateValueNew === Functions::VALUE()) {



>         if (!is_float($dateValueNew)) {


            return false;
        }

        if (strpos($dateValue, ':') !== false) {

<             $timeValue = DateTime::TIMEVALUE($dateValue);
<             if ($timeValue === Functions::VALUE()) {



>             $timeValue = DateTimeExcel\TimeValue::fromString($dateValue);
>             if (!is_float($timeValue)) {


                return false;
            }
            $dateValueNew += $timeValue;
        }

        return $dateValueNew;
    }

    /**
     * Converts a month name (either a long or a short name) to a month number.
     *

<      * @param string $month Month name or abbreviation



>      * @param string $monthName Month name or abbreviation


     *
     * @return int|string Month number (1 - 12), or the original string argument if it isn't a valid month name
     */

<     public static function monthStringToNumber($month)



>     public static function monthStringToNumber($monthName)


    {
        $monthIndex = 1;
        foreach (self::$monthNames as $shortMonthName => $longMonthName) {

<             if (($month === $longMonthName) || ($month === $shortMonthName)) {



>             if (($monthName === $longMonthName) || ($monthName === $shortMonthName)) {


                return $monthIndex;
            }
            ++$monthIndex;
        }


<         return $month;



>         return $monthName;


    }

    /**
     * Strips an ordinal from a numeric value.
     *
     * @param string $day Day number with an ordinal
     *
     * @return int|string The integer value with any ordinal stripped, or the original string argument if it isn't a valid numeric
     */
    public static function dayStringToNumber($day)
    {
        $strippedDayValue = (str_replace(self::$numberSuffixes, '', $day));
        if (is_numeric($strippedDayValue)) {
            return (int) $strippedDayValue;
        }

        return $day;

>     }
    }
> 
}
>     public static function dateTimeFromTimestamp(string $date, ?DateTimeZone $timeZone = null): DateTime
>     {
>         $dtobj = DateTime::createFromFormat('U', $date) ?: new DateTime();
>         $dtobj->setTimeZone($timeZone ?? self::getDefaultOrLocalTimezone());
> 
>         return $dtobj;
>     }
> 
>     public static function formattedDateTimeFromTimestamp(string $date, string $format, ?DateTimeZone $timeZone = null): string
>     {
>         $dtobj = self::dateTimeFromTimestamp($date, $timeZone);
> 
>         return $dtobj->format($format);