"""html calendar views

:organization: Logilab

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

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

"""

from datetime import datetime, date, timedelta

from vobject import iCalendar

from logilab.mtconverter import html_escape

from cubicweb.interfaces import ICalendarable

from cubicweb.selectors import implements

from cubicweb.utils import strptime, date_range, todate

from cubicweb.view import EntityView

from cubicweb.common.uilib import ajax_replace_url

_ = unicode

# useful constants & functions ################################################

ONEDAY = timedelta(1)

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

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

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

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

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

               )

# Calendar views ##############################################################

class iCalView(EntityView):

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

    Does apply to ICalendarable compatible entities

    """

    __select__ = implements(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 = task.start

            if task.stop:

                event.add('dtend').value = 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

    """

    id = 'hcal'

    __select__ = implements(ICalendarable)

    need_navigation = False

    title = _('hCalendar')

    #templatable = False

    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>' % (task.start.isoformat(), self.format_date(task.start)))

            if task.stop:

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

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

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

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/>' % self.req._('from %(date)s' % {'date': self.format_date(task.start)}))

                self.w('<br/>' % self.req._('to %(date)s' % {'date': self.format_date(task.stop)}))

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

class CalendarLargeItemView(CalendarItemView):

    id = 'calendarlargeitem'

class _TaskEntry(object):

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

        self.task = task

        self.color = color

        self.index = index

        self.length = 1

    def in_working_hours(self):

        """predicate returning True is the task is in working hours"""

        if self.task.start.hour > 7 and self.task.stop.hour < 20:

            return True

        return False

    def is_one_day_task(self):

        task = self.task

        return task.start and task.stop and task.start.isocalendar() ==  task.stop.isocalendar()

class OneMonthCal(EntityView):

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

    id = 'onemonthcal'

    __select__ = implements(ICalendarable)

    need_navigation = False

    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 =  datetime.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 = date(year, month, 1)

        firstday = first_day_of_month - timedelta(first_day_of_month.weekday())

        if month >= 12:

            last_day_of_month = date(year + 1, 1, 1) - timedelta(1)

        else:

            last_day_of_month = date(year, month + 1, 1) - timedelta(1)

        lastday = last_day_of_month + timedelta(6 - last_day_of_month.weekday())

        month_dates = list(date_range(firstday, lastday))

        dates = {}

        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 = []

            tstart = todate(task.start)

            if tstart:

                if tstart > lastday:

                    continue

                the_dates = [tstart]

            tstop = todate(task.start)

            if tstop:

                if tstop < firstday:

                    continue

                the_dates = [tstop]

            if tstart and tstop:

                if tstart.isocalendar() == tstop.isocalendar():

                    if firstday <= tstart <= lastday:

                        the_dates = [tstart]

                else:

                    the_dates = date_range(max(tstart, firstday),

                                           min(tstop, 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 mdate in month_dates:

            d_tasks = dates.get((mdate.year, mdate.month, mdate.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 mdate, task_rows in zip(month_dates, days):

            if mdate.weekday() == 0:

                self.w(u'<tr>')

            self._build_calendar_cell(mdate, task_rows, curdate)

            if mdate.weekday() == 6:

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

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

    def _prevnext_links(self, curdate):

        prevdate = curdate - timedelta(31)

        nextdate = curdate + timedelta(31)

        rql = self.rset.printable_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, celldate, rows, curdate):

        curmonth = curdate.month

        classes = ""

        if celldate.month != curmonth:

            classes += " outOfRange"

        if celldate == 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>' % celldate.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(celldate), stop=self.format_date(celldate),

                                 __redirectrql=self.rset.printable_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.printable_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"""

    id = 'oneweekcal'

    __select__ = implements(ICalendarable)

    need_navigation = False

    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 directly with RQL

        _today =  datetime.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.isocalendar()[1]        

        # week - 1 since we get week number > 0 while we want it to start from 0

        first_day_of_week = todate(strptime('%s-%s-1' % (year, week - 1), '%Y-%U-%w'))

        lastday = first_day_of_week + timedelta(6)

        firstday = first_day_of_week

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

        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 = []

            tstart = todate(task.start)

            tstop = todate(task.stop)

            if tstart:

                if tstart > lastday:

                    continue

                the_dates = [tstart]

            if tstop:

                if tstop < firstday:

                    continue

                the_dates = [tstop]

            if tstart and tstop:

                the_dates = date_range(max(tstart, firstday),

                                       min(tstop, lastday))

            if not the_dates:

                continue

            if task not in task_colors:

                task_colors[task] = colors[next_color_index]