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

# Copyright 2012-2016 Mir Calculate. http://www.calculate-linux.org
#
#  Licensed under the Apache License, Version 2.0 (the "License");
#  you may not use this file except in compliance with the License.
#  You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the License is distributed on an "AS IS" BASIS,
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#  See the License for the specific language governing permissions and
#  limitations under the License.

import os
import sys
import time
from calculate.lib.utils.files import getModeFile
from calculate.lib.cl_ldap import ldapUser

from calculate.lib.cl_lang import setLocalTranslate

_ = lambda x: x
setLocalTranslate('cl_client3', sys.modules[__name__])


class Printable(object):
    def __init__(self, parent):
        if isinstance(parent, Printable):
            self.parent = parent.parent
        self.parent = parent

    def printERROR(self, s):
        self.parent.printERROR(s)


class _shareData(Printable):
    """Share class"""
    fileName = ""
    template = ""
    lenData = 0
    data = []

    def getDataInFile(self, fileName='', lenData=0):
        """Get data list from file"""
        return filter(lambda x: len(x) == lenData,
                      map(lambda x: x.rstrip().split(":"), open(fileName)))

    def getFileAccess(self, perm="READ"):
        if perm == "READ":
            if os.access(self.fileName, os.R_OK):
                return True
            else:
                self.printERROR(_("Failed to read the file") + _(": ") +
                                self.fileName)
            return False
        elif perm == "WRITE":
            if os.access(self.fileName, os.W_OK):
                return True
            else:
                self.printERROR(_("Failed to write to file") + _(": ") +
                                self.fileName)
                return False

    def getData(self):
        if id(_shareData.data) == id(self.data):
            self.data = self.data[:]
        if self.data:
            return self.data
        elif self.getFileAccess(perm="READ"):
            self.data = self.getDataInFile(fileName=self.fileName,
                                           lenData=self.lenData)
            return self.data
        else:
            return False

    def save(self):
        if self.getFileAccess(perm="WRITE"):
            buff = "\n".join(map(lambda x: ":".join(x), self.data)) + "\n"
            FD = open(self.fileName, "w+")
            FD.write(buff)
            FD.close()
            return True
        else:
            return False

    def delete(self, name):
        if self.getData() is False:
            return False
        else:
            self.data = filter(lambda x: x[0] != name, self.data)
            return True

    def replace(self, name, listData):
        if self.getData() is False:
            return False
        else:
            flagFound = False
            for index, listDataOld in enumerate(self.data):
                if name == listDataOld[0]:
                    flagFound = True
                    if not self.equally(listData, self.data[index]):
                        self.data[index] = listData
            if flagFound:
                return True
            else:
                return None

    def equally(self, listDataA, listDataB):
        if set(listDataA) == set(listDataB):
            return True
        else:
            return False

    def get(self, name):
        if self.getData() is False:
            return False
        else:
            listData = filter(lambda x: x[0] == name, self.data)
            if listData:
                return listData[0]
            else:
                return []


class passwd(_shareData):
    '''Class for working with the file /etc/passwd'''
    fileName = "/etc/passwd"
    template = "%(login)s:x:%(uid)s:%(gid)s:%(gecos)s:%(directory)s:%(shell)s"
    lenData = 7

    def add(self, name, uid, gid, gecos="", directory="", shell="/bin/bash"):
        if not directory:
            directory = "/home/%s" % name
        userData = self.template % {'login': name, 'uid': uid, 'gid': gid,
                                    'gecos': gecos, 'directory': directory,
                                    'shell': shell}
        userList = userData.split(":")
        if self.getData() is False:
            return False
        else:
            ret = self.replace(name, userList)
            if ret is False:
                return False
            elif ret is None:
                self.data.append(userList)
            return True


class group(_shareData):
    '''Class for working with the file /etc/group'''
    fileName = "/etc/group"
    template = "%(group_name)s:x:%(gid)s:%(user_list)s"
    lenData = 4

    def add(self, name, gid, userList=()):
        groupData = self.template % {'group_name': name, 'gid': gid,
                                     'user_list': ','.join(userList)}
        groupList = groupData.split(":")
        if self.getData() is False:
            return False
        else:
            ret = self.replace(name, groupList)
            if ret is False:
                return False
            elif ret is None:
                self.data.append(groupList)
            return True

    def replace(self, name, listData):
        if self.getData() is False:
            return False
        else:
            delEmpty = lambda y: filter(lambda x: x.strip(), y)
            flagFound = False
            for index, listDataOld in enumerate(self.data):
                if name == listDataOld[0]:
                    flagFound = True
                    if not self.equally(listData, self.data[index]):
                        listDataWork = listData[:]
                        listDataWork[1] = self.data[index][1]
                        # Constant gid
                        listDataWork[2] = self.data[index][2]
                        # Join user list
                        userList = delEmpty(self.data[index][3].split(',') +
                                            listDataWork[3].split(','))
                        # unique list
                        userList = reduce(lambda x, y: \
                                              (y in x and x) or x + [y],
                                          userList, [])
                        listDataWork[3] = ','.join(userList)
                        self.data[index] = listDataWork
            if flagFound:
                return True
            else:
                return None

    def equally(self, listDataA, listDataB):
        getData = lambda x: x[:1] + x[3:]
        return _shareData.equally(self, getData(listDataA),
                                  getData(listDataB))

    def getSecondUserGroups(self, userName):
        """get all second user groups"""
        if self.getData() is False:
            return False
        else:
            userGroups = []
            for group, x, gid, userList in self.data:
                usersInGroup = userList.split(",")
                if userName in usersInGroup:
                    userGroups.append(group)
            return userGroups

    def getUsersInGroup(self, name):
        if self.getData() is False:
            return False
        else:
            dataGroup = map(lambda x: x[3].split(","),
                            filter(lambda x: x[0] == name, self.data))
            if dataGroup:
                return dataGroup[0]
            else:
                return []

    def deleteUserInGroups(self, userName, groups):
        if self.getData() is False:
            return False
        else:
            data = []
            for dataList in self.data:
                groupName, x, gid, userList = dataList
                if groupName in groups:
                    usersList = ",".join(filter(lambda x: x != userName,
                                                userList.split(",")))
                    dataList[3] = usersList
                data.append(dataList)
            self.data = data
            return self.data


class shadow(_shareData):
    '''Class for working with the file /etc/shadow'''
    fileName = "/etc/shadow"
    template = ("%(login)s:%(hash)s:%(shadowLastChange)s:"
                "%(shadowMin)s:%(shadowMax)s:%(shadowWarning)s:::")
    lenData = 9

    def add(self, name, pwdHash,
            shadowLastChange=str(int(time.time() / 86400)), shadowMin="0",
            shadowMax="99999", shadowWarning="7"):
        shadowData = self.template % {'login': name, 'hash': pwdHash,
                                      'shadowLastChange': shadowLastChange,
                                      'shadowMin': shadowMin,
                                      'shadowMax': shadowMax,
                                      'shadowWarning': shadowWarning}
        shadowList = shadowData.split(":")
        if self.getData() is False:
            return False
        else:
            ret = self.replace(name, shadowList)
            if ret is False:
                return False
            elif ret is None:
                self.data.append(shadowList)
            return True

    def equally(self, listDataA, listDataB):
        getData = lambda x: x[:1] + x[2:]
        return _shareData.equally(self, getData(listDataA),
                                  getData(listDataB))


class _shareCache(_shareData):
    def save(self):
        path = os.path.dirname(self.fileName)
        if not os.path.exists(path):
            try:
                os.makedirs(path)
            except OSError:
                self.printERROR(_("Failed to create directory %s") % path)
                return False
        if not os.path.exists(self.fileName):
            try:
                open(self.fileName, "w").close()
            except IOError:
                self.printERROR(_("Failed to create file %s") % self.fileName)
                return False
        if self.getFileAccess(perm="WRITE"):
            modeFile = 0600
            if getModeFile(self.fileName, mode="mode") != modeFile:
                os.chmod(self.fileName, modeFile)
            buff = "\n".join(map(lambda x: ":".join(x), self.data)) + "\n"
            FD = open(self.fileName, "w+")
            FD.write(buff)
            FD.close()
            return True
        else:
            return False

    def getData(self):
        if id(_shareData.data) == id(self.data):
            self.data = self.data[:]
        if self.data:
            return self.data
        elif not os.path.exists(self.fileName):
            return self.data
        elif self.getFileAccess(perm="READ"):
            self.data = self.getDataInFile(fileName=self.fileName,
                                           lenData=self.lenData)
            return self.data
        else:
            return False


class cachePasswd(_shareCache, passwd):
    fileName = "/var/lib/calculate/calculate-client/cache/passwd"


class cacheGroup(_shareCache, group):
    fileName = "/var/lib/calculate/calculate-client/cache/group"

    def replace(self, name, listData):
        return _shareData.replace(self, name, listData)

    def equally(self, listDataA, listDataB):
        return _shareData.equally(self, listDataA, listDataB)


class cacheShadow(_shareCache, shadow):
    fileName = "/var/lib/calculate/calculate-client/cache/shadow"


class cacheCreateGroup(cacheGroup):
    fileName = "/var/lib/calculate/calculate-client/cache/create_group"


class cacheCreatePasswd(cachePasswd):
    fileName = "/var/lib/calculate/calculate-client/cache/create_passwd"


class userCache(Printable):
    ldapObj = ldapUser()

    def addUserToCache(self, userName, pwdHash):
        '''Add LDAP user to cache'''
        ldapData = self.ldapObj.getUserLdapInfo(userName, shadowAttr=True)
        if not ldapData:
            self.printERROR(_("User %s not found in LDAP") % userName)
            return False
        groupName = ldapData['group']
        # Add user
        cachePasswdObj = cachePasswd(self)
        if not cachePasswdObj.add(userName, ldapData['uid'], ldapData['gid'],
                                  gecos=ldapData['fullName'],
                                  directory=ldapData['home'],
                                  shell=ldapData['loginShell']):
            return False
        if not cachePasswdObj.save():
            return False
        cacheGroupObj = cacheGroup(self)
        # Add primary group
        if not cacheGroupObj.add(groupName, ldapData['gid']):
            return False
        # Add second groups
        secondGroupsData = ldapData['groups']
        cacheSecondUserGroups = cacheGroupObj.getSecondUserGroups(userName)
        deleteSecondGroups = cacheSecondUserGroups
        if secondGroupsData:
            allUsersSecondGroups = []
            for groupName, gid in secondGroupsData:
                usersInGroup = cacheGroupObj.getUsersInGroup(groupName)
                if usersInGroup is False:
                    return False
                if not userName in usersInGroup:
                    usersInGroup.append(userName)
                if not cacheGroupObj.add(groupName, gid, usersInGroup):
                    return False
                allUsersSecondGroups.append(groupName)
            deleteSecondGroups = list(set(cacheSecondUserGroups) - \
                                      set(allUsersSecondGroups))
        if not cacheGroupObj.deleteUserInGroups(userName, deleteSecondGroups):
            return False
        if not cacheGroupObj.save():
            return False
        # Add shadow user
        cacheShadowObj = cacheShadow(self)
        if not cacheShadowObj.add(userName, pwdHash,
                                  shadowLastChange=ldapData['shadowLastChange'],
                                  shadowMin=ldapData['shadowMin'],
                                  shadowMax=ldapData['shadowMax'],
                                  shadowWarning=ldapData['shadowWarning']):
            return False
        if not cacheShadowObj.save():
            return False
        return True

    def delUserFromCacheCreate(self, userName):
        '''Delete LDAP user from createCache'''
        cacheCreatePasswdObj = cacheCreatePasswd(self)
        cacheUserData = cacheCreatePasswdObj.get(userName)
        if cacheUserData is False:
            return False
        if not cacheUserData:
            return True
        gid = cacheUserData[3]
        cacheCreateGroupObj = cacheCreateGroup(self)
        cacheSecondGroups = cacheCreateGroupObj.getSecondUserGroups(userName)
        if cacheSecondGroups is False:
            return False
        # delete user in second groups
        if not cacheCreateGroupObj.deleteUserInGroups(userName,
                                                      cacheSecondGroups):
            return False
        # delete user
        if not cacheCreatePasswdObj.delete(userName):
            return False
        if not cacheCreatePasswdObj.save():
            return False
        # delete groups
        usersGids = map(lambda x: x[3], cacheCreatePasswdObj.data)
        deleteGroups = map(lambda x: x[0],
                           filter(lambda x: not x[2] in usersGids and not x[3],
                                  cacheCreateGroupObj.data))
        for delGroupName in deleteGroups:
            if not cacheCreateGroupObj.delete(delGroupName):
                return False
        if not cacheCreateGroupObj.save():
            return False
        return True

    def delUserFromCache(self, userName):
        '''Delete LDAP user from cache'''
        cachePasswdObj = cachePasswd(self)
        cacheUserData = cachePasswdObj.get(userName)
        if cacheUserData is False:
            return False
        if not cacheUserData:
            return True
        gid = cacheUserData[3]
        cacheGroupObj = cacheGroup(self)
        cacheSecondGroups = cacheGroupObj.getSecondUserGroups(userName)
        if cacheSecondGroups is False:
            return False
        # delete user in second groups
        if not cacheGroupObj.deleteUserInGroups(userName, cacheSecondGroups):
            return False
        # delete user
        if not cachePasswdObj.delete(userName):
            return False
        if not cachePasswdObj.save():
            return False
        # delete groups
        usersGids = map(lambda x: x[3], cachePasswdObj.data)
        deleteGroups = map(lambda x: x[0],
                           filter(lambda x: not x[2] in usersGids and not x[3],
                                  cacheGroupObj.data))
        for delGroupName in deleteGroups:
            if not cacheGroupObj.delete(delGroupName):
                return False
        if not cacheGroupObj.save():
            return False
        # delete shadow user
        cacheShadowObj = cacheShadow(self)
        if not cacheShadowObj.delete(userName):
            return False
        if not cacheShadowObj.save():
            return False
        return True

    def delUserFromSystem(self, userName):
        '''Delete LDAP user from system files ( passwd, group, shadow )'''
        cacheCreatePasswdObj = cacheCreatePasswd(self)
        cacheCreatePasswdData = cacheCreatePasswdObj.get(userName)
        if cacheCreatePasswdData is False:
            return False
        if not cacheCreatePasswdData:
            return True
        passwdObj = passwd(self)
        userData = passwdObj.get(userName)
        if userData is False:
            return False
        # delete user
        if not userData:
            return True
        if not passwdObj.delete(userName):
            return False
        if not passwdObj.save():
            return False
        # delete user group
        groupObj = group(self)
        listGroupData = groupObj.getData()
        if listGroupData is False:
            return False
        cacheCreateGroupObj = cacheCreateGroup(self)
        secondUsersGroups = groupObj.getSecondUserGroups(userName)
        usersGids = map(lambda x: x[3], passwdObj.data)
        listGroupDataWork = []
        for index, groupData in enumerate(listGroupData):
            groupName, x, gid, listUsers = groupData
            listUsers = filter(lambda x: x.strip(), listUsers.split(','))
            listUsers = ",".join(filter(lambda x: x != userName, listUsers))
            cacheCreateGroupData = cacheCreateGroupObj.get(groupName)
            if cacheCreateGroupData is False:
                return False
            if groupName in cacheCreateGroupData:
                if not gid in usersGids and not listUsers:
                    continue
            listGroupDataWork.append([groupName, x, gid, listUsers])
        groupObj.data = listGroupDataWork
        if not groupObj.save():
            return False
        # delete user shadow
        shadowObj = shadow(self)
        shadowData = shadowObj.get(userName)
        if shadowData is False:
            return False
        if not shadowData:
            return True
        if not shadowObj.delete(userName):
            return False
        if not shadowObj.save():
            return False
        if not self.delUserFromCacheCreate(userName):
            return False
        return True

    def isConnectToLdap(self):
        connectData = self.ldapObj.getBindConnectData()
        if not connectData:
            return {}
        bindDn, bindPw, host = connectData
        usersDN = self.ldapObj.getUsersDN()
        groupsDNs = self.ldapObj.getGroupsDN()
        # Соединяемся с LDAP
        if not self.ldapObj.ldapConnect(bindDn, bindPw, host):
            return False
        return True

    def deleteCacheUsersFromSystem(self):
        '''Delete cache users from system'''
        cacheCreatePasswdObj = cacheCreatePasswd(self)
        cacheCreateListPasswdData = cacheCreatePasswdObj.getData()
        if cacheCreateListPasswdData is False:
            return False
        delUsersPasswd = map(lambda x: x[0], cacheCreateListPasswdData)
        for delUser in delUsersPasswd:
            if not self.delUserFromSystem(delUser):
                return False
        return True

    def getLoginDomainUsers(self):
        '''Get all domain login users'''
        cacheCreatePasswdObj = cacheCreatePasswd(self)
        cacheListCreatePasswdData = cacheCreatePasswdObj.getData()
        if cacheListCreatePasswdData is False:
            return False
        return cacheListCreatePasswdData

    def addCacheUsersFromSystem(self):
        '''Add cache users from system'''
        cachePasswdObj = cachePasswd(self)
        cacheListPasswdData = cachePasswdObj.getData()
        if not isinstance(cacheListPasswdData, (list, tuple)):
            return False
        # Add cache passwd users to system
        passwdObj = passwd(self)
        cacheCreatePasswdObj = cacheCreatePasswd(self)
        cacheListCreatePasswdData = cacheCreatePasswdObj.getData()
        if cacheListCreatePasswdData is False:
            return False
        # remove deleted users
        cacheUsers = map(lambda x: x[0], cacheListPasswdData)
        createUsers = map(lambda x: x[0], cacheListCreatePasswdData)
        deletedUsers = list(set(createUsers) - set(cacheUsers))
        for delUser in deletedUsers:
            if not self.delUserFromSystem(delUser):
                return False
            if not self.delUserFromCache(delUser):
                return False
        addUsers = []
        addUsersGid = []
        notAddUsers = []
        for cachePasswdData in cacheListPasswdData:
            userName, x, uid, gid, gecos, directory, shell = cachePasswdData
            retPasswd = passwdObj.get(userName)
            if retPasswd is False:
                return False
            if not retPasswd:
                if not cacheCreatePasswdObj.add(userName, uid, gid,
                                                gecos=gecos,
                                                directory=directory,
                                                shell=shell):
                    return False
            retCacheCreate = cacheCreatePasswdObj.get(userName)
            if retCacheCreate is False:
                return False
            if retCacheCreate:
                if not passwdObj.add(userName, uid, gid,
                                     gecos=gecos,
                                     directory=directory,
                                     shell=shell):
                    return False
                addUsers.append(userName)
                addUsersGid.append(gid)
            else:
                notAddUsers.append(userName)
        if passwdObj.data:
            if not passwdObj.save():
                return False
            if not cacheCreatePasswdObj.save():
                return False
        cacheShadowObj = cacheShadow(self)
        cacheListShadowData = cacheShadowObj.getData()
        if not isinstance(cacheListShadowData, (list, tuple)):
            return False
        # Add cache shadow users to system
        shadowObj = shadow(self)
        for cacheShadowData in cacheListShadowData:
            userName, pwdHash, shadowLastChange, shadowMin, shadowMax, \
            shadowWarning, x, x, x = cacheShadowData
            if userName in addUsers:
                if not shadowObj.add(userName, pwdHash,
                                     shadowLastChange=shadowLastChange,
                                     shadowMin=shadowMin,
                                     shadowMax=shadowMax,
                                     shadowWarning=shadowWarning):
                    return False
        if shadowObj.data:
            if not shadowObj.save():
                return False
        cacheGroupObj = cacheGroup(self)
        cacheListGroupData = cacheGroupObj.getData()
        if not isinstance(cacheListGroupData, (list, tuple)):
            return False
        cacheCreateGroupObj = cacheCreateGroup(self)
        # Add cache group users to system
        groupObj = group(self)
        setAddUsers = set(addUsers)
        for cacheGroupData in cacheListGroupData:
            groupName, x, gid, listUsers = cacheGroupData
            retGroup = groupObj.get(groupName)
            if retGroup is False:
                return False
            listUsers = filter(lambda x: x.strip(), listUsers.split(','))
            if setAddUsers & set(listUsers) or gid in addUsersGid:
                listUsers = filter(lambda x: not x in notAddUsers, listUsers)
                if not retGroup:
                    if not cacheCreateGroupObj.add(groupName, gid, listUsers):
                        return False
                if not groupObj.add(groupName, gid, listUsers):
                    return False
        if groupObj.data:
            if not groupObj.save():
                return False
            if cacheCreateGroupObj.data:
                if not cacheCreateGroupObj.save():
                    return False
        return True

    def syncCacheToLdap(self):
        '''Compare cache users to LDAP users.

        Deleting a user from the cache when the differences'''
        if not self.isConnectToLdap():
            self.printERROR(_("Failed to connect to the LDAP server"))
            return False
        cachePasswdObj = cachePasswd(self)
        cacheListPasswdData = cachePasswdObj.getData()
        if cacheListPasswdData is False:
            return False
        if (not isinstance(cacheListPasswdData, (tuple, list)) or
                not cacheListPasswdData):
            return True
        cacheGroupObj = cacheGroup(self)
        cacheListGroupData = cacheGroupObj.getData()
        if cacheListGroupData is False:
            return False
        cacheShadowObj = cacheShadow(self)
        deletedCacheUsers = []
        for cachePasswdData in cacheListPasswdData:
            userName, x, uid, gid, gecos, directory, shell = cachePasswdData
            ldapData = self.ldapObj.getUserLdapInfo(userName, shadowAttr=True)
            if not ldapData:
                deletedCacheUsers.append(userName)
                continue
            cacheGroupData = map(lambda x: x[0], filter(lambda x: x[2] == gid,
                                                        cacheListGroupData))
            if not cacheGroupData:
                deletedCacheUsers.append(userName)
                continue
            groupName = cacheGroupData[0]
            cacheShadowData = cacheShadowObj.get(userName)
            if cacheShadowData is False:
                return False
            if not cacheShadowData:
                deletedCacheUsers.append(userName)
                continue
            x, x, shadowLastChange, shadowMin, shadowMax, shadowWarning, \
            x, x, x = cacheShadowData
            groups = cacheGroupObj.getSecondUserGroups(userName)
            gidsGroups = map(lambda x: x[2],
                             filter(lambda x: x[0] in groups,
                                    cacheGroupObj.data))
            userShadowDict = {'uid': uid,
                              'gid': gid,
                              'fullName': gecos,
                              'home': directory,
                              'group': groupName,
                              'groups': (groups, gidsGroups),
                              'loginShell': shell,
                              'shadowLastChange': shadowLastChange,
                              'shadowMin': shadowMin,
                              'shadowMax': shadowMax,
                              'shadowWarning': shadowWarning}
            flagDeleteUser = False
            for attr, value in userShadowDict.items():
                if attr == "groups":
                    for index, val in enumerate(value):
                        if set(map(lambda x: x[index],
                                   ldapData[attr])) != set(val):
                            flagDeleteUser = True
                            break
                else:
                    if ldapData[attr] != value:
                        flagDeleteUser = True
                        break
            if flagDeleteUser:
                deletedCacheUsers.append(userName)
                continue
        # Deleted cache users
        for delUserName in deletedCacheUsers:
            if not self.delUserFromCache(delUserName):
                return False
        return True

    def clearCache(self):
        '''Clear cache files'''
        cacheObjs = (cachePasswd(self), cacheShadow(self), cacheGroup(self),
                     cacheCreateGroup(self), cacheCreatePasswd(self))
        for cacheObj in cacheObjs:
            if not cacheObj.save():
                return False
        return True