"""

PHP date() style date formatting

See http://www.php.net/date for format strings

Usage:

>>> import datetime

>>> d = datetime.datetime.now()

>>> df = DateFormat(d)

>>> print df.format('jS F Y H:i')

7th October 2003 11:39

>>>

"""

from django.utils.dates import MONTHS, MONTHS_3, MONTHS_AP, WEEKDAYS, WEEKDAYS_ABBR

from django.utils.tzinfo import LocalTimezone

from django.utils.translation import ugettext as _

from django.utils.encoding import force_unicode

from calendar import isleap, monthrange

import re, time

re_formatchars = re.compile(r'(?<!\\)([aAbBdDfFgGhHiIjlLmMnNOPrsStTUwWyYzZ])')

re_escaped = re.compile(r'\\(.)')

class Formatter(object):

    def format(self, formatstr):

        pieces = []

        for i, piece in enumerate(re_formatchars.split(force_unicode(formatstr))):

            if i % 2:

                pieces.append(force_unicode(getattr(self, piece)()))

            elif piece:

                pieces.append(re_escaped.sub(r'\1', piece))

        return u''.join(pieces)

class TimeFormat(Formatter):

    def __init__(self, t):

        self.data = t

    def a(self):

        "'a.m.' or 'p.m.'"

        if self.data.hour > 11:

            return _('p.m.')

        return _('a.m.')

    def A(self):

        "'AM' or 'PM'"

        if self.data.hour > 11:

            return _('PM')

        return _('AM')

    def B(self):

        "Swatch Internet time"

        raise NotImplementedError

    def f(self):

        """

        Time, in 12-hour hours and minutes, with minutes left off if they're

        zero.

        Examples: '1', '1:30', '2:05', '2'

        Proprietary extension.

        """

        if self.data.minute == 0:

            return self.g()

        return u'%s:%s' % (self.g(), self.i())

    def g(self):

        "Hour, 12-hour format without leading zeros; i.e. '1' to '12'"

        if self.data.hour == 0:

            return 12

        if self.data.hour > 12:

            return self.data.hour - 12

        return self.data.hour

    def G(self):

        "Hour, 24-hour format without leading zeros; i.e. '0' to '23'"

        return self.data.hour

    def h(self):

        "Hour, 12-hour format; i.e. '01' to '12'"

        return u'%02d' % self.g()

    def H(self):

        "Hour, 24-hour format; i.e. '00' to '23'"

        return u'%02d' % self.G()

    def i(self):

        "Minutes; i.e. '00' to '59'"

        return u'%02d' % self.data.minute

    def P(self):

        """

        Time, in 12-hour hours, minutes and 'a.m.'/'p.m.', with minutes left off

        if they're zero and the strings 'midnight' and 'noon' if appropriate.

        Examples: '1 a.m.', '1:30 p.m.', 'midnight', 'noon', '12:30 p.m.'

        Proprietary extension.

        """

        if self.data.minute == 0 and self.data.hour == 0:

            return _('midnight')

        if self.data.minute == 0 and self.data.hour == 12:

            return _('noon')

        return u'%s %s' % (self.f(), self.a())

    def s(self):

        "Seconds; i.e. '00' to '59'"

        return u'%02d' % self.data.second

class DateFormat(TimeFormat):

    year_days = [None, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334]

    def __init__(self, dt):

        # Accepts either a datetime or date object.

        self.data = dt

        self.timezone = getattr(dt, 'tzinfo', None)

        if hasattr(self.data, 'hour') and not self.timezone:

            self.timezone = LocalTimezone(dt)

    def b(self):

        "Month, textual, 3 letters, lowercase; e.g. 'jan'"

        return MONTHS_3[self.data.month]

    def d(self):

        "Day of the month, 2 digits with leading zeros; i.e. '01' to '31'"

        return u'%02d' % self.data.day

    def D(self):

        "Day of the week, textual, 3 letters; e.g. 'Fri'"

        return WEEKDAYS_ABBR[self.data.weekday()]

    def F(self):

        "Month, textual, long; e.g. 'January'"

        return MONTHS[self.data.month]

    def I(self):

        "'1' if Daylight Savings Time, '0' otherwise."

        if self.timezone.dst(self.data):

            return u'1'

        else:

            return u'0'

    def j(self):

        "Day of the month without leading zeros; i.e. '1' to '31'"

        return self.data.day

    def l(self):

        "Day of the week, textual, long; e.g. 'Friday'"

        return WEEKDAYS[self.data.weekday()]

    def L(self):

        "Boolean for whether it is a leap year; i.e. True or False"

        return isleap(self.data.year)

    def m(self):

        "Month; i.e. '01' to '12'"

        return u'%02d' % self.data.month

    def M(self):

        "Month, textual, 3 letters; e.g. 'Jan'"

        return MONTHS_3[self.data.month].title()

    def n(self):

        "Month without leading zeros; i.e. '1' to '12'"

        return self.data.month

    def N(self):

        "Month abbreviation in Associated Press style. Proprietary extension."

        return MONTHS_AP[self.data.month]

    def O(self):

        "Difference to Greenwich time in hours; e.g. '+0200'"

        seconds = self.Z()

        return u"%+03d%02d" % (seconds // 3600, (seconds // 60) % 60)

    def r(self):

        "RFC 2822 formatted date; e.g. 'Thu, 21 Dec 2000 16:01:07 +0200'"

        return self.format('D, j M Y H:i:s O')

    def S(self):

        "English ordinal suffix for the day of the month, 2 characters; i.e. 'st', 'nd', 'rd' or 'th'"

        if self.data.day in (11, 12, 13): # Special case

            return u'th'

        last = self.data.day % 10

        if last == 1:

            return u'st'

        if last == 2:

            return u'nd'

        if last == 3:

            return u'rd'

        return u'th'

    def t(self):

        "Number of days in the given month; i.e. '28' to '31'"

        return u'%02d' % monthrange(self.data.year, self.data.month)[1]

    def T(self):

        "Time zone of this machine; e.g. 'EST' or 'MDT'"

        name = self.timezone.tzname(self.data)

        if name is None:

            name = self.format('O')

        return unicode(name)

    def U(self):

        "Seconds since the Unix epoch (January 1 1970 00:00:00 GMT)"

        off = self.timezone.utcoffset(self.data)

        return int(time.mktime(self.data.timetuple())) + off.seconds * 60

    def w(self):

        "Day of the week, numeric, i.e. '0' (Sunday) to '6' (Saturday)"

        return (self.data.weekday() + 1) % 7

    def W(self):

        "ISO-8601 week number of year, weeks starting on Monday"

        # Algorithm from http://www.personal.ecu.edu/mccartyr/ISOwdALG.txt

        week_number = None

        jan1_weekday = self.data.replace(month=1, day=1).weekday() + 1

        weekday = self.data.weekday() + 1

        day_of_year = self.z()

        if day_of_year <= (8 - jan1_weekday) and jan1_weekday > 4:

            if jan1_weekday == 5 or (jan1_weekday == 6 and isleap(self.data.year-1)):

                week_number = 53

            else:

                week_number = 52

        else:

            if isleap(self.data.year):

                i = 366

            else:

                i = 365

            if (i - day_of_year) < (4 - weekday):

                week_number = 1

            else:

                j = day_of_year + (7 - weekday) + (jan1_weekday - 1)

                week_number = j // 7

                if jan1_weekday > 4:

                    week_number -= 1

        return week_number

    def y(self):

        "Year, 2 digits; e.g. '99'"

        return unicode(self.data.year)[2:]

    def Y(self):

        "Year, 4 digits; e.g. '1999'"

        return self.data.year

    def z(self):

        "Day of the year; i.e. '0' to '365'"

        doy = self.year_days[self.data.month] + self.data.day

        if self.L() and self.data.month > 2:

            doy += 1

        return doy

    def Z(self):

        """

        Time zone offset in seconds (i.e. '-43200' to '43200'). The offset for

        timezones west of UTC is always negative, and for those east of UTC is

        always positive.

        """

        offset = self.timezone.utcoffset(self.data)

        # Only days can be negative, so negative offsets have days=-1 and

        # seconds positive. Positive offsets have days=0

        return offset.days * 86400 + offset.seconds

def format(value, format_string):

    "Convenience function"

    df = DateFormat(value)

    return df.format(format_string)

def time_format(value, format_string):

    "Convenience function"

    tf = TimeFormat(value)

    return tf.format(format_string)