"""

    Python implementation courtesy of Drew Csillag (StarMedia Network, Inc.)

    This version has been somewhat modified by MAL. It is still fairly

    rough though and not necessarily high performance... 

    XXX Still needs testing and checkup !!!

    WARNING: Using this file is only recommended if you really must

    use it for some reason. It is not being actively maintained !

"""

__version__ = '1.2.0 [Python]'

import time,types,exceptions,math

### Errors

class Error(exceptions.StandardError):

    pass

class RangeError(Error):

    pass

### Constants (internal use only)

month_offset=(

    (0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365),

    (0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366),

    )

days_in_month=(

    (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31),

    (31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31),

    )

### Helpers

def _IS_LEAPYEAR(d):

    return ((d.year % 4 == 0)

            and (

                (d.year % 100 != 0)

                or (d.year % 400 == 0)

                )

            )

def _YEAROFFSET(d):

    return (

        (d.year - 1) * 365

        + (d.year - 1) / 4

        - (d.year - 1) / 100

        + (d.year - 1) / 400

        )

class _EmptyClass:

    pass

def createEmptyObject(Class,

                      _EmptyClass=_EmptyClass):

    o = _EmptyClass()

    o.__class__ = Class

    return o

### DateTime class

class DateTime:

    def __init__(self, year, month=1, day=1, hour=0, minute=0, second=0.0):

        second=1.0 * second

        if month <= 0:

            raise RangeError, "year out of range (>0)"

        #calculate absolute date

        leap = (year % 4 == 0) and ((year % 100 != 0) or (year % 400 == 0))

        #Negative values indicate days relative to the years end

        if month < 0:

            month = month + 13 

        if not (month >= 1 and month <= 12):

            raise RangeError, "month out of range (1-12)"

        #Negative values indicate days relative to the months end

        if (day < 0):

            day = day + days_in_month[leap][month - 1] + 1;

        if not (day >= 1 and day <= days_in_month[leap][month - 1]):

            raise RangeError, "day out of range"

        year = year - 1

        yearoffset = year * 365 + year / 4 - year / 100 + year / 400

        year = year + 1

        absdate = day + month_offset[leap][month - 1] + yearoffset;

        self.absdate = absdate

        self.year = year

        self.month = month

        self.day = day

        self.day_of_week = (absdate - 1) % 7

        self.day_of_year = absdate - yearoffset

        self.days_in_month = days_in_month[leap][month - 1]

        comdate = absdate - 693594

        if not (hour >=0 and hour <= 23):

            raise RangeError, "hour out of range (0-23)"

        if not (minute >= 0 and minute <= 59):

            raise RangeError, "minute out of range (0-59)"

        if not (second >= 0.0 and

                (second < 60.0 or 

                 (hour == 23 and minute == 59 and second < 61.0))):

            raise RangeError, "second out of range (0.0 - <60.0; <61.0 for 23:59)"

        self.abstime = (hour * 3600 + minute * 60) + second

        self.hour = hour

        self.minute = minute

        self.second = second

        self.dst = -1

        self.tz = "???"

        self.is_leapyear = leap

        self.yearoffset = yearoffset

        self.iso_week = (self.year, self.day, self.day_of_week)

        if comdate < 0.0:

            comdate = comdate - self.abstime / 86400.0

        else:

            comdate = comdate + self.abstime / 86400.0

        self.comdate = comdate

    def COMDate(self):

        return self.comdate

    def __str__(self):

        return "%04d-%02d-%02d %02d:%02d:%05.2f" % (

            self.year, self.month, self.day, self.hour, self.minute,

            self.second)

    def __getattr__(self, attr):

        if attr == 'mjd':

            return (self - mjd0).days

        elif attr == 'jdn':

            return (self - jdn0).days

        elif attr == 'tjd':

            return (self - jdn0).days % 10000

        elif attr == 'tjd_myriad':

            return int((self - jdn0).days) / 10000 + 240

        elif attr == 'absdays':

            return self.absdate - 1 + self.abstime / 86400.0

        else:

            try:

                return self.__dict__[attr]

            except:

                raise AttributeError, attr

    def __mul__(self, other):

        raise TypeError, "bad operand type(s) for *"

    def __div__(self, other):

        raise TypeError, "bad operand type(s) for /"

    def strftime(self, format_string="%c"):

        "localtime([seconds]) -> (tm_year,tm_mon,tm_day,tm_hour,tm_min,tm_sec,tm_wday,tm_yday,tm_isdst)"

        # The map prevents a deprecation warning on Python 2.5.1 (Mac)

        # DeprecationWarning: integer argument expected, got float

        items = [int(item) for item in self.tuple()]

        return time.strftime(format_string, items)

    # Alias

    Format = strftime

    def tuple(self):

        return (self.year, self.month, self.day, self.hour, self.minute,

                self.second, self.day_of_week, self.day_of_year, -1)

        #return time.localtime(self.ticks())

    def absvalues(self):

        return self.absdate, self.abstime

    def __float__(self):

        return self.ticks()

    def __int__(self):

        return int(self.ticks)

    def ticks(self, offset=0.0, dst=-1):

        tticks=time.mktime(self.year, self.month, self.day, self.hour,

                           self.minute, self.second, self.day_of_week, 0, dst)

        if tticks == -1:

            raise OverflowError, "cannot convert value to a time value"

        ticks = (1.0*tticks) + (self.abstime - int(self.abstime)) - offset

        return ticks

    def gmticks(self, offset=0.0):

        from mx.DateTime import tz_offset

        return (self-tz_offset(self)).ticks()

    def gmtoffset(self):

        gmtime = DateTime(*time.gmtime()[:6])

        return - (now() - gmtime)

    def __repr__(self):

        return "<DateTime object for '%d-%02d-%02d %02d:%02d:%05.2f' at %x>"% (

            self.year, self.month, self.day, self.hour, self.minute,

            self.second, id(self))

    def __cmp__(self, other,

                cmp=cmp):

        if isinstance(other,DateTime):

            cmpdate = cmp(self.absdate,other.absdate)

            if cmpdate == 0:

                return cmp(self.abstime,other.abstime)

            else:

                return cmpdate

        elif type(other) == types.NoneType:

            return -1

        elif type(other) == types.StringType:

            return -1

        elif type(other) in (types.FloatType, types.LongType, types.IntType):

            return 1

        return -1

    def __hash__(self):

        return hash(self.tuple())

    def __add__(self, other):

        abstime=self.abstime

        absdate=self.absdate

        didadd=0

        if type(other) == types.InstanceType:

            if other.__class__ == DateTimeDelta:

                abstime = abstime + other.seconds

                didadd=1

            elif other.__class__ == DateTime:

                raise TypeError, "DateTime + DateTime is not supported"

            else:

                return other.__class__.__radd__(other, self)

        elif type(other) == types.IntType or type(other) == types.FloatType:

            abstime = abstime + other * 86400.0

            didadd=1

        if not didadd:

            raise TypeError, "cannot add these two types"

        if abstime >= 86400.0:

            days = abstime / 86400.0

            absdate = absdate + days

            abstime = abstime - (86400.0 * int(days))

            #print "absdate, abstime = ", absdate, abstime

        elif abstime < 0.0:

            days = int(((-abstime - 1) / 86400.0)) + 1

            #days = int(-abstime / 86400.0)

            absdate = absdate - days

            abstime = abstime + 86400.0 * int(days)

        if absdate < 1:

            raise RangeError, "underflow while adding"

        return DateTimeFromAbsDateTime(absdate, abstime)

    def __radd__(self, other):

        return DateTime.__add__(other, self)

    def __sub__(self, other):

        abstime=self.abstime

        absdate=self.absdate

        didsub=0

        if type(other) == types.InstanceType:

            if other.__class__ == DateTimeDelta:

                abstime = abstime - other.seconds

                didsub = 1

            elif other.__class__ == DateTime:

                absdate = absdate - other.absdate

                abstime = abstime - other.abstime

                return DateTimeDelta(absdate,0.0,0.0,abstime)

            else:

                return other.__rsub__(self)

        elif type(other) == types.IntType or type(other) == types.FloatType:

            abstime = abstime - other * 86400.0;

            didsub=1

        if not didsub:

            raise TypeError, "cannot subtract these two types"

        if abstime >= 86400.0:

            days = abstime / 86400.0

            absdate = absdate + days

            abstime = abstime - (86400.0 * days)

            #print "absdate, abstime = ", absdate, abstime

        elif abstime < 0.0:

            #print "abstime < 0"

            days = int( ((-abstime - 1) / 86400.0) + 1)

            #days = -abstime / 86400.0

            absdate = absdate - int(days)

            abstime = (1.0*abstime) + (86400.0 * days)

            #print "absdate, abstime", absdate, abstime

        if absdate < 1:

            raise RangeError, "underflow while adding"

        return DateTimeFromAbsDateTime(absdate, abstime)

# Constants

mjd0 = DateTime(1858, 11, 17)

jdn0 = DateTime(-4713, 1, 1, 12, 0, 0.0)

# Other DateTime constructors

def DateTimeFromCOMDate(comdate):

    absdate = int(comdate)

    abstime = (comdate - float(absdate)) * 86400.0

    if abstime < 0.0:

        abstime = -abstime

    absdate = absdate + 693594;

    dt = DateTimeFromAbsDateTime(absdate, abstime)

    dt.comdate = comdate

    return dt

def DateTimeFromAbsDateTime(absdate, abstime):

    # Create the object without calling its default constructor

    dt = createEmptyObject(DateTime)

    # Init. the object

    abstime=1.0 * abstime

    if abstime < 0 and abstime > -0.001: abstime = 0.0

    if not (absdate > 0):

        raise RangeError, "absdate out of range (>0)"

    if not (abstime >= 0.0 and abstime <= 86400.0):

        raise RangeError, "abstime out of range (0.0 - 86400.0) <%s>" % abstime

    dt.absdate=absdate

    dt.abstime=abstime

    #calculate com date

    comdate = 1.0 * (dt.absdate - 693594)

    if comdate < 0.0:

        comdate = comdate - dt.abstime / 86400.0

    else:

        comdate = comdate + dt.abstime / 86400.0

    dt.comdate = comdate

    #calculate the date

    #print "absdate=", absdate

    year = int((1.0 * absdate) / 365.2425)

    #newApproximation:

    while 1:

        #print "year=", year

        yearoffset = year * 365 + year / 4 - year / 100 + year / 400

        #print "yearoffset=", yearoffset

        #print "absdate=", absdate

        if yearoffset >= absdate:

            year = year - 1

            #print "year = ", year

            continue #goto newApproximation

        year = year + 1

        leap = (year % 4 == 0) and ((year % 100 != 0) or (year % 400 == 0))

        dayoffset = absdate - yearoffset

        #print "dayoffset=", dayoffset

        if dayoffset > 365 and leap == 0:

            #print "dayoffset=", dayoffset

            continue #goto newApproximation

        monthoffset = month_offset[leap]

        for month in range(1, 13):

            if monthoffset[month] >= dayoffset:

                break

        dt.year = year

        dt.month = month

        dt.day = dayoffset - month_offset[leap][month-1]

        dt.day_of_week = (dt.absdate - 1) % 7

        dt.day_of_year = dayoffset

        break

    #calculate the time

    inttime = int(abstime)

    hour = inttime / 3600

    minute = (inttime % 3600) / 60

    second = abstime - 1.0 * (hour*3600 + minute*60)

    dt.hour = hour;

    dt.minute = minute;