from . import LOGGER, Singleton, ldapConfig, dbConfig, mailConfig
import geruecht.controller.databaseController as dc
import geruecht.controller.ldapController as lc
import geruecht.controller.emailController as ec
import calendar
from geruecht.model.user import User
from geruecht.exceptions import PermissionDenied
from datetime import datetime, timedelta
from geruecht.exceptions import UsernameExistLDAP, UsernameExistDB, DatabaseExecption, LDAPExcetpion, DayLocked, TansactJobIsAnswerdException

db = dc.DatabaseController()
ldap = lc.LDAPController()
emailController = ec.EmailController(mailConfig['URL'], mailConfig['user'], mailConfig['passwd'], mailConfig['crypt'], mailConfig['port'], mailConfig['email'])

class UserController(metaclass=Singleton):

    def __init__(self):
        pass

    def getAllStatus(self):
        return db.getAllStatus()

    def getStatus(self, name):
        return db.getStatus(name)

    def setStatus(self, name):
        return db.setStatus(name)

    def deleteStatus(self, status):
        db.deleteStatus(status)

    def updateStatus(self, status):
        return db.updateStatus(status)

    def updateStatusOfUser(self, username, status):
        return db.updateStatusOfUser(username, status)

    def updateVotingOfUser(self, username, voting):
        return db.updateVotingOfUser(username, voting)

    def deleteDrinkType(self, type):
        db.deleteDrinkType(type)

    def updateDrinkType(self, type):
        return db.updateDrinkType(type)

    def setDrinkType(self, type):
        return db.setDrinkType(type)

    def deletDrinkPrice(self, drink):
        db.deleteDrink(drink)

    def setDrinkPrice(self, drink):
        retVal = db.setDrinkPrice(drink)
        return retVal

    def updateDrinkPrice(self, drink):
        retVal = db.updateDrinkPrice(drink)
        return retVal

    def getAllDrinkTypes(self):
        return db.getAllDrinkTypes()

    def getPricelist(self):
        list = db.getPriceList()
        return list

    def setTransactJob(self, from_user, to_user, date):
        jobtransact = db.setTransactJob(from_user, to_user, date.date())
        emailController.sendMail(jobtransact['to_user'], 'jobtransact', jobtransact)
        return jobtransact

    def getTransactJobFromUser(self, user, date):
        return db.getTransactJobFromUser(user, date.date())

    def getAllTransactJobFromUser(self, user, date):
        return db.getAllTransactJobFromUser(user, date.date())

    def getAllTransactJobToUser(self, user, date):
        return db.getAllTransactJobToUser(user, date.date())

    def getTransactJob(self, from_user, to_user, date):
        return db.getTransactJob(from_user, to_user, date.date())

    def deleteTransactJob(self, from_user, to_user, date):
        transactJob = self.getTransactJob(from_user, to_user, date)
        if transactJob['answerd']:
            raise TansactJobIsAnswerdException("TransactJob is already answerd")
        db.deleteTransactJob(from_user, to_user, date.date())

    def answerdTransactJob(self, from_user, to_user, date, answer):
        transactJob = db.updateTransactJob(from_user, to_user, date.date(), answer)
        if answer:
            self.addWorker(to_user.uid, date)
        return transactJob

    def setLockedDay(self, date, locked, hard=False):
        return db.setLockedDay(date.date(), locked, hard)

    def getLockedDay(self, date):
        now = datetime.now()
        oldMonth = False
        for i in range(1, 8):
            if datetime(now.year, now.month, i).weekday() == 2:
                if now.day < i:
                    oldMonth = True
                    break
        lockedYear = date.year
        lockedMonth = date.month if date.month < now.month else now.month - 1 if oldMonth else now.month
        daysInMonth = calendar.monthrange(lockedYear, lockedMonth)[1]
        startDay = 1
        for i in range(1, 8):
            if datetime(lockedYear, lockedMonth, i).weekday() == 2:
                startDay = i
                break
        if lockedYear <= now.year and lockedMonth <= now.month:
            for i in range(startDay, daysInMonth + 1):
                self.setLockedDay(datetime(lockedYear, lockedMonth, i), True)
            for i in range(1, 8):
                nextMonth = datetime(lockedYear, lockedMonth + 1, i)
                if nextMonth.weekday() == 2:
                    break
                self.setLockedDay(nextMonth, True)
        return db.getLockedDay(date.date())

    def getWorker(self, date, username=None):
        if (username):
            user = self.getUser(username)
            return [db.getWorker(user, date)]
        return db.getWorkers(date)

    def addWorker(self, username, date, userExc=False):
        if (userExc):
            lockedDay = self.getLockedDay(date)
            if lockedDay:
                if lockedDay['locked']:
                    raise DayLocked("Day is locked. You can't get the Job")
        user = self.getUser(username)
        if (not db.getWorker(user, date)):
            db.setWorker(user, date)
        return self.getWorker(date, username=username)

    def deleteWorker(self, username, date, userExc=False):
        user = self.getUser(username)
        if userExc:
            lockedDay = self.getLockedDay(date)
            if lockedDay:
                if lockedDay['locked']:
                    transactJobs = self.getTransactJobFromUser(user, date)
                    found = False
                    for job in transactJobs:
                        if job['accepted'] and job['answerd']:
                            found = True
                            break
                    if not found:
                        raise DayLocked("Day is locked. You can't delete the Job")
        db.deleteWorker(user, date)

    def lockUser(self, username, locked):
        user = self.getUser(username)
        user.updateData({'locked': locked})
        db.updateUser(user)
        return self.getUser(username)

    def updateConfig(self, username, data):
        user = self.getUser(username)
        user.updateData(data)
        db.updateUser(user)
        return self.getUser(username)

    def __updateDataFromLDAP(self, user):
        groups = ldap.getGroup(user.uid)
        user_data = ldap.getUserData(user.uid)
        user_data['gruppe'] = groups
        user_data['group'] = groups
        user.updateData(user_data)
        db.updateUser(user)

    def autoLock(self, user):
        if user.autoLock:
            if user.getGeruecht(year=datetime.now().year).getSchulden() <= (-1*user.limit):
                user.updateData({'locked': True})
                emailController.sendMail(user)
            else:
                user.updateData({'locked': False})
        db.updateUser(user)

    def addAmount(self, username, amount, year, month, finanzer=False):
        user = self.getUser(username)
        if not user.locked or finanzer:
            user.addAmount(amount, year=year, month=month)
            creditLists = user.updateGeruecht()
            for creditList in creditLists:
                db.updateCreditList(creditList)
        self.autoLock(user)
        return user.getGeruecht(year)

    def addCredit(self, username, credit, year, month):
        user = self.getUser(username)
        user.addCredit(credit, year=year, month=month)
        creditLists = user.updateGeruecht()
        for creditList in creditLists:
            db.updateCreditList(creditList)
        self.autoLock(user)
        return user.getGeruecht(year)

    def getAllUsersfromDB(self):
        users = db.getAllUser()
        for user in users:
            try:
                self.__updateDataFromLDAP(user)
            except:
                pass
            self.__updateGeruechte(user)
        return db.getAllUser()

    def checkBarUser(self, user):
        date = datetime.now()
        zero = date.replace(hour=0, minute=0, second=0, microsecond=0)
        end = zero + timedelta(hours=12)
        startdatetime = date.replace(hour=12, minute=0, second=0, microsecond=0)
        if date > zero and end > date:
             startdatetime = startdatetime - timedelta(days=1)
        enddatetime = startdatetime + timedelta(days=1)
        result = False
        if date >= startdatetime and date < enddatetime:
            result = db.getWorker(user, startdatetime)
        return True if result else False


    def getUser(self, username):
        user = db.getUser(username)
        groups = ldap.getGroup(username)
        user_data = ldap.getUserData(username)
        user_data['gruppe'] = groups
        user_data['group'] = groups
        if user is None:
            user = User(user_data)
            db.insertUser(user)
        else:
            user.updateData(user_data)
            db.updateUser(user)
        user = db.getUser(username)
        self.__updateGeruechte(user)
        return user

    def __updateGeruechte(self, user):
        user.getGeruecht(datetime.now().year)
        creditLists = user.updateGeruecht()
        if user.getGeruecht(datetime.now().year).getSchulden() != 0:
            for creditList in creditLists:
                db.updateCreditList(creditList)

    def sendMail(self, username):
        if type(username) == User:
            user = username
        if type(username) == str:
            user = db.getUser(username)
        return emailController.sendMail(user)

    def sendAllMail(self):
        retVal = []
        users = db.getAllUser()
        for user in users:
            retVal.append(self.sendMail(user))
        return retVal

    def modifyUser(self, user, ldap_conn, attributes):
        try:
            if 'username' in attributes:
                db.changeUsername(user, attributes['username'])
            ldap.modifyUser(user, ldap_conn, attributes)
            if 'username' in attributes:
                return self.getUser(attributes['username'])
            else:
                return self.getUser(user.uid)
        except UsernameExistLDAP as err:
            db.changeUsername(user, user.uid)
            raise Exception(err)
        except LDAPExcetpion as err:
            if 'username' in attributes:
                db.changeUsername(user, user.uid)
                raise Exception(err)
        except Exception as err:
            raise Exception(err)

    def loginUser(self, username, password):
        try:
            user = self.getUser(username)
            user.password = password
            ldap.login(username, password)
            ldap_conn = ldap.bind(user, password)
            return user, ldap_conn
        except PermissionDenied as err:
            raise err