#!/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.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=STORE_DIR):

        FileBase.__init__(self, 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)

    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().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)

    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

    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_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

    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(), freebusy),

            [(3, "OPAQUE"), (4, "")])

        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(), freebusy),

            [(2, ""), (3, "OPAQUE"), (4, ""), (5, ""), (6, "")])

        return True

    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=PUBLISH_DIR):

        FileBase.__init__(self, store_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([fb.start, fb.end])))

        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