#!/usr/bin/env python

"""

A simple filesystem-based store of calendar data.

Copyright (C) 2014, 2015 Paul Boddie <paul@boddie.org.uk>

This program is free software; you can redistribute it and/or modify it under

the terms of the GNU General Public License as published by the Free Software

Foundation; either version 3 of the License, or (at your option) any later

version.

This program is distributed in the hope that it will be useful, but WITHOUT

ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more

details.

You should have received a copy of the GNU General Public License along with

this program.  If not, see <http://www.gnu.org/licenses/>.

"""

from datetime import datetime

from imiptools.config import STORE_DIR, PUBLISH_DIR

from imiptools.data import make_calendar, parse_object, to_stream

from imiptools.dates import format_datetime, get_datetime

from imiptools.filesys import fix_permissions, FileBase

from imiptools.period import FreeBusyPeriod

from os.path import exists, isfile, join

from os import listdir, remove, rmdir

from time import sleep

import codecs

class FileStore(FileBase):

    "A file store of tabular free/busy data and objects."

    def __init__(self, store_dir=None):

        FileBase.__init__(self, store_dir or STORE_DIR)

    def acquire_lock(self, user, timeout=None):

        FileBase.acquire_lock(self, timeout, user)

    def release_lock(self, user):

        FileBase.release_lock(self, user)

    # Utility methods.

    def _set_defaults(self, t, empty_defaults):

        for i, default in empty_defaults:

            if i >= len(t):

                t += [None] * (i - len(t) + 1)

            if not t[i]:

                t[i] = default

        return t

    def _get_table(self, user, filename, empty_defaults=None):

        """

        From the file for the given 'user' having the given 'filename', return

        a list of tuples representing the file's contents.

        The 'empty_defaults' is a list of (index, value) tuples indicating the

        default value where a column either does not exist or provides an empty

        value.

        """

        self.acquire_lock(user)

        try:

            f = codecs.open(filename, "rb", encoding="utf-8")

            try:

                l = []

                for line in f.readlines():

                    t = line.strip(" \r\n").split("\t")

                    if empty_defaults:

                        t = self._set_defaults(t, empty_defaults)

                    l.append(tuple(t))

                return l

            finally:

                f.close()

        finally:

            self.release_lock(user)

    def _set_table(self, user, filename, items, empty_defaults=None):

        """

        For the given 'user', write to the file having the given 'filename' the

        'items'.

        The 'empty_defaults' is a list of (index, value) tuples indicating the

        default value where a column either does not exist or provides an empty

        value.

        """

        self.acquire_lock(user)

        try:

            f = codecs.open(filename, "wb", encoding="utf-8")

            try:

                for item in items:

                    if empty_defaults:

                        item = self._set_defaults(list(item), empty_defaults)

                    f.write("\t".join(item) + "\n")

            finally:

                f.close()

                fix_permissions(filename)

        finally:

            self.release_lock(user)

    # Store object access.

    def _get_object(self, user, filename):

        """

        Return the parsed object for the given 'user' having the given

        'filename'.

        """

        self.acquire_lock(user)

        try:

            f = open(filename, "rb")

            try:

                return parse_object(f, "utf-8")

            finally:

                f.close()

        finally:

            self.release_lock(user)

    def _set_object(self, user, filename, node):

        """

        Set an object for the given 'user' having the given 'filename', using

        'node' to define the object.

        """

        self.acquire_lock(user)

        try:

            f = open(filename, "wb")

            try:

                to_stream(f, node)

            finally:

                f.close()

                fix_permissions(filename)

        finally:

            self.release_lock(user)

        return True

    def _remove_object(self, filename):

        "Remove the object with the given 'filename'."

        try:

            remove(filename)

        except OSError:

            return False

        return True

    def _remove_collection(self, filename):

        "Remove the collection with the given 'filename'."

        try:

            rmdir(filename)

        except OSError:

            return False

        return True

    # User discovery.

    def get_users(self):

        "Return a list of users."

        return listdir(self.store_dir)

    # Event and event metadata access.

    def get_events(self, user):

        "Return a list of event identifiers."

        filename = self.get_object_in_store(user, "objects")

        if not filename or not exists(filename):

            return None

        return [name for name in listdir(filename) if isfile(join(filename, name))]

    def get_all_events(self, user):

        "Return a set of (uid, recurrenceid) tuples for all events."

        uids = self.get_events(user)

        all_events = set()

        for uid in uids:

            all_events.add((uid, None))

            all_events.update([(uid, recurrenceid) for recurrenceid in self.get_recurrences(user, uid)])

        return all_events

    def get_active_events(self, user):

        "Return a set of uncancelled events of the form (uid, recurrenceid)."

        all_events = self.get_all_events(user)

        # Filter out cancelled events.

        cancelled = self.get_cancellations(user) or []

        all_events.difference_update(cancelled)

        return all_events

    def get_event(self, user, uid, recurrenceid=None):

        """

        Get the event for the given 'user' with the given 'uid'. If

        the optional 'recurrenceid' is specified, a specific instance or

        occurrence of an event is returned.

        """

        if recurrenceid:

            return self.get_recurrence(user, uid, recurrenceid)

        else:

            return self.get_complete_event(user, uid)

    def get_complete_event(self, user, uid):

        "Get the event for the given 'user' with the given 'uid'."

        filename = self.get_object_in_store(user, "objects", uid)

        if not filename or not exists(filename):

            return None

        return self._get_object(user, filename)

    def set_event(self, user, uid, recurrenceid, node):

        """

        Set an event for 'user' having the given 'uid' and 'recurrenceid' (which

        if the latter is specified, a specific instance or occurrence of an

        event is referenced), using the given 'node' description.

        """

        if recurrenceid:

            return self.set_recurrence(user, uid, recurrenceid, node)

        else:

            return self.set_complete_event(user, uid, node)

    def set_complete_event(self, user, uid, node):

        "Set an event for 'user' having the given 'uid' and 'node'."

        filename = self.get_object_in_store(user, "objects", uid)

        if not filename:

            return False

        return self._set_object(user, filename, node)

    def remove_event(self, user, uid, recurrenceid=None):

        """

        Remove an event for 'user' having the given 'uid'. If the optional

        'recurrenceid' is specified, a specific instance or occurrence of an

        event is removed.

        """

        if recurrenceid:

            return self.remove_recurrence(user, uid, recurrenceid)

        else:

            for recurrenceid in self.get_recurrences(user, uid) or []:

                self.remove_recurrence(user, uid, recurrenceid)

            return self.remove_complete_event(user, uid)

    def remove_complete_event(self, user, uid):

        "Remove an event for 'user' having the given 'uid'."

        self.remove_recurrences(user, uid)

        filename = self.get_object_in_store(user, "objects", uid)

        if not filename:

            return False

        return self._remove_object(filename)

    def get_recurrences(self, user, uid):

        """

        Get additional event instances for an event of the given 'user' with the

        indicated 'uid'.

        """

        filename = self.get_object_in_store(user, "recurrences", uid)

        if not filename or not exists(filename):

            return []

        return [name for name in listdir(filename) if isfile(join(filename, name))]

    def get_recurrence(self, user, uid, recurrenceid):

        """

        For the event of the given 'user' with the given 'uid', return the

        specific recurrence indicated by the 'recurrenceid'.

        """

        filename = self.get_object_in_store(user, "recurrences", uid, recurrenceid)

        if not filename or not exists(filename):

            return None

        return self._get_object(user, filename)

    def set_recurrence(self, user, uid, recurrenceid, node):

        "Set an event for 'user' having the given 'uid' and 'node'."

        filename = self.get_object_in_store(user, "recurrences", uid, recurrenceid)

        if not filename:

            return False

        return self._set_object(user, filename, node)

    def remove_recurrence(self, user, uid, recurrenceid):

        """

        Remove a special recurrence from an event stored by 'user' having the

        given 'uid' and 'recurrenceid'.

        """

        filename = self.get_object_in_store(user, "recurrences", uid, recurrenceid)

        if not filename:

            return False

        return self._remove_object(filename)

    def remove_recurrences(self, user, uid):

        """

        Remove all recurrences for an event stored by 'user' having the given

        'uid'.

        """

        for recurrenceid in self.get_recurrences(user, uid):

            self.remove_recurrence(user, uid, recurrenceid)

        recurrences = self.get_object_in_store(user, "recurrences", uid)

        if recurrences:

            return self._remove_collection(recurrences)

        return True

    # Free/busy period providers, upon extension of the free/busy records.

    def _get_freebusy_providers(self, user):

        """

        Return the free/busy providers for the given 'user'.

        This function returns any stored datetime and a list of providers as a

        2-tuple. Each provider is itself a (uid, recurrenceid) tuple.

        """

        filename = self.get_object_in_store(user, "freebusy-providers")

        if not filename or not exists(filename):

            return None

        # Attempt to read providers, with a declaration of the datetime

        # from which such providers are considered as still being active.

        t = self._get_table(user, filename, [(1, None)])

        try:

            dt_string = t[0][0]

        except IndexError:

            return None

        return dt_string, t[1:]

    def get_freebusy_providers(self, user, dt=None):

        """

        Return a set of uncancelled events of the form (uid, recurrenceid)

        providing free/busy details beyond the given datetime 'dt'.

        If 'dt' is not specified, all events previously found to provide

        details will be returned. Otherwise, if 'dt' is earlier than the

        datetime recorded for the known providers, None is returned, indicating

        that the list of providers must be recomputed.

        This function returns a list of (uid, recurrenceid) tuples upon success.

        """

        t = self._get_freebusy_providers(user)

        if not t:

            return None

        dt_string, t = t

        # If the requested datetime is earlier than the stated datetime, the

        # providers will need to be recomputed.

        if dt:

            providers_dt = get_datetime(dt_string)

            if not providers_dt or providers_dt > dt:

                return None

        # Otherwise, return the providers.

        return t[1:]

    def _set_freebusy_providers(self, user, dt_string, t):

        "Set the given provider timestamp 'dt_string' and table 't'."

        filename = self.get_object_in_store(user, "freebusy-providers")

        if not filename:

            return False

        t.insert(0, (dt_string,))

        self._set_table(user, filename, t, [(1, "")])

        return True

    def set_freebusy_providers(self, user, dt, providers):

        """

        Define the uncancelled events providing free/busy details beyond the

        given datetime 'dt'.

        """

        t = []

        for obj in providers:

            t.append((obj.get_uid(), obj.get_recurrenceid()))

        return self._set_freebusy_providers(user, format_datetime(dt), t)

    def append_freebusy_provider(self, user, provider):

        "For the given 'user', append the free/busy 'provider'."

        t = self._get_freebusy_providers(user)

        if not t:

            return False

        dt_string, t = t

        t.append((provider.get_uid(), provider.get_recurrenceid()))

        return self._set_freebusy_providers(user, dt_string, t)

    def remove_freebusy_provider(self, user, provider):

        "For the given 'user', remove the free/busy 'provider'."

        t = self._get_freebusy_providers(user)

        if not t:

            return False

        dt_string, t = t

        try:

            t.remove((provider.get_uid(), provider.get_recurrenceid()))

        except ValueError:

            return False

        return self._set_freebusy_providers(user, dt_string, t)

    # Free/busy period access.

    def get_freebusy(self, user):

        "Get free/busy details for the given 'user'."

        filename = self.get_object_in_store(user, "freebusy")

        if not filename or not exists(filename):

            return []

        else:

            return map(lambda t: FreeBusyPeriod(*t), self._get_table(user, filename, [(4, None)]))

    def get_freebusy_for_other(self, user, other):

        "For the given 'user', get free/busy details for the 'other' user."

        filename = self.get_object_in_store(user, "freebusy-other", other)

        if not filename or not exists(filename):

            return []

        else:

            return map(lambda t: FreeBusyPeriod(*t), self._get_table(user, filename, [(4, None)]))

    def set_freebusy(self, user, freebusy):

        "For the given 'user', set 'freebusy' details."

        filename = self.get_object_in_store(user, "freebusy")

        if not filename:

            return False

        self._set_table(user, filename, map(lambda fb: fb.as_tuple(strings_only=True), freebusy))

        return True

    def set_freebusy_for_other(self, user, freebusy, other):

        "For the given 'user', set 'freebusy' details for the 'other' user."

        filename = self.get_object_in_store(user, "freebusy-other", other)

        if not filename:

            return False

        self._set_table(user, filename, map(lambda fb: fb.as_tuple(strings_only=True), freebusy))

        return True

    # Object status details access.

    def _get_requests(self, user, queue):

        "Get requests for the given 'user' from the given 'queue'."

        filename = self.get_object_in_store(user, queue)

        if not filename or not exists(filename):

            return None

        return self._get_table(user, filename, [(1, None)])

    def get_requests(self, user):

        "Get requests for the given 'user'."

        return self._get_requests(user, "requests")

    def get_cancellations(self, user):

        "Get cancellations for the given 'user'."

        return self._get_requests(user, "cancellations")

    def _set_requests(self, user, requests, queue):

        """

        For the given 'user', set the list of queued 'requests' in the given

        'queue'.

        """

        filename = self.get_object_in_store(user, queue)

        if not filename:

            return False

        self.acquire_lock(user)

        try:

            f = open(filename, "w")

            try:

                for request in requests:

                    print >>f, "\t".join([value or "" for value in request])

            finally:

                f.close()

                fix_permissions(filename)

        finally:

            self.release_lock(user)

        return True

    def set_requests(self, user, requests):

        "For the given 'user', set the list of queued 'requests'."

        return self._set_requests(user, requests, "requests")

    def set_cancellations(self, user, cancellations):

        "For the given 'user', set the list of queued 'cancellations'."

        return self._set_requests(user, cancellations, "cancellations")

    def _set_request(self, user, uid, recurrenceid, queue):

        """

        For the given 'user', set the queued 'uid' and 'recurrenceid' in the

        given 'queue'.

        """

        filename = self.get_object_in_store(user, queue)

        if not filename:

            return False

        self.acquire_lock(user)

        try:

            f = open(filename, "a")

            try:

                print >>f, "\t".join([uid, recurrenceid or ""])

            finally:

                f.close()

                fix_permissions(filename)

        finally:

            self.release_lock(user)

        return True

    def set_request(self, user, uid, recurrenceid=None):

        "For the given 'user', set the queued 'uid' and 'recurrenceid'."

        return self._set_request(user, uid, recurrenceid, "requests")

    def set_cancellation(self, user, uid, recurrenceid=None):

        "For the given 'user', set the queued 'uid' and 'recurrenceid'."

        return self._set_request(user, uid, recurrenceid, "cancellations")

    def queue_request(self, user, uid, recurrenceid=None):

        """

        Queue a request for 'user' having the given 'uid'. If the optional

        'recurrenceid' is specified, the request refers to a specific instance

        or occurrence of an event.

        """

        requests = self.get_requests(user) or []

        if (uid, recurrenceid) not in requests:

            return self.set_request(user, uid, recurrenceid)

        return False

    def dequeue_request(self, user, uid, recurrenceid=None):

        """

        Dequeue a request for 'user' having the given 'uid'. If the optional

        'recurrenceid' is specified, the request refers to a specific instance

        or occurrence of an event.

        """

        requests = self.get_requests(user) or []

        try:

            requests.remove((uid, recurrenceid))

            self.set_requests(user, requests)

        except ValueError:

            return False

        else:

            return True

    def cancel_event(self, user, uid, recurrenceid=None):

        """

        Queue an event for cancellation for 'user' having the given 'uid'. If

        the optional 'recurrenceid' is specified, a specific instance or

        occurrence of an event is cancelled.

        """

        cancellations = self.get_cancellations(user) or []

        if (uid, recurrenceid) not in cancellations:

            return self.set_cancellation(user, uid, recurrenceid)

        return False

class FilePublisher(FileBase):

    "A publisher of objects."

    def __init__(self, store_dir=None):

        FileBase.__init__(self, store_dir or PUBLISH_DIR)

    def set_freebusy(self, user, freebusy):

        "For the given 'user', set 'freebusy' details."

        filename = self.get_object_in_store(user, "freebusy")

        if not filename:

            return False

        record = []

        rwrite = record.append

        rwrite(("ORGANIZER", {}, user))

        rwrite(("UID", {}, user))

        rwrite(("DTSTAMP", {}, datetime.utcnow().strftime("%Y%m%dT%H%M%SZ")))

        for fb in freebusy:

            if not fb.transp or fb.transp == "OPAQUE":

                rwrite(("FREEBUSY", {"FBTYPE" : "BUSY"}, "/".join(

                    map(format_datetime, [fb.get_start_point(), fb.get_end_point()]))))

        f = open(filename, "wb")

        try:

            to_stream(f, make_calendar([("VFREEBUSY", {}, record)], "PUBLISH"))

        finally:

            f.close()

            fix_permissions(filename)

        return True

# vim: tabstop=4 expandtab shiftwidth=4