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

from trac.core import *
from trac.perm import PermissionSystem
from trac.db import Table, Column, Index
from datetime import datetime
from trac.util.datefmt import utc, to_timestamp
from trac.util.text import to_unicode
from trac.env import IEnvironmentSetupParticipant
from tracbooking.utils import validate_id, make_hash

__all__ = [
    'Attendee',
    'BookingOption',
    'AvailableOption',
    'BookingModelsupplier',
    'Event',
    'EventAccount',
    'Option2Event',
    'Supplier',
    'BookingReminder',
    "AvailableOptionVariation",
    "BookingOptionVariation"]

class BookingOption(object):
    def __init__(self, env, bo_id, a_id, ao_id, count, fetch_variations=False):
        self.env = env
        self.bo_id = int(bo_id)
        self.a_id = int(a_id)
        self.ao_id = int(ao_id)
        self.count = int(count)
        self.variations = []
        if fetch_variations:
            self.variations = BookingOptionVariation.fetch_by_attendee(env, a_id)

    @staticmethod
    def fetch_one(env, a_id, ao_id, fetch_variations=False):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("SELECT bo_id, a_id, ao_id, count " \
                        "FROM booking_option " \
                        "WHERE a_id=%s and ao_id=%s", (a_id, ao_id))
        row = cursor.fetchone()
        if not row:
            return []
        return BookingOption(env, fetch_variations=fetch_variations, *row)

    @staticmethod
    def fetch_by_attendee(env, a_id, fetch_variations=False):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("SELECT bo_id, a_id, ao_id, count FROM booking_option "  \
                "WHERE a_id=%s", (a_id,))
        rows = cursor.fetchall()
        if not rows:
            return []
        return [BookingOption(env, fetch_variations=fetch_variations, *row) for row in rows]

    @staticmethod
    def exists(env, a_id):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("SELECT COUNT(*) FROM booking_option " \
                       "WHERE o_id=%s;", (a_id,))
        row = cursor.fetchone()
        return row[0] > 0

    def commit(self):
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("INSERT INTO booking_option " \
                       "(a_id, ao_id, count) " \
                       "VALUES(%s, %s, %s);", (
                        self.a_id,
                        self.ao_id,
                        self.count))
        db.commit()
        self.bo_id = db.get_last_id(cursor, 'booking_option')

    @staticmethod
    def delete(env, a_id, ao_id):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("DELETE FROM booking_option " \
                        "WHERE a_id =%s and ao_id=%s;", (a_id, ao_id))
        db.commit()

    @staticmethod
    def delete_by_attendee(env, a_id):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("DELETE FROM booking_option " \
                        "WHERE a_id =%s;", (a_id,))
        db.commit()

    def update(self):
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("UPDATE booking_option " \
                        "SET count=%s " \
                        "WHERE a_id=%s and ao_id=%s;", (
                        self.count,
                        self.a_id,
                        self.ao_id))
        db.commit()

class BookingOptionVariation(object):
    def __init__(self, env, attendee_id, variation_id, ovi_id):
        self.env = env
        self.attendee_id = attendee_id
        self.variation_id = variation_id
        self.ovi_id = ovi_id

    @staticmethod
    def fetch_one(env, attendee_id, variation_id):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("SELECT attendee_id,variation_id,ovi_id " \
                        "FROM booking_option_variations " \
                        "WHERE attendee_id=%s AND variation_id=%s;", (attendee_id,variation_id))
        row = cursor.fetchone()
        return row and BookingOptionVariation(env, *row) or None

    @staticmethod
    def fetch_by_attendee(env, attendee_id):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("SELECT attendee_id,variation_id,ovi_id " \
                        "FROM booking_option_variations " \
                        "WHERE attendee_id=%s;", (attendee_id,))
        return [BookingOptionVariation(env, *row) for row in cursor.fetchall()]

    def commit(self):
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("INSERT INTO booking_option_variations " \
                       "(attendee_id,variation_id,ovi_id) " \
                       "VALUES(%s, %s, %s);", (
                        self.attendee_id,
                        self.variation_id,
                        self.ovi_id))
        db.commit()

    @staticmethod
    def delete(self, env, bov_id):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("DELETE FROM booking_option_variations " \
                       "WHERE attendee_id=%s and variation_id=%s;", (attendee_id,variation_id))
        db.commit()

    @staticmethod
    def update(env, attendee_id, variation_id, ovi_id):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("UPDATE booking_option_variations " \
                       "SET ovi_id=%s WHERE attendee_id=%s and variation_id=%s;", (ovi_id, attendee_id, variation_id))
        db.commit()

class AvailableOption(object):
    def __init__(self, env, ao_id, name, description, price, active, min_count, max_count, supplier_id, ext_id, stock_count, fetch_variations=True, attendee_id=None):
        self.env = env
        self.ao_id = ao_id
        self.name = name
        self.description = description
        self.price = price
        self.active = active
        self.min_count = min_count
        self.max_count = max_count
        self.supplier_id = supplier_id
        self.ext_id = ext_id
        self.stock_count = stock_count
        self.variations = fetch_variations and AvailableOptionVariation.fetch_all(env, ao_id, attendee_id=attendee_id) or []

    @staticmethod
    def fetch_one(env, ao_id=None, name=None, fetch_variations=True, attendee_id=None):
        db = env.get_db_cnx()
        cursor = db.cursor()
        if not name:
            cursor.execute("""SELECT ao_id,name,description,price,active,min_count,max_count,supplier_id,ext_id,stock_count
                        FROM booking_available_option
                        WHERE ao_id=%s""", (ao_id,))
        else:
            cursor.execute("""SELECT ao_id,name,description,price,active,min_count,max_count,supplier_id,ext_id,stock_count
                        FROM booking_available_option
                        WHERE name=%s""", (name,))
        row = cursor.fetchone()
        if not row:
            return None
        return AvailableOption(env, fetch_variations=fetch_variations, attendee_id=attendee_id, *row)

    @staticmethod
    def fetch_all(env, only_active=False, fetch_variations=True):
        db = env.get_db_cnx()
        cursor = db.cursor()
        if not only_active:
            cursor.execute("""SELECT ao_id,name,description,price,active,min_count,max_count,supplier_id,ext_id,stock_count
                FROM booking_available_option;""")
        else:
            cursor.execute("""SELECT ao_id,name,description,price,active,min_count,max_count,supplier_id,ext_id,stock_count
                FROM booking_available_option where active=1;""")
        return [AvailableOption(env, fetch_variations=fetch_variations, *row) for row in cursor.fetchall()]

    @staticmethod
    def fetch_by_event(env, e_id):
        maps = Option2Event.fetch_by_event(env, e_id)
        db = env.get_db_cnx()
        cursor = db.cursor()
        maps = [m.ao_id for m in maps]
        s = """SELECT ao_id,name,description,price,active,min_count,max_count,supplier_id,ext_id,stock_count
            FROM booking_available_option where ao_id in %s;""" % str(tuple(maps))
        cursor.execute(s)
        rows = cursor.fetchall()
        if not rows:
            return []
        return [AvailableOption(env, *row) for row in cursor.fetchall()]

    def commit(self):
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("""INSERT INTO booking_available_option
                        (name, description, price, active, min_count, max_count,supplier_id,ext_id,stock_count)
                        VALUES(%s, %s, %s, %s, %s, %s, %s, %s, %s)""", (
                        self.name,
                        self.description,
                        self.price,
                        self.active,
                        self.min_count,
                        self.max_count,
                        self.supplier_id,
                        self.ext_id,
                        self.stock_count))
        db.commit()
        self.ao_id = db.get_last_id(cursor, 'booking_available_option')

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

    def update(self):
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("""UPDATE booking_available_option
                        SET name=%s,
                        description=%s,
                        price=%s,
                        active=%s,
                        min_count=%s,
                        max_count=%s,
                        supplier_id=%s,
                        ext_id=%s,
                        stock_count=%s
                        WHERE ao_id = %s;""", (
                        self.name,
                        self.description,
                        self.price,
                        self.active,
                        self.min_count,
                        self.max_count,
                        self.supplier_id,
                        self.ext_id,
                        self.stock_count,
                        self.ao_id))
        db.commit()

class AvailableOptionVariation(object):
    def __init__(self, env, variation_id, option_id, name, attendee_id=None):
        self.env = env
        self.variation_id = variation_id
        self.option_id = option_id
        self.name = name
        self.variations = AvailableOptionVariationItem.fetch_all(env, variation_id)
        self.selected_data = None
        if attendee_id:
            selected = attendee_id and BookingOptionVariation.fetch_one(env, attendee_id, variation_id) or None
            if selected:
                self.selected_data = AvailableOptionVariationItem.fetch_one(env, selected.ovi_id)

    @staticmethod
    def fetch_one(env, variation_id=None, attendee_id=None):
        db = env.get_db_cnx()
        cursor = db.cursor()
        if not name:
            cursor.execute("SELECT variation_id,option_id,name " \
                "FROM booking_available_option_variations " \
                "WHERE variation_id=%s", (variation_id,))
        row = cursor.fetchone()
        if not row:
            return None
        return AvailableOptionVariation(env, attendee_id=attendee_id, *row)

    @staticmethod
    def fetch_all(env, option_id, attendee_id=None):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("SELECT variation_id,option_id,name " \
        "FROM booking_available_option_variations " \
        "WHERE option_id=%s", (option_id,))
        rows = cursor.fetchall()
        if not rows:
            return None
        return [AvailableOptionVariation(env, attendee_id=attendee_id, *row) for row in rows]

    def commit(self):
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("INSERT INTO booking_available_option_variations " \
            "(option_id, name) " \
            "VALUES(%s, %s, %s)", (
            self.option_id,
            self.name))
        db.commit()
        self.variation_id = db.get_last_id(cursor, 'booking_available_option_variations')

    @staticmethod
    def delete(env, ovi_id):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("DELETE FROM booking_available_option_variations " \
                        "WHERE variation_id =%s;", (variation_id,))
        db.commit()

    def update(self):
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("PDATE booking_available_option_variations " \
                        "SET option_id=%s, " \
                        "name=%s " \
                        "WHERE variation_id = %s;", (
                        self.option_id,
                        self.name,
                        self.variation_id))
        db.commit()

class AvailableOptionVariationItem(object):
    def __init__(self, env, ovi_id, variation_id, name, value, description=""):
        self.env = env
        self.ovi_id = ovi_id
        self.variation_id = variation_id
        self.name = name
        self.value = value
        self.description = description

    @staticmethod
    def fetch_one(env, ovi_id=None):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("SELECT ovi_id,variation_id,name,value,description " \
            "FROM booking_available_option_variation_items " \
            "WHERE ovi_id=%s", (ovi_id,))
        row = cursor.fetchone()
        if not row:
            return None
        return AvailableOptionVariationItem(env, *row)

    @staticmethod
    def fetch_all(env, variation_id):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("SELECT ovi_id,variation_id,name,value,description " \
        "FROM booking_available_option_variation_items " \
        "WHERE variation_id=%s", (variation_id,))
        rows = cursor.fetchall()
        if not rows:
            return None
        return [AvailableOptionVariationItem(env, *row) for row in rows]

    def commit(self):
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("INSERT INTO booking_available_option_variation_items " \
            "(variation_id, name, value) " \
            "VALUES(%s, %s, %s, %s)", (
            self.variation_id,
            self.name,
            self.value,
            self.description))
        db.commit()
        self.ovi_id = db.get_last_id(cursor, 'booking_available_option_variation_items')

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

    def update(self):
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("UPDATE booking_available_option_variation_items " \
            "SET variation_id=%s, " \
            "name=%s, " \
            "value=%s, " \
            "description=%s " \
            "WHERE ovi_id = %s;", (
            self.variation_id,
            self.name,
            self.value,
            self.description,
            self.ovi_id))
        db.commit()

class Supplier(object):

    """I hate this coding shit. sqlalchemy rulez!"""
    def __init__(self, env, supplier_id, name, address, phone, email, fax):

        self.env = env
        self.supplier_id = int(supplier_id)
        self.name = name
        self.address = address
        self.phone = phone
        self.email = email
        self.fax = fax

    @staticmethod
    def fetch_one(env, supplier_id=0, name=None):
        db = env.get_db_cnx()
        cursor = db.cursor()
        if not name:
            cursor.execute("SELECT name, address, phone, email, fax " \
                            "FROM supplier " \
                            "WHERE supplier_id=%s", (supplier_id,))
        else:
            cursor.execute("SELECT name, address, phone, email, fax " \
                            "FROM supplier " \
                            "WHERE name=%s", (name,))
        row = cursor.fetchone()
        if not row:
            return None
        return Supplier(env, *row)

    @staticmethod
    def fetch_all(env):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("SELECT supplier_id, name, address, phone, email, fax FROM supplier;")
        rows = cursor.fetchall()
        if not rows:
            return []
        return [Supplier(env, *row) for row in rows]

    def commit(self):
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("INSERT INTO supplier " \
                    "(name, address, phone, email, fax) " \
                    "VALUES(%s, %s, %s, %s, %s)", (
                        self.supplier_id,
                        self.name,
                        self.address,
                        self.phone,
                        self.email,
                        self.fax))
        db.commit()
        self.supplier_id = db.get_last_id(cursor, 'supplier')

    @staticmethod
    def delete(env, a_id, e_id):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("DELETE FROM supplier WHERE supplier_id = %s;", (supplier_id,))
        db.commit()

    def update(self):
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("UPDATE supplier " \
                    "SET name=%s, " \
                    "address=%s, " \
                    "phone=%s, " \
                    "email=%s, " \
                    "fax=%s " \
                    "WHERE supplier_id=%s;", (
                        self.name,
                        self.address,
                        self.phone,
                        self.email,
                        self.fax,
                        self.supplier_id))
        db.commit()


class Attendee(object):

    def __init__(self, env, a_id, e_id, ext_id, nick, email, finished, has_paid, time, actual_amount, fetch_options=False, fetch_variations=False):
        self.env = env
        self.a_id = int(a_id)
        self.e_id = int(e_id)
        self.ext_id = to_unicode(ext_id)
        self.nick = to_unicode(nick)
        self.email = to_unicode(email)
        self.finished = int(bool(finished))
        self.has_paid = int(bool(has_paid))
        self.time = time
        self.actual_amount = actual_amount
        self.options = None
        if fetch_options:
            self.options = BookingOption.fetch_by_attendee(env, self.a_id, fetch_variations=fetch_variations)

    @staticmethod
    def fetch_one(env, a_id=0, nick=None, e_id=0, fetch_options=False, fetch_variations=False):
        db = env.get_db_cnx()
        cursor = db.cursor()
        if not nick:
            cursor.execute("""SELECT a_id, e_id, ext_id, nick, email, finished, has_paid, time, actual_amount
                            FROM attendee
                            WHERE a_id=%s""", (a_id,))
        else:
            cursor.execute("""SELECT a_id, e_id, ext_id, nick, email, finished, has_paid, time, actual_amount
                            FROM attendee
                            WHERE nick=%s and e_id=%s""", (nick, e_id))
        row = cursor.fetchone()
        if not row:
            return None
        a_id, e_id, ext_id, nick, email, finished, has_paid, time, actual_amount = row
        return Attendee(env, a_id, e_id, ext_id, nick, email, finished, has_paid, datetime.utcfromtimestamp(time), actual_amount, fetch_options=fetch_options, fetch_variations=fetch_variations)

    @staticmethod
    def fetch_all(env, e_id=0, fetch_options=False, fetch_variations=False):
        db = env.get_db_cnx()
        cursor = db.cursor()
        s = "SELECT a_id, e_id, ext_id, nick, email, finished, has_paid, time, actual_amount FROM attendee %s;"
        if e_id > 0:
            s = s % "WHERE attendee.e_id=%s"
            cursor.execute(s, (e_id,))
        else:
            cursor.execute(s % "")
        rows = cursor.fetchall()
        if not rows:
            return []
        res = []
        for row in rows:
            a_id, e_id, ext_id, nick, email, finished, has_paid, time, actual_amount = row
            res.append(Attendee(env, a_id, e_id, ext_id, nick, email, finished, has_paid, datetime.utcfromtimestamp(time), actual_amount, fetch_options=fetch_options, fetch_variations=fetch_variations))
        return res

    @staticmethod
    def fetch_all_sorted(env, e_id=0, fetch_options=False):
        db = env.get_db_cnx()
        cursor = db.cursor()
        s = "SELECT attendee.a_id, attendee.e_id, attendee.ext_id, attendee.nick, attendee.email, attendee.finished, attendee.has_paid, attendee.time, attendee.actual_amount, booking_event.name FROM attendee, booking_event WHERE attendee.e_id=booking_event.e_id %s ORDER BY booking_event.name;"
        if e_id > 0:
            s = s % "AND attendee.e_id=%s"
            cursor.execute(s, (e_id,))
        else:
            cursor.execute(s % "")
        rows = cursor.fetchall()
        if not rows:
            return []
        oldname = rows[0][-1]
        curname = rows[0][-1]
        res = []
        tmp = []
        for row in rows:
            curname = row[-1]
            if curname != oldname:
                res.append(tmp)
                tmp = []
            a_id, e_id, ext_id, nick, email, finished, has_paid, time, name, actual_amount = row
            a = Attendee(env, a_id, e_id, ext_id, nick, email, finished, has_paid, datetime.utcfromtimestamp(time), actual_amount, fetch_options)
            a.name = name
            tmp.append(a)
            oldname = curname
        res.append(tmp)
        return res

    @staticmethod
    def exists(env, nick):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("""SELECT COUNT(*) FROM attendee
                        WHERE nick=%s;""", (nick,))
        row = cursor.fetchone()
        return row[0] > 0

    def commit(self):
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("""INSERT INTO attendee
                        (e_id, ext_id, nick, email, finished, has_paid, time, actual_amount)
                        VALUES(%s, %s,  %s, %s, %s, %s, %s, %s)""", (
                        self.e_id,
                        self.ext_id,
                        self.nick,
                        self.email,
                        self.finished,
                        self.has_paid,
                        to_timestamp(self.time),
                        self.actual_amount))
        db.commit()
        self.a_id = db.get_last_id(cursor, 'attendee')

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

    def update(self):
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("""UPDATE attendee
                        SET nick=%s,
                        email=%s,
                        finished=%s,
                        has_paid=%s,
                        actual_amount=%s
                        WHERE a_id=%s;""", (
                        self.nick,
                        self.email,
                        self.finished,
                        self.has_paid,
                        self.actual_amount,
                        self.a_id))
        db.commit()

    def calculate_fee(self):
        cache = {}
        res = 0.0
        for i in self.options:
            opt = AvailableOption.fetch_one(self.env, i.ao_id)
            res += opt.price * i.count
        return "%.2f" % res

class EventAccount(object):
    def __init__(self, env, ea_id, e_id, account_owner, account_no, bank_name, bank_no, first_reason, second_reason):
        self.env = env
        self.ea_id = ea_id
        self.e_id = e_id
        self.account_owner = account_owner
        self.account_no = account_no
        self.bank_name = bank_name
        self.bank_no = bank_no
        self.first_reason = first_reason
        self.second_reason = second_reason

    @staticmethod
    def fetch_by_event(env, e_id):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("""SELECT *
            FROM event_account
            WHERE e_id=%s""", (e_id,))
        row = cursor.fetchone()
        if not row:
            return None
        return EventAccount(env, *row)

    @staticmethod
    def copy_by_event(env, old_id, new_id):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("SELECT account_owner, account_no, bank_name, bank_no, first_reason, second_reason FROM event_account where e_id=%s;", (old_id,))
        row = cursor.fetchone()
        account_owner, account_no, bank_name, bank_no, first_reason, second_reason = row

        cursor.execute("INSERT INTO event_account " \
            "(e_id, account_owner, account_no, bank_name, bank_no, first_reason, second_reason) " \
            "VALUES(%s,%s,%s,%s,%s,%s,%s);", (
            new_id,
            account_owner,
            account_no,
            bank_name,
            bank_no,
            first_reason,
            second_reason))
        

    def commit(self):
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("INSERT INTO event_account " \
                       "(e_id, account_owner, account_no, bank_name, bank_no, first_reason, second_reason) " \
                       "VALUES(%s, %s, %s, %s, %s, %s, %s)", (
                        self.e_id,
                        self.account_owner,
                        self.account_no,
                        self.bank_name,
                        self.bank_no,
                        self.first_reason,
                        self.second_reason))
        db.commit()
        self.a_id = db.get_last_id(cursor, 'event_account')

    def update(self):
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("UPDATE event_account SET " \
                    "e_id=%s, " \
                    "account_owner=%s, " \
                    "account_no=%s, " \
                    "bank_name=%s, " \
                    "bank_no=%s, " \
                    "first_reason=%s, " \
                    "second_reason=%s;", (
                    self.e_id,
                    self.account_owner,
                    self.account_no,
                    self.bank_name,
                    self.bank_no,
                    self.first_reason,
                    self.second_reason))
        db.commit()
        self.ea_id = db.get_last_id(cursor, 'event_account')

    def __zero__(self):
        return self.ea_id != 0

class Event(object):
    def __init__(self, env, e_id, name, description, time_begin, time_end, register_deadline=datetime.now(utc), edit_deadline=datetime.now(utc), payment_deadline=datetime.now(utc), fetch_options=False, only_active=False, attendee_id=None):
        self.env = env
        self.e_id = e_id
        self.name = name
        self.description = description
        self.time_begin = time_begin
        self.time_end = time_end
        self.register_deadline = register_deadline
        self.edit_deadline = edit_deadline
        self.payment_deadline = payment_deadline
        self.options = []
        if fetch_options:
            relations = Option2Event.fetch_by_event(self.env, self.e_id)
            for relation in relations:
                option = AvailableOption.fetch_one(self.env, relation.ao_id, attendee_id=attendee_id)
                if option:
                    if only_active and not option.active:
                        continue
                    self.options.append(option)

    @staticmethod
    def fetch_one(env, e_id=0, name=None, fetch_options=False, only_active=False, attendee_id=None):
        db = env.get_db_cnx()
        cursor = db.cursor()
        if not name:
            cursor.execute("SELECT e_id, name, description, time_begin, time_end, register_deadline, edit_deadline, payment_deadline " \
                            "FROM booking_event " \
                            "WHERE e_id=%s", (e_id,))
        else:
            cursor.execute("SELECT e_id, name, description, time_begin, time_end, register_deadline, edit_deadline, payment_deadline "
                            "FROM booking_event " \
                            "WHERE name=%s", (name,))
        row = cursor.fetchone()
        if not row:
            return None
        e_id, name, description, time_begin, time_end, register_deadline, edit_deadline, payment_deadline = row
        return Event(env, e_id, name, description, datetime.utcfromtimestamp(time_begin), datetime.utcfromtimestamp(time_end), datetime.utcfromtimestamp(register_deadline), datetime.utcfromtimestamp(edit_deadline),  datetime.utcfromtimestamp(payment_deadline), fetch_options=fetch_options, only_active=only_active, attendee_id=attendee_id)

    @staticmethod
    def fetch_all(env, fetch_options=False, only_active=False, attendee_id=None):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("""SELECT e_id, name, description, time_begin, time_end, register_deadline, edit_deadline, payment_deadline FROM booking_event;""")
        rows = cursor.fetchall()
        if not rows:
            return []
        res = []
        for row in rows:
            e_id, name, description, time_begin, time_end, register_deadline, edit_deadline, payment_deadline = row
            res.append(Event(env, e_id, name, description, datetime.utcfromtimestamp(time_begin), datetime.utcfromtimestamp(time_end), datetime.utcfromtimestamp(register_deadline), datetime.utcfromtimestamp(edit_deadline),  datetime.utcfromtimestamp(payment_deadline), fetch_options=fetch_options, only_active=only_active, attendee_id=attendee_id))
        return res

    @staticmethod
    def copy(env, e_id):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("SELECT e_id, name, description, time_begin, time_end, register_deadline, edit_deadline, payment_deadline " \
                            "FROM booking_event " \
                            "WHERE e_id=%s", (e_id,))

        row = cursor.fetchone()
        if not row:
            return None
        e_id, name, description, time_begin, time_end, register_deadline, edit_deadline, payment_deadline = row
        event = Event(env, e_id, "Kopie von " + name, description, datetime.utcfromtimestamp(time_begin), datetime.utcfromtimestamp(time_end), datetime.utcfromtimestamp(register_deadline), datetime.utcfromtimestamp(edit_deadline),  datetime.utcfromtimestamp(payment_deadline))
        event.commit()
        event_account = EventAccount.copy_by_event(env, e_id, event.e_id)

        relations = Option2Event.fetch_by_event(env, e_id)
        for relation in relations:
            print "relation", relation.ao_id, event.e_id
            Option2Event.copy_by_event(env, relation.ao_id, event.e_id)
        

    def add_options(self, attendee_id):
        self.options = list()
        relations = Option2Event.fetch_by_event(self.env, self.e_id)
        for relation in relations:
            option = AvailableOption.fetch_one(self.env, relation.ao_id, attendee_id=attendee_id)
            if option:
                self.options.append(option)

    @staticmethod
    def exists(env, name):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("SELECT COUNT(e_id) FROM booking_event WHERE name=%s;", (name,))
        row = cursor.fetchone()
        return row[0] > 0

    def commit(self):
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("INSERT INTO booking_event " \
                       "(name, description, time_begin, time_end, register_deadline, edit_deadline, payment_deadline) " \
                       "VALUES(%s, %s, %s, %s, %s, %s, %s)", (
                        self.name,
                        self.description,
                        to_timestamp(self.time_begin),
                        to_timestamp(self.time_end),
                        to_timestamp(self.register_deadline),
                        to_timestamp(self.edit_deadline),
                        to_timestamp(self.payment_deadline)))
        db.commit()
        self.e_id = db.get_last_id(cursor, 'booking_event')

    @staticmethod
    def delete(env, e_id):
        db = env.get_db_cnx()
        cursor = db.cursor()
        try:
            cursor.execute("DELETE FROM booking_event WHERE e_id=%s;", (e_id,))
            db.commit()
        except Exception, e:
            env.log.debug("Event delete failed\n%s" + str(e))
            pass

    def update(self):
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("""UPDATE booking_event
                        SET name=%s,
                        description=%s,
                        time_begin=%s,
                        time_end=%s,
                        register_deadline=%s,
                        edit_deadline=%s,
                        payment_deadline=%s
                        WHERE e_id=%s;""", (
                        self.name,
                        self.description,
                        to_timestamp(self.time_begin),
                        to_timestamp(self.time_end),
                        to_timestamp(self.register_deadline),
                        to_timestamp(self.edit_deadline),
                        to_timestamp(self.payment_deadline),
                        self.e_id))
        db.commit()

    def __zero__(self):
        return self.e_id != 0

class BookingReminder(object):
    def __init__(self, env, reminder_id, e_id, text, notify_on, was_send_on=None):
        self.env = env
        self.reminder_id = reminder_id
        self.e_id = e_id
        self.text = text
        self.notify_on = notify_on
        self.was_send_on = was_send_on

    @staticmethod
    def fetch_one(env, reminder_id):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("SELECT * FROM booking_reminder WHERE reminder_id=%s;", (reminder_id,))
        row = cursor.fetchone()
        if not row:
            return None
        return BookingReminder(env, *row)

    @staticmethod
    def fetch_all(env):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("SELECT * FROM booking_reminder;")
        rows = cursor.fetchall()
        if not rows:
            return []
        return [BookingReminder(env, *row) for row in rows]

    @staticmethod
    def fetch_by_event(env, e_id):
        db = env.get_db_cnx()
        cursor = db.cursor()
        if e_id:
            cursor.execute("""SELECT *
                            FROM booking_reminder
                            WHERE e_id=%s""", (e_id,))
        rows = cursor.fetchall()
        if not rows:
            return []
        return [BookingReminder(env, *row) for row in rows]

    def commit(self):
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("INSERT INTO booking_reminder " \
                       "(reminder_id, e_id, text, notify_on, was_send_on) " \
                       "VALUES(%s, %s,%s, %s,%s)", (
                        self.reminder_id,
                        self.e_id,
                        self.text,
                        self.notify_on,
                        self.was_send_on))
        db.commit()
        self.reminder_id = db.get_last_id(cursor, 'booking_reminder')

    @staticmethod
    def update(env, ao_id, e_id):
        db = env.get_db_cnx()
        cursor = db.cursor()
        try:
            cursor.execute("UPDATE booking_reminder SET " \
                "text=%s " \
                "notify_on=%s " \
                "was_send_on=%s " \
                "WHERE reminder_id=%s and e_id=%s;",
                (self.text, self.notify_on, self.was_send_on, self.reminder_id, self.e_id))
            db.commit()
        except Exception:
            pass

    @staticmethod
    def delete(env, ao_id, e_id):
        db = env.get_db_cnx()
        cursor = db.cursor()
        try:
            cursor.execute("DELETE FROM booking_reminder WHERE ao_id=%s AND e_id=%s;", (ao_id, e_id,))
            db.commit()
        except Exception:
            pass

class Option2Event(object):

    def __init__(self, env, ao_id, e_id):
        self.env = env
        self.ao_id = ao_id
        self.e_id = e_id

    @staticmethod
    def fetch_one(env, ao_id, e_id):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("SELECT ao_id, e_id FROM option_to_event WHERE ao_id=%s AND e_id=%s;", (ao_id, e_id))
        row = cursor.fetchone()
        if not row:
            return None
        return Option2Event(env, int(ao_id), int(e_id))

    @staticmethod
    def fetch_by_option(env, ao_id):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("SELECT ao_id, e_id " \
                            "FROM option_to_event " \
                            "WHERE ao_id=%s", (ao_id,))
        rows = cursor.fetchall()
        if not rows:
            return []
        res = []
        for row in rows:
            res.append(Option2Event(env, *row))
        return res

    @staticmethod
    def fetch_by_event(env, e_id):
        db = env.get_db_cnx()
        cursor = db.cursor()
        if e_id:
            cursor.execute("""SELECT ao_id, e_id
                            FROM option_to_event
                            WHERE e_id=%s""", (e_id,))
        rows = cursor.fetchall()
        if not rows:
            return []
        res = []
        for row in rows:
            res.append(Option2Event(env, *row))
        return res

    @staticmethod
    def fetch_all(env, fetch=False):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("SELECT ao_id, e_id FROM option_to_event")
        rows = cursor.fetchall()
        if not rows:
            return []
        res = []
        for ao_id, e_id in rows:
            res.append(Option2Event(env, int(ao_id), int(e_id), fetch=fetch))
        return res

    @staticmethod
    def copy_by_event(env, ao_id, e_id):
        db = env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("INSERT INTO option_to_event (ao_id, e_id) VALUES(%s, %s);", (ao_id, e_id))
        db.commit()

    def commit(self):
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("INSERT INTO option_to_event " \
                       "(ao_id, e_id) " \
                       "VALUES(%s, %s)", (
                        self.ao_id,
                        self.e_id))
        db.commit()
        self.a_id = db.get_last_id(cursor, 'booking_event')

    @staticmethod
    def delete(env, ao_id, e_id):
        db = env.get_db_cnx()
        cursor = db.cursor()
        try:
            cursor.execute("DELETE FROM option_to_event WHERE ao_id=%s AND e_id=%s;", (ao_id, e_id,))
            db.commit()
        except Exception:
            pass


class BookingModelsupplier(Component):
    implements(IEnvironmentSetupParticipant)
    SCHEMA = [

    Table('booking_event', key='e_id')[
        Column('e_id', auto_increment=True),
        Column('name'),
        Column('description'),
        Column('time_begin', type='int'),
        Column('time_end', type='int'),
        Column('register_deadline', type='int'),
        Column('edit_deadline', type='int'),
        Column('payment_deadline', type='int'),
        Index(['name',])],

    Table('event_account', key='ea_id')[
        Column('ea_id', auto_increment=True),
        Column('e_id', type='int'),
        Column('account_owner'),
        Column('account_no', type='int'),
        Column('bank_name'),
        Column('bank_no', type='int'),
        Column('first_reason'),
        Column('second_reason')],

    Table('attendee', key='a_id')[
        Column('a_id', auto_increment=True),
        Column('e_id', type='int'),
        Column('ext_id'),
        Column('nick'),
        Column('email'),
        Column('finished', type='int'),
        Column('has_paid', type='int'),
        Column('time', type='int'),
        Column('actual_amount', type='float'),
        Index(['nick',]),
        Index(['e_id',]),
        Index(['ext_id',])],

    # custom relation specification for event specific attendee attributes
    Table('attendee_attributes', key='am_id')[
        Column('am_id', auto_increment=True),
        Column('e_id'),
        Column('name'),
        Column('type')],

    # the actual values of attributes for event 'e_id' and attendee 'a_id'
    Table('attendee_attribute_values', key='aam_id')[
        Column('aam_id', auto_increment=True),
        Column('eam_id', type='int'),
        Column('a_id', type='int'),
        Column('value')],

    Table('supplier', key='supplier_id')[
        Column('supplier_id', auto_increment=True),
        Column('name'),
        Column('address'),
        Column('phone'),
        Column('email'),
        Column('fax'),
        Index(['name',])],

    Table('booking_available_option', key='ao_id')[
        Column('ao_id', auto_increment=True),
        Column('name'),
        Column('description'),
        Column('price', type='real'),
        Column('active', type='int'),
        Column('min_count', type='int'),
        Column('max_count', type='int'),
        Column('supplier_id', type='int'),
        Column('ext_id', type='int'),
        Column('stock_count', type='int')],

    Table('booking_available_option_variations', key='variation_id')[
        Column('variation_id', auto_increment=True),
        Column('option_id'),
        Column('name')],

    Table('booking_available_option_variation_items', key='ovi_id')[
        Column('ovi_id', auto_increment=True),
        Column('variation_id'),
        Column('name'),
        Column('value'),
        Column('description')],

    Table('option_to_event', key=['ao_id', 'e_id'])[
        Column('ao_id', type='int'),
        Column('e_id', type='int')],

    Table('booking_reminder', key='reminder_id')[
        Column('reminder_id', type='int'),
        Column('e_id', type='int'),
        Column('text'),
        Column('notify_on', type='int'),
        Column('was_send_on', type='int')],

    Table('booking_option', key=['a_id', 'ao_id'])[
        Column('bo_id', auto_increment=True),
        Column('a_id', type='int'),
        Column('ao_id', type='int'),
        Column('count', type='int')],

    Table('booking_option_variations')[
        Column('attendee_id', type='int'),
        Column('variation_id', type='int'),
        Column('ovi_id', type='int')]]

    OptionVariationTrigger = "CREATE TRIGGER attendee_variation_trigger " \
                        "BEFORE DELETE ON attendee " \
                        "FOR EACH ROW BEGIN " \
                        "DELETE from booking_option_variations WHERE attendee_id = OLD.a_id; " \
                        "END;"

    EventAttendeeTrigger = "CREATE TRIGGER event_attendee_trigger " \
                        "BEFORE DELETE ON booking_event " \
                        "FOR EACH ROW BEGIN " \
                        "DELETE from attendee WHERE e_id = OLD.e_id; " \
                        "END;"

    EventAccountTrigger = "CREATE TRIGGER event_account_trigger " \
                        "BEFORE DELETE ON booking_event " \
                        "FOR EACH ROW BEGIN " \
                        "DELETE from event_account WHERE e_id = OLD.e_id; " \
                        "END;"

    EventOption2EventTrigger = "CREATE TRIGGER event_option_to_event_trigger " \
                        "BEFORE DELETE ON booking_event " \
                        "FOR EACH ROW BEGIN " \
                        "DELETE from option_to_event WHERE e_id = OLD.e_id; " \
                        "END;"

    EventBookingReminderTrigger = "CREATE TRIGGER event_booking_reminder_trigger " \
                        "BEFORE DELETE ON booking_event " \
                        "FOR EACH ROW BEGIN " \
                        "DELETE from booking_reminder WHERE e_id = OLD.e_id; " \
                        "END;"

    AttendeeBookingOptionTrigger = "CREATE TRIGGER attendee_booking_option_trigger " \
                        "BEFORE DELETE ON attendee " \
                        "FOR EACH ROW BEGIN " \
                        "DELETE from booking_option WHERE a_id = OLD.a_id; " \
                        "END;"
    AOptionOption2EventTrigger = "CREATE TRIGGER booking_available_option_option_to_event_trigger " \
                        "BEFORE DELETE ON booking_available_option " \
                        "FOR EACH ROW BEGIN " \
                        "DELETE from option_to_event WHERE ao_id = OLD.ao_id; " \
                        "END;"

    AOptionBookingTrigger = "CREATE TRIGGER booking_available_option_booking_option_trigger " \
                        "BEFORE DELETE ON booking_available_option " \
                        "FOR EACH ROW BEGIN " \
                        "DELETE from booking_option WHERE ao_id = OLD.ao_id; " \
                        "END;"

    def environment_created(self):

        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 attendee")
            cursor.fetchone()
            cursor.execute("select count(*) from event_account")
            cursor.fetchone()
            cursor.execute("select count(*) from booking_available_option")
            cursor.fetchone()
            cursor.execute("select count(*) from booking_option")
            cursor.fetchone()
            cursor.execute("select count(*) from booking_event")
            cursor.fetchone()
            cursor.execute("select count(*) from supplier")
            cursor.fetchone()
            cursor.execute("select count(*) from option_to_event")
            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."""

        EVENT_DATA = (
            (u'Matebestellung 2010-001',
            u'',
            to_timestamp(datetime(2010, 4, 24, 18, tzinfo=utc)),
            to_timestamp(datetime(2010, 4, 30, 16, tzinfo=utc)),
            to_timestamp(datetime(2010, 4, 29, 16, tzinfo=utc)),
            to_timestamp(datetime(2010, 4, 30, 16, tzinfo=utc)),
            to_timestamp(datetime(2010, 4, 30, 16, tzinfo=utc))),)

        supplier_DATA = (
            ('Getränke Rabe', "Hamm", "", "", ""))

        OPTION_DATA = (
            (u'Club Mate - 20 x 0.5L', u"""10 Liter frische leckere Club-Mate

 13.5 € Netto preis zzgl. 4.5 € Pfand

 Falls Du Kisten zurückgeben willst, einfach die Anzahl der Rückgabekisten angeben""", 18.0, 1, 0, 0, 1, 0, 50),
            (u'Matekiste Rückgabe', u'Nur komplette/vollständige Matekisten angeben', -4.5, 1, 0, 0, 1, 0, 1000),
        )

        AO_DATA = (
            (1, 1),
            (2, 1),
        )


        VARIATION_DATA = ()

        ACCOUNT_DATA = (
            (1, u'Chaostreff Dortmund', 4009368600, u'GLS-Bank', 43060967, u'Mate 2010/1', ''),
        )

        VARIATION_ITEM_DATA = ()

        try:
            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)
                    cursor.execute(stmt)
            db.commit()

            cursor.executemany("""INSERT INTO 'booking_event'
                            (name, description, time_begin, time_end, register_deadline, edit_deadline, payment_deadline)
                VALUES(%s, %s, %s, %s, %s, %s, %s)""", EVENT_DATA)

            cursor.executemany("""INSERT INTO 'option_to_event'
                            (ao_id, e_id)
                            VALUES(%s, %s)""", AO_DATA)

            cursor.executemany("""INSERT INTO 'event_account'
                            (e_id, account_owner, account_no, bank_name, bank_no, first_reason, second_reason)
                            VALUES(%s, %s, %s, %s, %s, %s, %s)""", ACCOUNT_DATA)

            #cursor.executemany("""INSERT INTO 'booking_available_option_variations'
                            #(variation_id, option_id, name)
                            #VALUES(%s, %s, %s)""", VARIATION_DATA)

            #cursor.executemany("""INSERT INTO 'booking_available_option_variation_items'
                            #(ovi_id, variation_id, name, value, description)
                            #VALUES(%s, %s, %s, %s, %s)""", VARIATION_ITEM_DATA)

            print OPTION_DATA
            cursor.executemany("""INSERT INTO 'booking_available_option'
                            (name, description, price, active, min_count, max_count, supplier_id, ext_id, stock_count)
                            VALUES(%s, %s, %s, %s, %s, %s, %s, %s, %s)""", OPTION_DATA)
            cursor.execute(self.EventAttendeeTrigger)
            cursor.execute(self.EventOption2EventTrigger)
            cursor.execute(self.EventBookingReminderTrigger)
            cursor.execute(self.AttendeeBookingOptionTrigger)
            cursor.execute(self.AOptionBookingTrigger)
            cursor.execute(self.AOptionOption2EventTrigger)
            cursor.execute(self.OptionVariationTrigger)
            db.commit()
        except:
            db.rollback()
            raise