from typing import Dict, Optional

from ...controller import Controller
from ...register import register
from ...context import Context
from ...utils import _
from ...config import get_config


class Risotto(Controller):
    async def on_join(self,
                      risotto_context: Context) -> None:
        """ pre-load servermodel and server
        """
        user_login = get_config()['global']['admin_user']
        sql = '''
        SELECT UserId
        FROM RisottoUser
        WHERE UserLogin = $1
        '''
        if await risotto_context.connection.fetchval(sql,
                                                     user_login) is None:
            await self._user_create(risotto_context,
                                    user_login,
                                    user_login,
                                    user_login)
            await self._user_role_create(risotto_context,
                                         user_login,
                                         'administrator',
                                         None,
                                         None)

    async def _user_create(self,
                           risotto_context: Context,
                           user_login: str,
                           user_name: str,
                           user_surname: str) -> Dict:
        user_insert = """INSERT INTO RisottoUser(UserLogin, UserName, UserSurname)
        VALUES ($1,$2,$3)
        RETURNING UserId
        """
        user_id = await risotto_context.connection.fetchval(user_insert,
                                                            user_login,
                                                            user_name,
                                                            user_surname)
        await self.call('v1.user.role.create',
                        risotto_context,
                        user_login=user_login,
                        role_name='all')
        return {'user_id': user_id,
                'user_login': user_login,
                'user_name': user_name,
                'user_surname': user_surname}

    @register('v1.user.create')
    async def user_create(self,
                          risotto_context: Context,
                          user_login: str,
                          user_name: str,
                          user_surname: str) -> Dict:
        return await self._user_create(risotto_context,
                                       user_login,
                                       user_name,
                                       user_surname)

    @register('v1.user.list')
    async def user_list(self,
                        risotto_context: Context) -> Dict:
        sql = '''
        SELECT UserId as user_id, UserLogin as user_login, UserName as user_name, UserSurname as user_surname
        FROM RisottoUser
        '''
        users = await risotto_context.connection.fetch(sql)
        return [dict(r) for r in users]

    @register('v1.user.delete')
    async def user_delete(self,
                          risotto_context: Context,
                          user_login: str) -> Dict:
        sql = '''
        DELETE FROM RisottoUser
        WHERE UserLogin = $1
        RETURNING UserId as user_id, UserLogin as user_login, UserName as user_name, UserSurname as user_surname
        '''
        user = await risotto_context.connection.fetchrow(sql,
                                                         user_login)
        if user is None:
            raise Exception(_(f'unable to find user {user_login}'))
        return dict(user)

    async def _user_role_create(self,
                               risotto_context: Context,
                               user_login: str,
                               role_name: str,
                               role_attribute: str,
                               role_attribute_value: str) -> Dict:
        # Verify if user exists and get ID
        sql = '''
        SELECT UserId
        FROM RisottoUser
        WHERE UserLogin = $1
        '''
        user_id = await risotto_context.connection.fetchval(sql,
                                                            user_login)
        if user_id is None:
            raise Exception(_(f'unable to find user {user_login}'))
        if role_attribute == role_attribute_value == None:
            sql = '''SELECT RoleId
            FROM UserRole
            WHERE RoleUserId = $1 AND RoleName = $2
            '''
            role_id = await risotto_context.connection.fetchval(sql,
                                                                user_id,
                                                                role_name)
        else:
            sql = '''SELECT RoleId
            FROM UserRole
            WHERE RoleUserId = $1 AND RoleName = $2 AND RoleAttribute = $3 AND RoleAttributeValue = $4
            '''
            role_id = await risotto_context.connection.fetchval(sql,
                                                                user_id,
                                                                role_name,
                                                                role_attribute,
                                                                role_attribute_value)
        if role_id is None:
            sql = '''INSERT INTO UserRole(RoleUserId, RoleName, RoleAttribute, RoleAttributeValue)
            VALUES($1,$2,$3,$4)
            RETURNING RoleId
            '''
            role_id = await risotto_context.connection.fetchval(sql,
                                                                user_id,
                                                                role_name,
                                                                role_attribute,
                                                                role_attribute_value)
        return {'role_id': role_id,
                'user_login': user_login,
                'role_name': role_name,
                'role_attribute': role_attribute,
                'role_attribute_value': role_attribute_value}

    @register('v1.user.role.create')
    async def user_role_create(self,
                               risotto_context: Context,
                               user_login: str,
                               role_name: str,
                               role_attribute: str,
                               role_attribute_value: str) -> Dict:
        return await self._user_role_create(risotto_context,
                                            user_login,
                                            role_name,
                                            role_attribute,
                                            role_attribute_value)

    @register('v1.user.role.list')
    async def user_role_list(self,
                             risotto_context: Context,
                             user_login: Optional[str]) -> Dict:
        if not user_login:
            sql = '''
            SELECT RoleId as role_id, RoleName as role_name, RoleAttribute as role_attribute, RoleAttributeValue as role_attribute_value, RisottoUser.UserLogin as user_login
            FROM UserRole, RisottoUser
            WHERE UserRole.RoleUserId = RisottoUser.UserId
            '''
            roles = await risotto_context.connection.fetch(sql)
        else:
            # Verify if user exists and get ID
            sql = '''
            SELECT UserId
            FROM RisottoUser
            WHERE UserLogin = $1
            '''
            user_id = await risotto_context.connection.fetchval(sql,
                                                                user_login)
            if user_id is None:
                raise Exception(_(f'unable to find user {user_login}'))
            sql = '''
            SELECT RoleId as role_id, RoleName as role_name, RoleAttribute as role_attribute, RoleAttributeValue as role_attribute_value, RisottoUser.UserLogin as user_login
            FROM UserRole, RisottoUser
            WHERE UserRole.RoleUserId = RisottoUser.UserId AND UserRole.RoleUserId = $1
            '''
            roles = await risotto_context.connection.fetch(sql,
                                                           user_id)
        return [dict(r) for r in roles]
#
# FIXME comment savoir quel role il faut supprimer ? avec attribut ou juste l'ID ?
#    @register('v1.user.role.delete')
#    async def user_role_delete(self,
#                               risotto_context: Context,
#                               user_login: str,
#                               role_name: str) -> Dict:
#        # Verify if user exists and get ID
#        sql = '''
#        SELECT UserId
#        FROM RisottoUser
#        WHERE UserLogin = $1
#        '''
#        user_id = await risotto_context.connection.fetchval(sql,
#                                                            user_login)
#        if user_id is None:
#            raise Exception(_(f'unable to find user {user_login}'))
#        sql = '''
#        DELETE FROM RisottoRole
#        WHERE RoleName = $1 AND UserId = $2
#        RETURNING RoleId as role_id, RoleName as role_name, RoleAttribute as role_attribute, RoleAttributeValue as role_attribute_value
#        '''
#        role = await risotto_context.connection.fetchrow(sql,
#                                                         role_name,
#                                                         user_id)
#        if role is None:
#            raise Exception(_(f'unable to find role {role_name}'))
#        return dict(role)