# -*- coding: utf-8 -*-

from trac.core import *
from trac.perm import PermissionSystem
from trac.db import Table, Column, Index
from trac.db.util import sql_escape_percent
from datetime import datetime, timedelta
from trac.util.datefmt import utc, to_timestamp
from trac.util.text import to_unicode
from trac.env import IEnvironmentSetupParticipant
from ctdotools.utils import validate_id, gen_wiki_page
from dateutil.rrule import *
from collections import defaultdict
from tracrendezvous.location.model import ItemLocation as RendezVousLocation
from tracrendezvous.rendezvous import api

__all__ = ['RendezVous', 'RendezVousComment', 'RendezVousType', 'RendezVousDate',
    'RendezVousVote', 'TypePermission', 'RendezVousModelProvider',
    'RendezVousTypePermissionSystem']

class RendezVousVote(object):

    def __init__(self, env, vote_id, date_id, user, email, time_created, time_begin, time_end):
        self.env = env
        self.vote_id = vote_id
        self.date_id = date_id
        self.user = to_unicode(user)
        self.email = to_unicode(email)
        self.time_created = time_created
        self.time_begin = time_begin
        self.time_end = time_end

    @staticmethod
    def fetch_one(env, vote_id):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("""SELECT *
                        FROM rendezvous_vote
                        WHERE vote_id=%s""", (vote_id,))
        row = cursor.fetchone()
        if not row:
            return None
        vote_id, date_id, user, email, time_created, time_begin, time_end = row
        return RendezVousVote(env, vote_id, date_id, user, email, datetime.utcfromtimestamp(time_created), datetime.utcfromtimestamp(time_begin), datetime.utcfromtimestamp(time_end))

    @staticmethod
    def exists(env, date_id, user, time_begin, time_end):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("""SELECT COUNT(*) FROM rendezvous_vote
                        WHERE date_id=%s
                        and user=%s
                        and time_begin=%s
                        and time_end=%s""", (date_id, user, to_timestamp(time_begin), to_timestamp(time_end)))
        row = cursor.fetchone()
        return row[0] > 0

    @staticmethod
    def fetch_by_date(env, date_id, userName=None):
        db = env.get_db_cnx()
        cursor = db.cursor()
        if userName == None:
            cursor.execute("""SELECT * FROM rendezvous_vote
                WHERE date_id=%s
                    ORDER BY user""", (date_id,))
        else:
            cursor.execute("""SELECT * FROM rendezvous_vote
                WHERE date_id=%s and user=%s
                    ORDER BY user;""", (date_id, userName))
        res = []
        for row in cursor:
            vote_id, date_id, user, email, time_created, time_begin, time_end = row
            res.append(RendezVousVote(env, vote_id, date_id, user, email, datetime.utcfromtimestamp(time_created), datetime.utcfromtimestamp(time_begin), datetime.utcfromtimestamp(time_end)))
        return res

    def commit(self):
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("""INSERT INTO rendezvous_vote
                        (date_id, user, email, time_created, time_begin, time_end)
                        VALUES(%s, %s, %s, %s, %s, %s)""", (
                            self.date_id,
                            self.user,
                            self.email,
                            to_timestamp(self.time_created),
                            to_timestamp(self.time_begin),
                            to_timestamp(self.time_end)))
        db.commit()
        self.vote_id = db.get_last_id(cursor, 'rendezvous_vote')

    @staticmethod
    def delete(env, vote_id):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("""DELETE FROM rendezvous_vote
                        WHERE vote_id =%s;""", (vote_id,))
        db.commit()

    @staticmethod
    def delete_by_date(env, date_id):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("""DELETE FROM rendezvous_vote
                        WHERE date_id =%s;""", (date_id,))
        db.commit()

    def update(self):
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("""UPDATE rendezvous_vote
                        SET user=%s,
                            email=%s,
                            time_created=%s,
                            time_begin=%s,
                            time_end=%s
                            WHERE vote_id=%s;""", (self.user,
                                self.email,
                                to_timestamp(self.time_created),
                                to_timestamp(self.time_begin),
                                to_timestamp(self.time_end),
                                self.vote_id))
        db.commit()

    def __str__(self):
        return "<RendezVousVote: %d, %d, %s, %s, %s, %s, %s" %(self.vote_id, self.date_id, self.user, self.email, self.time_created, self.time_begin, self.time_end)

def timedelta_2_string(t):
    return "%d,%d,%d" % (t.days, t.seconds,t.microseconds)

def string2_timedelta(t):
    return timedelta(*map(int, "1,2,3".split(",",3)))

class RendezVousDate(object):

    def __init__(self, env, date_id, rendezvous_id, author, email, time_created, time_begin, time_end, elected, fetch_votes=False):
        self.env = env
        self.date_id = date_id
        self.rendezvous_id = rendezvous_id
        self.author = to_unicode(author)
        self.email = to_unicode(email)
        self.time_created = time_created
        self.time_begin = time_begin
        self.time_end = time_end
        self.elected = elected
        if fetch_votes:
            self.votes = RendezVousVote.fetch_by_date(env, self.date_id)

    @staticmethod
    def fetch_one(env, date_id, fetch_votes=True):
        db = env.get_db_cnx()
        cursor = db.cursor()
        if int(date_id) > 0:
            cursor.execute("""SELECT *
                           FROM rendezvous_date
                           WHERE date_id=%s""", (date_id,) )
        row = cursor.fetchone()
        if not row:
            return None
        date_id, rendezvous_id, author, email, time_created, time_begin, time_end, elected = row
        return RendezVousDate(env, date_id, rendezvous_id, author, email, datetime.utcfromtimestamp(time_created), datetime.utcfromtimestamp(time_begin), datetime.utcfromtimestamp(time_end), elected, fetch_votes)

    @staticmethod
    def exists(env, ts_begin, ts_end):
        db = env.get_db_cnx()
        cursor = db.cursor()

        cursor.execute("SELECT date_id "
                        "FROM rendezvous_date "
                        "WHERE time_begin=%s AND time_end = %s",
                        (to_timestamp(ts_begin),
                        to_timestamp(ts_end)))
        rows = cursor.fetchall()
        return bool(rows)

    @staticmethod
    def fetch_by_rendezvous(env, rendezvous_id, fetch_votes=True):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("""SELECT *
                        FROM rendezvous_date
                        WHERE rendezvous_id=%s;""", (rendezvous_id,) )
        rows = cursor.fetchall()
        res = []
        for row in rows:
            date_id, rendezvous_id, author, email, time_created, time_begin, time_end, elected= row
            res.append(RendezVousDate(env, date_id, rendezvous_id, author, email, datetime.utcfromtimestamp(time_created), datetime.utcfromtimestamp(time_begin), datetime.utcfromtimestamp(time_end), elected, fetch_votes))
        return res

    @staticmethod
    def fetch_all(env, fetch_votes=True):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("SELECT * FROM rendezvous_date;")
        rows = cursor.fetchall()
        res = []
        for row in rows:
            date_id, rendezvous_id, author, email, time_created, time_begin, time_end, elected = row
            res.append(RendezVousDate(env, date_id, rendezvous_id, author, email, datetime.utcfromtimestamp(time_created), datetime.utcfromtimestamp(time_begin), datetime.utcfromtimestamp(time_end), elected, fetch_votes))
        return res

    def get_vote_count(self, authname=None):

        db = self.env.get_db_cnx()
        cursor = db.cursor()
        if authname:
            cursor.execute("""SELECT COUNT(rendezvous_date.date_id) from rendezvous_date INNER JOIN rendezvous_vote ON
            rendezvous_date.date_id=rendezvous_vote.date_id where rendezvous_date.date_id=%s and rendezvous_vote.user=%s;""", (self.date_id, authname))
        else:
            cursor.execute("SELECT COUNT(rendezvous_date.date_id) from rendezvous_date INNER JOIN rendezvous_vote "
            "ON rendezvous_date.date_id=rendezvous_vote.date_id "
            "where rendezvous_date.date_id=%s;", (self.date_id,))
        row  = cursor.fetchone()
        if row:
            return row[0]
        return 0

    def commit(self, conn=None):
        db = conn and conn or self.env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("""INSERT INTO rendezvous_date
                        (rendezvous_id, author, email, time_created, time_begin, time_end, elected)
                        VALUES(%s,%s,%s,%s,%s,%s,%s)""", (
                            self.rendezvous_id,
                            self.author,
                            self.email,
                            to_timestamp(self.time_created),
                            to_timestamp(self.time_begin),
                            to_timestamp(self.time_end),
                            self.elected))
        db.commit()
        self.date_id = db.get_last_id(cursor, 'rendezvous_date')

    @staticmethod
    def delete(env, date_id):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("DELETE FROM rendezvous_date WHERE date_id=%s", (date_id,))
        db.commit()

    @staticmethod
    def delete_by_rendezvous(env, rendezvous_id):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("""DELETE FROM rendezvous_date
                        WHERE rendezvous_id=%s;""", (rendezvous_id,) )
        db.commit()

    def update(self, conn=None):
        db = conn and conn or self.env.get_db_cnx()
        cursor = db.cursor()
        try:
            cursor.execute("""UPDATE rendezvous_date
                            SET rendezvous_id=%s,
                            author=%s,
                            email=%s,
                            time_created=%s,
                            time_begin=%s,
                            time_end=%s,
                            elected=%s
                            WHERE date_id=%s""", (self.rendezvous_id,
                                self.author,
                                self.email,
                                to_timestamp(self.time_created),
                                to_timestamp(self.time_begin),
                                to_timestamp(self.time_end),
                                self.elected,
                                self.date_id))
            if not conn:
                db.commit()
        except Exception:
            pass

    def __str__(self):
        return "<RendezVousDate: %d, %d, %s, %s, %s, %s, %s, %s>" % (self.date_id, self.rendezvous_id, self.author, self.email, str(self.time_created), str(self.time_begin), str(self.time_end), self.elected)

class RendezVousComment(object):

    def __init__(self, env, comment_id, rendezvous_id, author, comment, time_created):
        self.env = env
        self.comment_id = comment_id
        self.rendezvous_id = rendezvous_id
        self.author = to_unicode(author)
        self.comment = to_unicode(comment)
        self.time_created = time_created

    @staticmethod
    def fetch_one(env, comment_id):
        db = env.get_db_cnx()
        cursor = db.cursor()
        if int(comment_id) > 0:
            cursor.execute("SELECT * "
                           "FROM rendezvous_comment "
                           "WHERE comment_id=%s", (comment_id,) )
        row = cursor.fetchone()
        if not row:
            return None
        comment_id, rendezvous_id, author, comment, time_created = row
        return RendezVousComment(env, comment_id, rendezvous_id, author, comment, datetime.utcfromtimestamp(time_created))

    @staticmethod
    def fetch_by_rendezvous(env, rendezvous_id):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("""SELECT *
                        FROM rendezvous_comment
                        WHERE rendezvous_id=%s;""", (rendezvous_id,) )
        rows = cursor.fetchall()
        res = []
        for row in rows:
            comment_id, rendezvous_id, author, comment, time_created = row
            res.append(RendezVousComment(env, comment_id, rendezvous_id, author, comment, datetime.utcfromtimestamp(time_created)))
        return res

    @staticmethod
    def fetch_all(env):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("SELECT * FROM rendezvous_comment;")
        rows = cursor.fetchall()
        res = []
        for row in rows:
            comment_id, rendezvous_id, author, comment, time_created = row
            res.append(RendezVousComment(env, comment_id, rendezvous_id, author, comment, datetime.utcfromtimestamp(time_created)))
        return res

    def commit(self):
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("""INSERT INTO rendezvous_comment
                        (rendezvous_id, author, comment, time_created)
                        VALUES(%s,%s,%s,%s)""", (
                            self.rendezvous_id,
                            self.author,
                            self.comment,
                            to_timestamp(self.time_created)))
        db.commit()
        self.comment_id = db.get_last_id(cursor, 'rendezvous_comment')

    @staticmethod
    def delete(env, comment_id):
        db = env.get_db_cnx()
        RendezVousVote.delete_by_date(env, comment_id)
        cursor = db.cursor()
        cursor.execute("DELETE FROM rendezvous_comment WHERE comment_id=%s", (comment_id,))
        db.commit()

    @staticmethod
    def delete_by_rendezvous(env, rendezvous_id):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("DELETE FROM rendezvous_comment WHERE rendezvous_id=%s", (rendezvous_id,))
        db.commit()

    def update(self):
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        try:
            cursor.execute("""UPDATE rendezvous_comment
                            SET rendezvous_id=%s,
                            author=%s,
                            comment=%s,
                            time_created=%s
                            WHERE comment_id=%s""", (self.rendezvous_id,
                                self.author,
                                self.comment,
                                to_timestamp(self.time_created),
                                self.comment_id))
            db.commit()
        except Exception:
            pass

    def __str__(self):
        return "<RendezVousComment: %d, %d, %s, %s, %s>" % (self.comment_id, self.rendezvous_id, self.author, self.comment, str(self.time_created))


class RendezVousType(object):

    def __init__(self, env, type_id, name):
        self.env = env
        self.type_id = type_id
        self.name = to_unicode(name)
        self.typePermissions = TypePermission.fetch(env, type_id)

    @staticmethod
    def fetch_one(env, type_id=None, name=None):
        db = env.get_db_cnx()
        cursor = db.cursor()
        if type_id and type_id > 0:
            validate_id(int(type_id))
            cursor.execute("""SELECT *
                           FROM rendezvous_type
                           WHERE type_id=%s""", (type_id,))
        else:
            cursor.execute("""SELECT *
                           FROM rendezvous_type
                           WHERE name=%s""", (name,))
        row = cursor.fetchone()
        if row:
            return RendezVousType(env, row[0], row[1])
        return None

    @staticmethod
    def fetch_all(env):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("SELECT * FROM rendezvous_type")
        rows = cursor.fetchall()
        if not rows:
            return []
        res = []
        for row in rows:
            res.append(RendezVousType(env, row[0], row[1]))
        return res

    def commit(self):
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("""INSERT INTO rendezvous_type
                        (name)
                        VALUES(%s)""", (self.name,))
        db.commit()
        self.type_id = db.get_last_id(cursor, 'rendezvous_type')

    def has_permission(self, permission):
        for i in self.typePermissions:
            if i.permission == permission:
                return True
        return False

    def delete(self):
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        TypePermission.delete_by_type(self.env, self.type_id)
        cursor.execute("DELETE FROM rendezvous_type WHERE type_id=%s", (self.type_id,))
        db.commit()

    def update(self):
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("""UPDATE rendezvous_time
                        SET name=%s
                        WHERE type_id=%s""", (self.name, self.type_id))
        db.commit()

class TypePermission(object):

    def __init__(self, env, type_id, permission):
        self.env = env
        self.type_id = type_id
        self.permission = permission

    @staticmethod
    def fetch(env, type_id):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("""SELECT *
                           FROM rendezvous_type_to_permission
                           WHERE type_id=%s""", (type_id,) )
        rows = cursor.fetchall()
        if not rows:
            return []
        res = []
        for row in rows:
            res.append(TypePermission(env, row[0], row[1]))
        return res

    @staticmethod
    def fetch_one(env, type_id, permission):
        db = env.get_db_cnx()
        cursor = db.cursor()
        if int(type_id) > 0:
            cursor.execute("""SELECT *
                           FROM rendezvous_type_to_permission
                           WHERE type_id=%s AND permission=%s""", (type_id, permission))
        row = cursor.fetchone()
        if row:
            return TypePermission(env, row[0], row[1])
        return None

    @staticmethod
    def delete_by_type(env, type_id):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("DELETE FROM rendezvous_type_to_permission WHERE type_id=%s", (type_id,))
        db.commit()

    def commit(self):
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("""INSERT INTO rendezvous_type_to_permission
                        (type_id, permission)
                        VALUES(%s,%s)""", (self.type_id, self.permission))
        db.commit()

    def delete(self):
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("DELETE FROM rendezvous_type_to_permission WHERE type_id=%s AND permission=%s", (self.type_id, self.permission))
        db.commit()

    def __str__(self):
        return "<TypePermission: %d %s>" % (self.type_id, self.permission)


class RendezVous(object):
    def __init__(self, env, fetch_dates, rendezvous_id, name, author, email, description, time_created, schedule_deadline, min_votes, type_id, status, location_id, is_date_fixed, tags):
        self.env = env
        self.rendezvous_id = rendezvous_id
        self.name = to_unicode(name)
        self.author = to_unicode(author)
        self.email = to_unicode(email)
        self.description = to_unicode(description)
        self.time_created = time_created
        self.schedule_deadline = schedule_deadline
        self.min_votes = min_votes
        self.type_id = type_id
        t = RendezVousType.fetch_one(self.env, type_id)
        self.type_name = t and t.name or None
        self.status = to_unicode(status)
        self.location_id = location_id
        self.is_date_fixed = is_date_fixed
        self.dates = []
        self.tags = tags
        self.elected = 0
        if fetch_dates:
            self.dates = RendezVousDate.fetch_by_rendezvous(env, self.rendezvous_id)
            for i in self.dates:
                if i.elected:
                    self.elected = i.date_id

    @staticmethod
    def fetch_one(env, rid=None, name=None, fetch_dates=False):
        db = env.get_db_cnx()
        cursor = db.cursor()
        rendezvous_id=0
        if rid:
            rendezvous_id = int(rid)
            validate_id(rendezvous_id)
            cursor.execute("""SELECT *
                            FROM rendezvous
                            WHERE rendezvous_id=%s""", (rendezvous_id,))
        if name:
            myname = unicode(name)
            cursor.execute("""SELECT *
                            FROM rendezvous
                            WHERE name=%s""", name)

        row = cursor.fetchone()
        if not row:
            return None

        rendezvous_id, name, author, email, description, time_created, schedule_deadline, min_votes, type_id, status, location_id, is_date_fixed, tags = row
        return RendezVous(env, fetch_dates, rendezvous_id, name, author, email, description,
            datetime.utcfromtimestamp(time_created), datetime.utcfromtimestamp(schedule_deadline), min_votes, type_id, status, location_id, is_date_fixed, tags)

    @staticmethod
    def _fetch_some(env, fetch_dates, query, *args):
        db = env.get_db_cnx()
        cursor = db.cursor()
        if args:
            cursor.execute(query, args)
        else:
            cursor.execute(query)
        rows = cursor.fetchall()
        if not rows:
            return []
        res = []
        for row in rows:
            rendezvous_id, name, author, email, description, time_created, schedule_deadline, min_votes, type_id, status, location_id, is_date_fixed, tags = row
            res.append(
                RendezVous(env, fetch_dates, rendezvous_id, name, author,
                    email, description, datetime.utcfromtimestamp(time_created), datetime.utcfromtimestamp(schedule_deadline),
                    min_votes, type_id, status, location_id, is_date_fixed, tags))
        return res

    def get_date(self, date_id):
        for i in self.dates:
            if i.date_id == date_id:
                return i
        raise ValueError("RendezVousDate not found in RendezVous")

    @staticmethod
    def fetch_all(env, fetch_dates=False, sort=None):
        if not sort:
            return RendezVous._fetch_some(env, fetch_dates, "SELECT * FROM rendezvous;")
        return RendezVous._fetch_some(env, fetch_dates, "SELECT * FROM rendezvous ORDER BY name")

    @staticmethod
    def my_rendezvous(env, name):
        return RendezVous._fetch_some(env, False, "SELECT * FROM rendezvous where author = %s;", name)

    @staticmethod
    def exists(env, rendezvous_id=0):
        db = env.get_db_cnx()
        cursor = db.cursor()
        if int(rendezvous_id) <= 0:
            return False
        cursor.execute("""SELECT *
                        FROM 'rendezvous'
                        WHERE rendezvous_id=%s""", (rendezvous_id,))
        row = cursor.fetchone()
        return row != None

    def has_voted(self, authname=None):
        for date in self.dates:
            for vote in date.votes:
                if vote.user == authname:
                    return True
        return False

    def has_votes(self):
        for date in self.dates:
            if date.votes:
                return True
        return False

    def commit(self):
        db = self.env.get_db_cnx()
        t = datetime.now(utc)
        cursor = db.cursor()
        cursor.execute( "INSERT INTO rendezvous "
                        "(name,author,email,description,time_created,schedule_deadline,min_votes,type_id,status,location_id,is_date_fixed,tags) "
                        "VALUES(%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)",
            (self.name, self.author, self.email, self.description, to_timestamp(t),
                to_timestamp(self.schedule_deadline), self.min_votes, self.type_id,
                self.status, self.location_id, self.is_date_fixed, self.tags))
        db.commit()
        self.rendezvous_id = db.get_last_id(cursor, 'rendezvous')

    @staticmethod
    def delete(env, rendezvous_id):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("DELETE FROM rendezvous WHERE rendezvous_id = %s", (rendezvous_id,))
        db.commit()

    def update(self):
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("UPDATE rendezvous " \
            "SET name =%s, " \
            "author=%s, " \
            "email=%s, " \
            "description=%s, " \
            "time_created=%s, " \
            "schedule_deadline=%s, " \
            "min_votes=%s, " \
            "type_id=%s, " \
            "status=%s, " \
            "location_id=%s, " \
            "is_date_fixed=%s, " \
            "tags=%s " \
            "WHERE rendezvous_id=%s", (self.name, self.author, self.email,
                self.description, to_timestamp(self.time_created), to_timestamp(self.schedule_deadline),
                self.min_votes, self.type_id, self.status, self.location_id, self.is_date_fixed, self.tags, self.rendezvous_id))
        db.commit()

    def __str__(self):
        return "<RendezVous: %d, %s, %s, %s, %s>" % (self.rendezvous_id, self.name, self.author, self.email, str(self.time_created))


class RendezVousModelProvider(Component):
    implements(IEnvironmentSetupParticipant)

    SCHEMA = [

    # rendezvous system
    Table('rendezvous', key='rendezvous_id')[
        Column('rendezvous_id', auto_increment=True),
        Column('name'),
        Column('author'),
        Column('email'),
        Column('description'),
        Column('time_created', type='int'),
        Column('schedule_deadline', type='int'),
        Column('min_votes', type='int'),
        Column('type_id', type='int'),
        Column('status'),
        Column('location_id', type='int'),
        Column('is_date_fixed', type='int'),
        Column('tags'),
        Index(['name']),
        Index(['status']) ],

    Table('rendezvous_comment', key='comment_id')[
        Column('comment_id', auto_increment=True),
        Column('rendezvous_id', type='int'),
        Column('author'),
        Column('comment'),
        Column('time_created', type='int')],

    # an user's spare time frame
    Table('rendezvous_date', key='id')[
        Column('date_id', auto_increment=True),
        Column('rendezvous_id', type='int'),
        Column('author'),
        Column('email'),
        Column('time_created', type='int'),
        Column('time_begin', type='int'),
        Column('time_end', type='int'),
        Column('elected', type='int')],


    Table('rendezvous_type', key=["type_id"])[
        Column("type_id", auto_increment=True),
        Column("name"),
        Index(["name"])],

    Table('rendezvous_type_to_permission', key=["type_id", "permission"])[
        Column("type_id", type="int"),
        Column("permission")],

     # user's votings for a date with date and length of time frame
    Table('rendezvous_vote', key=['vote_id'])[
        Column('vote_id', auto_increment=True),
        Column('date_id', type='int'),
        Column('user'),
        Column('email'),
        Column('time_created', type='int'),
        Column('time_begin', type='int'),
        Column('time_end', type='int'),
        Index(['time_begin']),
        Index(['time_end'])]]

    RendezVousDateTrigger = "CREATE TRIGGER fkd_date_rendezvous_id " \
                        "BEFORE DELETE ON rendezvous " \
                        "FOR EACH ROW BEGIN " \
                        "DELETE from rendezvous_date WHERE rendezvous_id = OLD.rendezvous_id; " \
                        "END;"

    RendezVousCommentTrigger = "CREATE TRIGGER fkd_comment_rendezvous_id " \
                        "BEFORE DELETE ON rendezvous " \
                        "FOR EACH ROW BEGIN " \
                        "DELETE from rendezvous_comment WHERE rendezvous_id = OLD.rendezvous_id; " \
                        "END;"

    RendezVousVoteTrigger = "CREATE TRIGGER fkd_vote_date_id " \
                        "BEFORE DELETE ON rendezvous_date " \
                        "FOR EACH ROW BEGIN " \
                        "DELETE from rendezvous_vote WHERE date_id = OLD.date_id; " \
                        "END;"

    TYPE_DATA = (
    (u'public',),
    (u'admin',),
    (u'Offizieller Treff',),
    (u'Topic Treff',))


    LOCATION_DATA = (
        (u"CTDO, Langer August", "N", 51, 31, 39.4, "E", 7, 27, 53.8, 51.527611, 7.464922),
        (u"WILA, Langer August", "N", 51, 31, 39.4, "E", 7, 27, 53.8, 51.527611, 7.464922))

    TYPE_PERMISSIONS_DATA = (
    (1, u'RENDEZVOUS_VIEW'),
    (2, u'RENDEZVOUS_ADMIN'))

    def environment_created(self):

        if not "rendezvous" in self.config.sections():
            data = {"graph_size_x" : 1024,
                "graph_size_y" : 300,
                "max_dates_per_rendezvous" : 99,
                "max_description_length" : 1024,
                "max_votes_per_date" : 99,
                "show_location_map" : True,
                "show_vote_graph" : True}
            for k, v in data.iteritems():
              self.config.set("rendezvous", k, v)
            self.config.save()
        self._create_models(self.env.get_db_cnx())

    def environment_needs_upgrade(self, db):
        """First version - nothing to migrate, but possibly to create.
        """

        cursor = db.cursor()
        try:
            cursor.execute("select count(*) from rendezvous")
            cursor.fetchone()
            cursor.execute("select count(*) from rendezvous_date")
            cursor.fetchone()
            cursor.execute("select count(*) from rendezvous_comment")
            cursor.fetchone()
            cursor.execute("select count(*) from rendezvous_type")
            cursor.fetchone()
            cursor.execute("select count(*) from rendezvous_type_to_permission")
            cursor.fetchone()
            cursor.execute("select count(*) from rendezvous_vote")
            cursor.fetchone()
            return False
        except:
            db.rollback()
            return True

    def upgrade_environment(self, db):
        """ nothing to do here for now
        """
        self._create_models(db)

    def _create_models(self, db):

        """Called when a new Trac environment is created."""

        db_backend = None
        try:
            from trac.db import DatabaseManager
            db_backend, _ = DatabaseManager(self.env)._get_connector()
        except ImportError:
            db_backend = self.env.get_db_cnx()

        cursor = db.cursor()
        for table in self.SCHEMA:
            for stmt in db_backend.to_sql(table):
                self.env.log.debug(stmt)
                try:
                    cursor.execute(stmt)
                    db.commit()
                except Exception, e:
                    self.env.log.warning(str(e))
                    db.rollback()
        cursor.execute(self.RendezVousCommentTrigger)
        cursor.execute(self.RendezVousDateTrigger)
        cursor.execute(self.RendezVousVoteTrigger)
        db.commit()
        #try:
        cursor.executemany("""INSERT INTO 'rendezvous_type'
                    (name)
                    VALUES(%s)""", self.TYPE_DATA)
        db.commit()

class RendezVousTypePermissionSystem(Component):

    def check_user_type_permissions(self, user, type_id=None, name=None):
        ps = PermissionSystem(self.env).get_user_permissions(user)
        if 'RENDEZVOUS_ADMIN' in ps:
            return True
        t  = RendezVousType.fetch_one(self.env, type_id=type_id, name=name)
        if not t:
            return False
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("""SELECT permission
                           FROM rendezvous_type_to_permission
                           WHERE type_id=%s""", (t.type_id,))
        rows = cursor.fetchall()
        for p in rows:
            if not ps.has_key(p[0]):
                return False
        return True