""" Python part of the low-level DateTime[Delta] type implementation.

    Copyright (c) 1998-2001, Marc-Andre Lemburg; mailto:mal@lemburg.com

    Copyright (c) 2000-2007, eGenix.com Software GmbH; mailto:info@egenix.com

    See the documentation for further information on copyrights,

    or contact the author. All Rights Reserved.

"""

# Import the python implementation module

from mxDateTime_python import *

from mxDateTime_python import __version__

# Singletons

oneSecond = DateTimeDelta(0,0,0,1)

oneMinute = DateTimeDelta(0,0,1)

oneHour = DateTimeDelta(0,1)

oneDay = DateTimeDelta(1)

oneWeek = DateTimeDelta(7)

Epoch = DateTimeFromAbsDateTime(1,0)

# Shortcuts for pickle; for backward compatibility only (they are now

# defined in __init__.py to further reduce the pickles length)

def _DT(absdate,abstime):

    return DateTimeFromAbsDateTime(absdate,abstime)

def _DTD(seconds):

    return DateTimeDeltaFromSeconds(seconds)

# Module init

class modinit:

    global _time,_string,_math,_types

    import time,string,math,types

    _time = time

    _string = string

    _math = math

    _types = types

del modinit

### Helpers

def _isstring(arg,

              isinstance=isinstance, types=_types):

    if isinstance(arg, types.StringType):

        return 1

    try:

        if isinstance(arg, types.UnicodeType):

            return 1

    except AttributeError:

        pass

    return 0

### Compatibility APIs

# Aliases and functions to make 'from mx.DateTime import *' work much

# like 'from time import *'

def localtime(ticks=None,

              # Locals:

              time=_time.time,float=float,localtime=_time.localtime,

              round=round,int=int,DateTime=DateTime,floor=_math.floor):

    """localtime(ticks=None)

       Construct a DateTime instance using local time from ticks.  If

       ticks are not given, it defaults to the current time.  The

       result is similar to time.localtime(). Fractions of a second

       are rounded to the nearest micro-second.

    """

    if ticks is None:

        ticks = time()

    else:

        ticks = float(ticks)

    ticks = round(ticks, 6)

    fticks = floor(ticks)

    Y,M,D,h,m,s = localtime(fticks)[:6]

    s = s + (ticks - fticks)

    return DateTime(Y,M,D,h,m,s)

def gmtime(ticks=None,

           # Locals:

           time=_time.time,float=float,gmtime=_time.gmtime,

           round=round,int=int,DateTime=DateTime,floor=_math.floor):

    """gmtime(ticks=None)

       Construct a DateTime instance using UTC time from ticks.  If

       ticks are not given, it defaults to the current time.  The

       result is similar to time.gmtime(). Fractions of a second are

       rounded to the nearest micro-second.

    """

    if ticks is None:

        ticks = time()

    else:

        ticks = float(ticks)

    ticks = round(ticks, 6)

    fticks = floor(ticks)

    Y,M,D,h,m,s = gmtime(ticks)[:6]

    s = s + (ticks - fticks)

    return DateTime(Y,M,D,h,m,s)

def mktime((year,month,day,hour,minute,second,dow,doy,dst),

           # Locals:

           DateTime=DateTime):

    """mktime((year,month,day,hour,minute,second,dow,doy,dst))

       Same as the DateTime() constructor accept that the interface

       used is compatible to the similar time.mktime() API.

       Note that the tuple elements dow, doy and dst are not used in

       any way.

    """

    return DateTime(year,month,day,hour,minute,second)

def ctime(datetime):

    """ctime(datetime)

       Returns a string representation of the given DateTime instance

       using the current locale's default settings.

    """

    return datetime.strftime('%c')

def today(hour=0,minute=0,second=0.0,

          # Locals:

          localtime=_time.localtime,time=_time.time,DateTime=DateTime):

    """today(hour=0,minute=0,second=0.0)

       Returns a DateTime instance for today (in local time) at the

       given time (defaults to midnight).

    """

    Y,M,D = localtime(time())[:3]

    return DateTime(Y,M,D,hour,minute,second)

def TimeDelta(hours=0.0,minutes=0.0,seconds=0.0,

              # Locals:

              DateTimeDelta=DateTimeDelta):

    """TimeDelta(hours=0.0,minutes=0.0,seconds=0.0)

       Returns a DateTimeDelta-object reflecting the given time

       delta. Seconds can be given as float to indicate fractions.

    """

    return DateTimeDelta(0,hours,minutes,seconds)

def gm2local(datetime):

    """ gm2local(datetime)

        Convert a DateTime instance holding UTC time to a DateTime

        instance using local time.

    """

    return localtime(datetime.gmticks())

def local2gm(datetime):

    """ local2gm(datetime)

        Convert a DateTime instance holding local time to a DateTime

        instance using UTC time.

    """

    return gmtime(datetime.ticks())

# Alias

gmt = utc

# Default value for DateTimeFromTJD's tjd_myriad parameter

current_myriad = localtime().tjd_myriad

def DateTimeFromTJD(tjd,tjd_myriad=current_myriad):

    """ DateTimeFromTJD(tjd[,myriad])

        Return a DateTime instance for the given Truncated Julian Day.

        myriad defaults to the TJD myriad current at package import

        time.

        Note that this version of Truncated Julian Day number does

        real truncation of important information. It's use is

        discouraged and unsupported.

    """

    return DateTimeFromAbsDays(tjd + tjd_myriad * 10000.0 - 1721425.0)

def DateTimeFromJDN(jdn):

    """ DateTimeFromJDN(jdn)

        Return a DateTime instance for the given Julian Day Number.

        References:

        -----------

        Gregorian 2000-01-01 12:00:00 corresponds to JDN 2451545.0.

        Gregorian 1858-11-17 00:00:00.00 corresponds to JDN 2400000.5; MJD 0.0.

        Julian -4712-01-01 12:00:00.00 corresponds to JDN 0.0.

        Gregorian -4713-11-24 12:00:00.00 corresponds to JDN 0.0.

    """

    return DateTimeFromAbsDays(jdn - 1721425.5)

def DateTimeFromMJD(mjd):

    """ DateTimeFromMJD(mjd)

        Return a DateTime instance for the given Modified Julian Day

        (MJD). The MJD is calculated the same way as the JDN except

        that 1858-11-17 00:00:00.00 is taken as origin of the scale.

    """

    return DateTimeFromAbsDays(mjd + 678575.0)

def DateTimeFrom(*args, **kws):

    """ DateTimeFrom(*args, **kws)

        Generic DateTime instance constructor. Can handle parsing

        strings, numbers and keywords.

        XXX Add support for Unicode.

    """

    if len(args) == 1:

        # Single argument

        arg = args[0]

        argtype = type(arg)

        if _isstring(arg):

            import Parser

            return apply(Parser.DateTimeFromString, args, kws)

        elif argtype is DateTimeType:

            return arg

        elif argtype is DateTimeDeltaType:

            raise TypeError,'cannot convert DateTimeDelta to DateTime'

        else:

            try:

                value = float(arg)

            except (TypeError, ValueError):

                value = int(arg)

            assert not kws

            return DateTimeFromTicks(value)

    elif len(args) > 1:

        # More than one argument

        if len(args) == 2 and _isstring(args[0]) and _isstring(args[1]):

            # interpret as date and time string

            import Parser

            return apply(Parser.DateTimeFromString,

                         (args[0] + ' ' + args[1],),

                         kws)

        # Assume the arguments are the same as for DateTime()

        return apply(DateTime, args, kws)

    elif len(kws) > 0:

        # Keyword arguments; add defaults... today at 0:00:00

        hour = kws.get('hour',0)

        minute = kws.get('minute',0)

        second = kws.get('second',0)

        today = now()

        day = kws.get('day',today.day)

        month = kws.get('month',today.month)

        year = kws.get('year',today.year)

        return DateTime(year,month,day,hour,minute,second)

    else:

        raise TypeError,'cannot convert arguments to DateTime'

def DateTimeDeltaFrom(*args, **kws):

    """ DateTimeDeltaFrom(*args, **kws)

        Generic DateTimeDelta instance constructor. Can handle parsing

        strings, numbers and keywords.

        XXX Add support for Unicode.

    """

    if len(args) == 1:

        # Single argument

        arg = args[0]

        if _isstring(arg):

            import Parser

            return apply(Parser.DateTimeDeltaFromString, args, kws)

        elif type(arg) is DateTimeDeltaType:

            return arg

        elif type(arg) is DateTimeType:

            raise TypeError,'cannot convert DateTime to DateTimeDelta'

        else:

            try:

                value = float(arg)

            except TypeError:

                value = int(arg)

            assert not kws

            return DateTimeDeltaFromSeconds(value)

    elif len(args) > 1:

        # Assume the arguments are the same as for DateTimeDelta()

        return apply(DateTimeDelta, args, kws)

    elif len(kws) > 0:

        # Keyword arguments; default: 00:00:00:00.00

        hours = kws.get('hours',0)

        minutes = kws.get('minutes',0)

        seconds = kws.get('seconds',0.0)

        days = kws.get('days',0)

        return DateTimeDelta(days,hours,minutes,seconds)

    else:

        raise TypeError,'cannot convert arguments to DateTimeDelta'

def TimeDeltaFrom(*args, **kws):

    """ TimeDeltaFrom(*args, **kws)

        Generic TimeDelta instance constructor. Can handle parsing

        strings, numbers and keywords.

        XXX Add support for Unicode.

    """

    if len(args) > 1:

        # Assume the arguments are the same as for TimeDelta(): without

        # days part !

        return apply(DateTimeDelta, (0,)+args, kws)

    else:

        # Otherwise treat the arguments just like for DateTimeDelta

        # instances.

        return apply(DateTimeDeltaFrom, args, kws)

def DateFromTicks(ticks,

                  # Locals:

                  DateTime=DateTime,localtime=_time.localtime):

    """ DateFromTicks(ticks)

        Constructs a DateTime instance pointing to the local time date

        at 00:00:00.00 (midnight) indicated by the given ticks value.

        The time part is ignored.

    """

    return apply(DateTime, localtime(ticks)[:3])

def TimestampFromTicks(ticks,

                       # Locals:

                       DateTime=DateTime,localtime=_time.localtime):

    """ TimestampFromTicks(ticks)

        Constructs a DateTime instance pointing to the local date and

        time indicated by the given ticks value.

    """

    return apply(DateTime, localtime(ticks)[:6])

def TimeFromTicks(ticks,

                  # Locals:

                  DateTimeDelta=DateTimeDelta,localtime=_time.localtime):

    """ TimeFromTicks(ticks)

        Constructs a DateTimeDelta instance pointing to the local time

        indicated by the given ticks value. The date part is ignored.

    """

    return apply(DateTimeDelta, (0,) + localtime(ticks)[3:6])

# Aliases

utctime = gmtime

utc2local = gm2local

local2utc = local2gm

DateTimeFromTicks = localtime

Date = DateTime

Time = TimeDelta

Timestamp = DateTime

DateFrom = DateTimeFrom # XXX should only parse the date part !

TimeFrom = TimeDeltaFrom

TimestampFrom = DateTimeFrom

GregorianDateTime = DateTime

GregorianDate = Date

JulianDate = JulianDateTime

### For backward compatibility (these are depreciated):

def gmticks(datetime):

    """gmticks(datetime)

       [DEPRECIATED: use the .gmticks() method]

       Returns a ticks value based on the values stored in

       datetime under the assumption that they are given in UTC,

       rather than local time.

    """

    return datetime.gmticks()

# Alias

utcticks = gmticks

def tz_offset(datetime,

              # Locals:

              oneSecond=oneSecond):

    """tz_offset(datetime)

       [DEPRECIATED: use the .gmtoffset() method]

       Returns a DateTimeDelta instance representing the UTC

       offset for datetime assuming that the stored values refer

       to local time. If you subtract this value from datetime,

       you'll get UTC time.

    """

    return datetime.gmtoffset()

### Constants (only English; see Locale.py for other languages)

# Weekdays

Monday =        0

Tuesday =       1

Wednesday =     2

Thursday =      3

Friday =        4

Saturday =      5