from oauth2client.client import AccessTokenRefreshError
import constants
import datetime
import file_writer
import gdata
import globals
import os
import renderer
import time

class gcal_renderer(renderer.debuggable_abstaining_renderer):
    """A renderer to fetch upcoming events from www.google.com/calendar"""

    calendar_whitelist = frozenset([
        'Alex\'s calendar',
        'Family',
        'Holidays in United States',
        'Lynn Gasch',
        'Lynn\'s Work',
        'scott.gasch@gmail.com',
        'Scott Gasch External - Misc',
        'Birthdays',  # <-- from g+ contacts
    ])

    class comparable_event(object):
        """A helper class to sort events."""
        def __init__(self, start_time, end_time, summary, calendar):
            if start_time is None:
                assert(end_time is None)
            self.start_time = start_time
            self.end_time = end_time
            self.summary = summary
            self.calendar = calendar

        def __lt__(self, that):
            if self.start_time is None and that.start_time is None:
                return self.summary < that.summary
            if self.start_time is None or that.start_time is None:
                return self.start_time is None
            return (self.start_time,
                    self.end_time,
                    self.summary,
                    self.calendar) < (that.start_time,
                                      that.end_time,
                                      that.summary,
                                      that.calendar)

        def __str__(self):
            return '[%s]&nbsp;%s' % (self.timestamp(), self.friendly_name())

        def friendly_name(self):
            name = self.summary
            name = name.replace("countdown:", "")
            return "<B>%s</B>" % name

        def timestamp(self):
            if self.start_time is None:
                return "None"
            elif (self.start_time.hour == 0):
                return datetime.datetime.strftime(self.start_time,
                                                   '%a %b %d %Y')
            else:
                return datetime.datetime.strftime(self.start_time,
                                                  '%a %b %d %Y %H:%M%p')

    def __init__(self, name_to_timeout_dict, oauth):
        super(gcal_renderer, self).__init__(name_to_timeout_dict, True)
        self.oauth = oauth
        self.client = self.oauth.calendar_service()
        self.sortable_events = []
        self.countdown_events = []

    def debug_prefix(self):
        return "gcal"

    def periodic_render(self, key):
        self.debug_print('called for "%s"' % key)
        if (key == "Render Upcoming Events"):
            return self.render_upcoming_events()
        elif (key == "Look For Triggered Events"):
            return self.look_for_triggered_events()
        else:
            raise error('Unexpected operation')

    def render_upcoming_events(self):
        page_token = None
        def format_datetime(x):
            return datetime.datetime.strftime(x, '%Y-%m-%dT%H:%M:%SZ')
        time_min = datetime.datetime.now()
        time_max = time_min + datetime.timedelta(95)
        time_min, time_max = list(map(format_datetime, (time_min, time_max)))
        self.debug_print("time_min is %s" % time_min)
        self.debug_print("time_max is %s" % time_max)

        # Writes 2 files:
        #  + "upcoming events",
        #  + a countdown timer for a subser of events,
        f = file_writer.file_writer('gcal_3_none.html')
        f.write('<h1>Upcoming Calendar Events:</h1><hr>\n')
        f.write('<center><table width=96%>\n')

        g = file_writer.file_writer('countdown_3_7200.html')
        g.write('<h1>Countdowns:</h1><hr><ul>\n')

        try:
            self.sortable_events = []
            self.countdown_events = []
            while True:
                calendar_list = self.client.calendarList().list(
                    pageToken=page_token).execute()
                for calendar in calendar_list['items']:
                    if (calendar['summary'] in gcal_renderer.calendar_whitelist):
                        events = self.client.events().list(
                            calendarId=calendar['id'],
                            singleEvents=True,
                            timeMin=time_min,
                            timeMax=time_max,
                            maxResults=50).execute()

                        def parse_date(x):
                            y = x.get('date')
                            if y:
                                y = datetime.datetime.strptime(y, '%Y-%m-%d')
                            else:
                                y = x.get('dateTime')
                                if y:
                                    y = datetime.datetime.strptime(y[:-6],
                                                         '%Y-%m-%dT%H:%M:%S')
                                else:
                                    y = None
                            return y

                        for event in events['items']:
                            try:
                                summary = event['summary']
                                self.debug_print("event '%s' (%s to %s)" % (
                                    summary, event['start'], event['end']))
                                start = parse_date(event['start'])
                                end = parse_date(event['end'])
                                self.sortable_events.append(
                                    gcal_renderer.comparable_event(start,
                                                                   end,
                                                                   summary,
                                                                   calendar['summary']))
                                if ('countdown' in summary or
                                    'Holidays' in calendar['summary'] or
                                    'Countdown' in summary):
                                    self.debug_print("event is countdown worthy")
                                    self.countdown_events.append(
                                        gcal_renderer.comparable_event(start,
                                                                       end,
                                                                       summary,
                                                                       calendar['summary']))
                            except Exception as e:
                                print("gcal unknown exception, skipping event.");
                    else:
                        self.debug_print("Skipping calendar '%s'" % calendar['summary'])
                page_token = calendar_list.get('nextPageToken')
                if not page_token: break

            self.sortable_events.sort()
            upcoming_sortable_events = self.sortable_events[:12]
            for event in upcoming_sortable_events:
                self.debug_print("sorted event: %s" % event.friendly_name())
                f.write("""
<tr>
  <td style="padding-right: 1em;">
    %s
  </td>
  <td style="padding-left: 1em;">
    %s
  </td>
</tr>\n""" % (event.timestamp(), event.friendly_name()))
            f.write('</table></center>\n')
            f.close()

            self.countdown_events.sort()
            upcoming_countdown_events = self.countdown_events[:12]
            now = datetime.datetime.now()
            count = 0
            timestamps = { }
            for event in upcoming_countdown_events:
                eventstamp = event.start_time
                delta = eventstamp - now
                name = event.friendly_name()
                x = int(delta.total_seconds())
                if x > 0:
                    identifier = "id%d" % count
                    days = divmod(x, constants.seconds_per_day)
                    hours = divmod(days[1], constants.seconds_per_hour)
                    minutes = divmod(hours[1], constants.seconds_per_minute)
                    g.write('<li><SPAN id="%s">%d days, %02d:%02d</SPAN> until %s</li>\n' % (identifier, days[0], hours[0], minutes[0], name))
                    timestamps[identifier] = time.mktime(eventstamp.timetuple())
                    count += 1
                    self.debug_print("countdown to %s is %dd %dh %dm" % (
                        name, days[0], hours[0], minutes[0]))
            g.write('</ul>')
            g.write('<SCRIPT>\nlet timestampMap = new Map([')
            for x in list(timestamps.keys()):
                g.write('    ["%s", %f],\n' % (x, timestamps[x] * 1000.0))
            g.write(']);\n\n')
            g.write("""
// Pad things with a leading zero if necessary.
function pad(n) {
    return (n < 10) ? ("0" + n) : n;
}

// Return an 's' if things are plural.
function plural(n) {
    return (n == 1) ? "" : "s";
}

// Periodic function to run the page timers.
var fn = setInterval(function() {
    var now = new Date().getTime();
    for (let [id, timestamp] of timestampMap) {
        var delta = timestamp - now;

        if (delta > 0) {
            var days = Math.floor(delta / (1000 * 60 * 60 * 24));
            var hours = pad(Math.floor((delta % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60)));
            var minutes = pad(Math.floor((delta % (1000 * 60 * 60)) / (1000 * 60)));
            var seconds = pad(Math.floor((delta % (1000 * 60)) / 1000));

            var s = days + " day" + plural(days) + ", ";
            s = s + hours + ":" + minutes;
            document.getElementById(id).innerHTML = s;
        } else {
            document.getElementById(id).innerHTML = "EXPIRED";
        }
    }
}, 1000);
</script>""");
            g.close()
            return True
        except (gdata.service.RequestError, AccessTokenRefreshError):
            print("********* TRYING TO REFRESH GCAL CLIENT *********")
            self.oauth.refresh_token()
            self.client = self.oauth.calendar_service()
            return False
        except:
            raise

    def look_for_triggered_events(self):
        f = file_writer.file_writer(constants.gcal_imminent_pagename)
        f.write('<h1>Imminent Upcoming Calendar Events:</h1>\n<hr>\n')
        f.write('<center><table width=99%>\n')
        now = datetime.datetime.now()
        count = 0
        for event in self.sortable_events:
            eventstamp = event.start_time
            delta = eventstamp - now
            x = int(delta.total_seconds())
            if x > 0 and x <= constants.seconds_per_minute * 3:
                days = divmod(x, constants.seconds_per_day)
                hours = divmod(days[1], constants.seconds_per_hour)
                minutes = divmod(hours[1], constants.seconds_per_minute)
                eventstamp = event.start_time
                name = event.friendly_name()
                calendar = event.calendar
                f.write("<LI> %s (%s) upcoming in %d minutes.\n" % (name, calendar, minutes[0]))
                count += 1
        f.write("</table>")
        f.close()
        if count > 0:
            globals.put("gcal_triggered", True)
        else:
            globals.put("gcal_triggered", False)
        return True