"""
@AUTHOR: zhuo
@NAME: zhuojiaxuan
@software: PyCharm
@DATE: 2025/08/05 11:17
"""
from django.db import transaction
from django.db.models import Max
from django.views.generic.base import View

from AgentModel.models import AgentRole, AgentRoleMenu, AgentMenu, AgentUserRole
from Object.ResponseObject import ResponseObject
from Object.TokenObject import TokenObject
from Service.CommonService import CommonService
import time


class AgentRoleView(View):
    def get(self, request, *args, **kwargs):
        request.encoding = 'utf-8'
        operation = kwargs.get('operation')
        return self.validation(request.GET, request, operation)

    def post(self, request, *args, **kwargs):
        request.encoding = 'utf-8'
        operation = kwargs.get('operation')
        return self.validation(request.POST, request, operation)

    def validation(self, request_dict, request, operation):
        language = request_dict.get('language', 'en')
        response = ResponseObject(language, 'pc')

        if operation == '??':
            return response.json(0)
        else:
            tko = TokenObject(request.META.get('HTTP_AUTHORIZATION'), returntpye='pc')
            if tko.code != 0:
                return response.json(tko.code)
            response.lang = tko.lang
            userID = tko.userID

            if operation == 'getList':
                return self.getList(userID, request_dict, response)
            elif operation == 'doAdd':
                return self.doAdd(userID, request_dict, response)
            elif operation == 'doEdit':
                return self.doEdit(userID, request_dict, response)
            elif operation == 'doDelete':
                return self.doDelete(userID, request_dict, response)
            elif operation == 'getRoleDetail':
                return self.getRoleDetail(userID, request_dict, response)
            elif operation == 'setPerms':
                return self.setPerms(userID, request_dict, response)
            elif operation == 'getMenusIds':
                return self.getMenusIds(userID, request_dict, response)
            elif operation == 'getAllMenusTree':
                return self.getAllMenusTree(userID, request_dict, response)
            elif operation == 'getUserInfo':
                return self.getUserInfo(userID, request_dict, response)
            else:
                return response.json(404)

    def getList(self, userID, request_dict, response):
        """获取角色列表"""
        isSelect = request_dict.get('isSelect', None)  # 获取全部数据作为角色选项
        if isSelect:
            role_qs = AgentRole.objects.all().values('rid', 'role_name', 'description')
            return response.json(0, {'list': CommonService.qs_to_list(role_qs)})

        roleName = request_dict.get('role_name', '')
        pageNo = request_dict.get('pageNo', None)
        pageSize = request_dict.get('pageSize', None)

        if not all([pageNo, pageSize]):
            return response.json(444,  "缺少分页参数")

        page = int(pageNo)
        line = int(pageSize)

        if roleName:
            role_qs = AgentRole.objects.filter(role_name__contains=roleName)
        else:
            role_qs = AgentRole.objects.all()

        count = role_qs.count()
        role_qs = role_qs.order_by('-rid')[(page - 1) * line:page * line]

        list_data = []
        for role in role_qs:
            # 统计该角色关联的用户数和菜单数
            user_count = AgentUserRole.objects.filter(role=role).count()
            menu_count = AgentRoleMenu.objects.filter(role=role).count()

            list_data.append({
                'rid': role.rid,
                'role_name': role.role_name,
                'description': role.description,
                'data_scope': role.data_scope,
                'agent_type': role.agent_type,
                'user_count': user_count,
                'menu_count': menu_count,
                'status': 1,  # 默认启用状态
                'created_time': getattr(role, 'created_time', int(time.time())),
                'updated_time': getattr(role, 'updated_time', int(time.time()))
            })

        return response.json(0, {'list': list_data, 'total': count})

    def getRoleDetail(self, userID, request_dict, response):
        """获取角色详情"""
        rid = request_dict.get('rid', '')
        if not rid:
            return response.json(444,  "缺少角色ID")

        try:
            role = AgentRole.objects.get(rid=rid)
            data = {
                'rid': role.rid,
                'role_name': role.role_name,
                'description': role.description,
                'data_scope': role.data_scope,
                'agent_type': role.agent_type
            }
            return response.json(0, data)
        except AgentRole.DoesNotExist:
            return response.json(404,  "角色不存在")

    def doAdd(self, userID, request_dict, response):
        """新增角色"""
        data_dict = CommonService.request_dict_to_dict(request_dict)

        # 必填字段验证
        role_name = data_dict.get('role_name', '').strip()
        if not role_name:
            return response.json(444,  "角色名称不能为空")

        # 检查角色名是否已存在
        if AgentRole.objects.filter(role_name=role_name).exists():
            return response.json(500,  "角色名称已存在")

        # 自动生成角色ID
        max_rid = AgentRole.objects.aggregate(Max('rid'))['rid__max']
        new_rid = (max_rid or 0) + 1

        # 设置默认值
        data_dict['rid'] = new_rid
        data_dict.setdefault('description', '')
        data_dict.setdefault('data_scope', 1)
        data_dict.setdefault('agent_type', 1)

        try:
            role = AgentRole.objects.create(**data_dict)
            return response.json(0, {'rid': role.rid},  "角色创建成功")
        except Exception as e:
            return response.json(500,  f"角色创建失败: {str(e)}")

    def doEdit(self, userID, request_dict, response):
        """编辑角色"""
        data_dict = CommonService.request_dict_to_dict(request_dict)

        rid = data_dict.get('rid')
        if not rid:
            return response.json(444,  "缺少角色ID")

        try:
            role = AgentRole.objects.get(rid=rid)
        except AgentRole.DoesNotExist:
            return response.json(404,  "角色不存在")

        # 检查角色名是否已存在（排除自身）
        role_name = data_dict.get('role_name', '').strip()
        if role_name and AgentRole.objects.exclude(rid=rid).filter(role_name=role_name).exists():
            return response.json(500,  "角色名称已存在")

        # 移除不需要更新的字段
        data_dict.pop('rid', None)

        try:
            AgentRole.objects.filter(rid=rid).update(**data_dict)
            return response.json(0,  "角色更新成功")
        except Exception as e:
            return response.json(500,  f"角色更新失败: {str(e)}")

    def doDelete(self, userID, request_dict, response):
        """删除角色"""
        rid = request_dict.get('rid', '')
        if not rid:
            return response.json(444,  "缺少角色ID")

        try:
            role = AgentRole.objects.get(rid=rid)
        except AgentRole.DoesNotExist:
            return response.json(404,  "角色不存在")

        # 若已关联用户，需提示
        if AgentUserRole.objects.filter(role_id=rid).exists():
            return response.json(500,  "该角色已关联用户，不可删除")

        try:
            # 先删除角色菜单关联
            AgentRoleMenu.objects.filter(role_id=rid).delete()
            # 再删除角色
            role.delete()
            return response.json(0,  "角色删除成功")
        except Exception as e:
            return response.json(500,  f"角色删除失败: {str(e)}")

    def getAllMenusTree(self, userID, request_dict, response):
        """获取所有菜单的树形结构（用于权限分配）"""
        try:
            # 获取所有根菜单
            root_menus = AgentMenu.objects.filter(parentId=0).order_by('sort')
            menu_tree = []

            for root_menu in root_menus:
                menu_data = self._build_menu_tree(root_menu)
                menu_tree.append(menu_data)

            return response.json(0, {'list': menu_tree})
        except Exception as e:
            return response.json(500,  f"获取菜单树失败: {str(e)}")

    def _build_menu_tree(self, menu):
        """递归构建菜单树"""
        menu_data = {
            'id': menu.id,
            'title': menu.title,
            'parentId': menu.parentId,
            'menutype': menu.menutype,
            'sort': menu.sort
        }

        # 获取子菜单
        children = AgentMenu.objects.filter(parentId=menu.id).order_by('sort')
        if children.exists():
            menu_data['children'] = []
            for child in children:
                child_data = self._build_menu_tree(child)
                menu_data['children'].append(child_data)

        return menu_data

    def setPerms(self, userID, request_dict, response):
        """设置角色权限"""
        rid = request_dict.get('rid', '')
        menu_ids = request_dict.get('menu_ids', '')

        if not rid:
            return response.json(444,  "缺少角色ID")

        try:
            role = AgentRole.objects.get(rid=rid)

            with transaction.atomic():
                # 先清空角色的所有菜单权限
                AgentRoleMenu.objects.filter(role_id=rid).delete()

                # 添加新的菜单权限
                if menu_ids:
                    if isinstance(menu_ids, str):
                        menu_ids = menu_ids.split(',') if menu_ids else []

                    if menu_ids:
                        menu_objects = AgentMenu.objects.filter(id__in=menu_ids)

                        role_menus = []
                        for menu in menu_objects:
                            role_menus.append(AgentRoleMenu(role=role, menu=menu))

                        if role_menus:
                            AgentRoleMenu.objects.bulk_create(role_menus)

            return response.json(0,  "权限分配成功")
        except AgentRole.DoesNotExist:
            return response.json(404,  "角色不存在")
        except Exception as e:
            return response.json(500,  f"权限分配失败：{str(e)}")

    def getMenusIds(self, userID, request_dict, response):
        """获取角色关联的菜单ID列表"""
        rid = request_dict.get('rid', '')
        if not rid:
            return response.json(444,  "缺少角色ID")

        try:
            role = AgentRole.objects.get(rid=rid)
            # 获取角色关联的菜单ID列表
            menu_ids = AgentRoleMenu.objects.filter(role=role).values_list('menu_id', flat=True)
            return response.json(0, {'menu_ids': list(menu_ids)})
        except AgentRole.DoesNotExist:
            return response.json(404,  "角色不存在")
        except Exception as e:
            return response.json(500,  f"获取角色菜单失败: {str(e)}")

    def getUserInfo(self, userID, request_dict, response):
        """获取用户基本信息和角色 """
        try:
            print(f"获取用户信息 - userID: {userID}")

            # 获取用户角色关联信息
            user_roles = AgentUserRole.objects.filter(user_id=userID).select_related('role')
            print(f"找到的用户角色关联: {user_roles.count()} 条")

            roles = []
            role_ids = []
            for user_role in user_roles:
                roles.append(user_role.role.role_name)
                role_ids.append(user_role.role.rid)
                print(f"角色: {user_role.role.role_name} (ID: {user_role.role.rid})")

            # 如果没有找到角色，设置默认角色
            if not roles:
                print("用户没有分配角色，设置为默认用户")
                roles = ["user"]

            data = {
                'user_id': userID,
                'username': userID,
                'roles': roles,
                'role_ids': role_ids
            }
            print(f"返回用户信息: {data}")
            return response.json(0, data)
        except Exception as e:
            print(f"获取用户信息失败: {str(e)}")
            return response.json(500, f"获取用户信息失败: {str(e)}")