"""html calendar views

:organization: Logilab

:copyright: 2001-2008 LOGILAB S.A. (Paris, FRANCE), all rights reserved.

:contact: http://www.logilab.fr/ -- mailto:contact@logilab.fr

"""

from mx.DateTime import DateTime, RelativeDateTime, today, ISO

from datetime import datetime

from vobject import iCalendar, icalendar

from logilab.mtconverter import html_escape

from cubicweb.interfaces import ICalendarable

from cubicweb.common.utils import date_range

from cubicweb.common.uilib import ajax_replace_url

from cubicweb.common.selectors import interface_selector, anyrset_selector

from cubicweb.common.registerers import priority_registerer

from cubicweb.common.view import EntityView

# For backward compatibility

from cubicweb.interfaces import ICalendarViews, ITimetableViews

try:

    from cubicweb.web.views.old_calendar import _CalendarView, AMPMWeekCalendarView

except ImportError:

    import logging

    logger = logging.getLogger('cubicweb.registry')

    logger.info("old calendar views could not be found and won't be registered")

_ = unicode

# useful constants & functions

def mkdt(mxdate):

    """

    Build a stdlib datetime date from a mx.datetime 

    """

    d = mxdate

    return datetime(d.year, d.month, d.day, d.hour, d.minute,

                    tzinfo=icalendar.utc)

def iso(mxdate):

    """

    Format a ms datetime in ISO 8601 string 

    """

    # XXX What about timezone?

    return ISO.str(mxdate)

# mx.DateTime and ustrftime could be used to build WEEKDAYS

WEEKDAYS = (_("monday"), _("tuesday"), _("wednesday"), _("thursday"),

            _("friday"), _("saturday"), _("sunday"))

# used by i18n tools

MONTHNAMES = ( _('january'), _('february'), _('march'), _('april'), _('may'),

               _('june'), _('july'), _('august'), _('september'), _('october'),

               _('november'), _('december')

               )

#################

# In calendar views (views used as calendar cell item) 

class CalendarItemView(EntityView):

    id = 'calendaritem'

    def cell_call(self, row, col, dates=False):

        task = self.complete_entity(row)

        task.view('oneline', w=self.w)

        if dates:

            if task.start and task.stop:

                self.w('<br/>from %s'%self.format_date(task.start))

                self.w('<br/>to %s'%self.format_date(task.stop))

class CalendarLargeItemView(CalendarItemView):

    id = 'calendarlargeitem'

#################

# Calendar views

class iCalView(EntityView):

    """A calendar view that generates a iCalendar file (RFC 2445)

    Does apply to ICalendarable compatible entities

    """

    __registerer__ = priority_registerer

    __selectors__ = (interface_selector,)

    accepts_interfaces = (ICalendarable,)

    need_navigation = False

    content_type = 'text/calendar'

    title = _('iCalendar')

    templatable = False

    id = 'ical'

    def call(self):

        ical = iCalendar()

        for i in range(len(self.rset.rows)):

            task = self.complete_entity(i)

            event = ical.add('vevent')

            event.add('summary').value = task.dc_title()

            event.add('description').value = task.dc_description()

            if task.start:

                event.add('dtstart').value = mkdt(task.start)

            if task.stop:

                event.add('dtend').value = mkdt(task.stop)

        buff = ical.serialize()

        if not isinstance(buff, unicode):

            buff = unicode(buff, self.req.encoding)

        self.w(buff)

class hCalView(EntityView):

    """A calendar view that generates a hCalendar file

    Does apply to ICalendarable compatible entities

    """

    __registerer__ = priority_registerer

    __selectors__ = (interface_selector,)

    accepts_interfaces = (ICalendarable,)

    need_navigation = False

    title = _('hCalendar')

    templatable = False

    id = 'hcal'

    def call(self):

        self.w(u'<div class="hcalendar">')

        for i in range(len(self.rset.rows)):

            task = self.complete_entity(i)

            self.w(u'<div class="vevent">')

            self.w(u'<h3 class="summary">%s</h3>' % html_escape(task.dc_title()))

            self.w(u'<div class="description">%s</div>' % html_escape(task.dc_description()))

            if task.start:

                self.w(u'<abbr class="dtstart" title="%s">%s</abbr>' % (iso(task.start), self.format_date(task.start)))

            if task.stop:

                self.w(u'<abbr class="dtstop" title="%s">%s</abbr>' % (iso(task.stop), self.format_date(task.stop)))

            self.w(u'</div>')

        self.w(u'</div>')

class _TaskEntry(object):

    def __init__(self, task, color, index=0):

        self.task = task

        self.color = color

        self.index = index

        self.length = 1

class OneMonthCal(EntityView):

    """At some point, this view will probably replace ampm calendars"""

    __registerer__ = priority_registerer

    __selectors__ = (interface_selector, anyrset_selector)

    accepts_interfaces = (ICalendarable,)

    need_navigation = False

    id = 'onemonthcal'

    title = _('one month')

    def call(self):

        self.req.add_js('cubicweb.ajax.js')

        self.req.add_css('cubicweb.calendar.css')

        # XXX: restrict courses directy with RQL

        _today =  today()

        if 'year' in self.req.form:

            year = int(self.req.form['year'])

        else:

            year = _today.year

        if 'month' in self.req.form:

            month = int(self.req.form['month'])

        else:

            month = _today.month

        first_day_of_month = DateTime(year, month, 1)

        lastday = first_day_of_month + RelativeDateTime(months=1,weekday=(6,1))

        firstday= first_day_of_month + RelativeDateTime(months=-1,weekday=(0,-1))

        month_dates = list(date_range(firstday, lastday))

        dates = {}

        users = []

        task_max = 0

        for row in xrange(self.rset.rowcount):

            task = self.rset.get_entity(row,0)

            if len(self.rset[row]) > 1 and self.rset.description[row][1] == 'EUser':

                user = self.rset.get_entity(row,1)

            else:

                user = None

            the_dates = []

            if task.start:

                if task.start > lastday:

                    continue

                the_dates = [task.start]

            if task.stop:

                if task.stop < firstday:

                    continue

                the_dates = [task.stop]

            if task.start and task.stop:

                if task.start.absdate == task.stop.absdate:

                    date = task.start

                    if firstday<= date <= lastday:

                        the_dates = [date]

                else:

                    the_dates = date_range(max(task.start,firstday),

                                           min(task.stop,lastday))

            if not the_dates:

                continue

            for d in the_dates:

                d_tasks = dates.setdefault((d.year, d.month, d.day), {})

                t_users = d_tasks.setdefault(task,set())

                t_users.add( user )

                if len(d_tasks)>task_max:

                    task_max = len(d_tasks)

        days = []

        nrows = max(3,task_max)

        # colors here are class names defined in cubicweb.css

        colors = [ "col%x"%i for i in range(12) ]

        next_color_index = 0

        visited_tasks = {} # holds a description of a task

        task_colors = {}   # remember a color assigned to a task

        for date in month_dates:

            d_tasks = dates.get((date.year, date.month, date.day), {})

            rows = [None] * nrows

            # every task that is "visited" for the first time

            # require a special treatment, so we put them in

            # 'postpone'

            postpone = []

            for task in d_tasks:

                if task in visited_tasks:

                    task_descr = visited_tasks[ task ]

                    rows[task_descr.index] = task_descr

                else:

                    postpone.append(task)

            for task in postpone:

                # to every 'new' task we must affect a color

                # (which must be the same for every user concerned

                # by the task)

                for i,t in enumerate(rows):

                    if t is None:

                        if task in task_colors:

                            color = task_colors[task]

                        else:

                            color = colors[next_color_index]

                            next_color_index = (next_color_index+1)%len(colors)

                            task_colors[task] = color

                        task_descr = _TaskEntry(task, color, i)

                        rows[i] = task_descr

                        visited_tasks[task] = task_descr

                        break

                else:

                    raise RuntimeError("is it possible we got it wrong?")

            days.append( rows )

        curdate = first_day_of_month

        self.w(u'<div id="onemonthcalid">')

        # build schedule

        self.w(u'<table class="omcalendar">')

        prevlink, nextlink = self._prevnext_links(curdate)  # XXX

        self.w(u'<tr><th><a href="%s">&lt;&lt;</a></th><th colspan="5">%s %s</th>'

               u'<th><a href="%s">&gt;&gt;</a></th></tr>' %

               (html_escape(prevlink), self.req._(curdate.strftime('%B').lower()),

                curdate.year, html_escape(nextlink)))

        # output header

        self.w(u'<tr><th>%s</th><th>%s</th><th>%s</th><th>%s</th><th>%s</th><th>%s</th><th>%s</th></tr>' %

               tuple(self.req._(day) for day in WEEKDAYS))

        # build calendar

        for date, task_rows in zip(month_dates, days):

            if date.day_of_week == 0:

                self.w(u'<tr>')

            self._build_calendar_cell(date, task_rows, curdate)

            if date.day_of_week == 6:

                self.w(u'</tr>')

        self.w(u'</table></div>')

    def _prevnext_links(self, curdate):

        prevdate = curdate - RelativeDateTime(months=1)

        nextdate = curdate + RelativeDateTime(months=1)

        rql = self.rset.rql

        prevlink = ajax_replace_url('onemonthcalid', rql, 'onemonthcal',

                                    year=prevdate.year, month=prevdate.month)

        nextlink = ajax_replace_url('onemonthcalid', rql, 'onemonthcal',

                                    year=nextdate.year, month=nextdate.month)

        return prevlink, nextlink

    def _build_calendar_cell(self, date, rows, curdate):

        curmonth = curdate.month

        classes = ""

        if date.month != curmonth:

            classes += " outOfRange"

        if date == today():

            classes += " today"

        self.w(u'<td class="cell%s">' % classes)

        self.w(u'<div class="calCellTitle%s">' % classes)

        self.w(u'<div class="day">%s</div>' % date.day)

        if len(self.rset.column_types(0)) == 1:

            etype = list(self.rset.column_types(0))[0]

            url = self.build_url(vid='creation', etype=etype,

                                 schedule=True,

                                 start=self.format_date(date), stop=self.format_date(date),

                                 __redirectrql=self.rset.rql,

                                 __redirectparams=self.req.build_url_params(year=curdate.year, month=curmonth),

                                 __redirectvid=self.id

                                 )

            self.w(u'<div class="cmd"><a href="%s">%s</a></div>' % (html_escape(url), self.req._(u'add')))

            self.w(u' ')

        self.w(u'</div>')

        self.w(u'<div class="cellContent">')

        for task_descr in rows:

            if task_descr:

                task = task_descr.task

                self.w(u'<div class="task %s">' % task_descr.color)

                task.view('calendaritem', w=self.w )

                url = task.absolute_url(vid='edition',

                                        __redirectrql=self.rset.rql,

                                        __redirectparams=self.req.build_url_params(year=curdate.year, month=curmonth),

                                        __redirectvid=self.id

                                        )

                self.w(u'<div class="tooltip" ondblclick="stopPropagation(event); window.location.assign(\'%s\'); return false;">' % html_escape(url))

                task.view('tooltip', w=self.w )

                self.w(u'</div>')

            else:

                self.w(u'<div class="task">')

                self.w(u" ")

            self.w(u'</div>')

        self.w(u'</div>')

        self.w(u'</td>')

class OneWeekCal(EntityView):

    """At some point, this view will probably replace ampm calendars"""

    __registerer__ = priority_registerer

    __selectors__ = (interface_selector, anyrset_selector)

    accepts_interfaces = (ICalendarable,)

    need_navigation = False

    id = 'oneweekcal'

    title = _('one week')

    def call(self):

        self.req.add_js( ('cubicweb.ajax.js', 'cubicweb.calendar.js') )

        self.req.add_css('cubicweb.calendar.css')

        # XXX: restrict courses directy with RQL

        _today =  today()

        if 'year' in self.req.form:

            year = int(self.req.form['year'])

        else:

            year = _today.year

        if 'week' in self.req.form:

            week = int(self.req.form['week'])

        else:

            week = _today.iso_week[1]        

        first_day_of_week = ISO.ParseWeek("%s-W%s-1"%(year, week))

        lastday = first_day_of_week + RelativeDateTime(days=6)

        firstday= first_day_of_week

        dates = [[] for i in range(7)]

        task_max = 0

        task_colors = {}   # remember a color assigned to a task

        # colors here are class names defined in cubicweb.css

        colors = [ "col%x"%i for i in range(12) ]

        next_color_index = 0

        done_tasks = []

        for row in xrange(self.rset.rowcount):

            task = self.rset.get_entity(row,0)

            if task in done_tasks:

                continue

            done_tasks.append(task)

            the_dates = []

            if task.start:

                if task.start > lastday:

                    continue

                the_dates = [task.start]

            if task.stop:

                if task.stop < firstday:

                    continue

                the_dates = [task.stop]

            if task.start and task.stop:

                the_dates = date_range(max(task.start,firstday),