package com.example.springboot.controller;

import com.example.springboot.entity.*;
import com.example.springboot.entity.vo.Result;
import com.example.springboot.entity.vo.RolePermissionVo;
import com.example.springboot.mapper.RolePermissionMapper;
import com.example.springboot.service.PermissionService;
import com.example.springboot.service.RolePermissionService;
import com.example.springboot.service.RoleService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.apache.shiro.authz.annotation.RequiresRoles;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RestController
@Slf4j
@Api(tags = "角色和权限关系")
@RequestMapping("/api/rolePermission")
public class RolePermissionController {
    @Autowired
    private RolePermissionService rolePermissionService;
    @Autowired
    private RoleService roleService;
    @Autowired
    private PermissionService permissionService;



        @ApiOperation(value = "添加或者更新角色和权限关系")
        @PostMapping("/saveOrUpdate")
        @RequiresPermissions({"rolePermission:add"})
        @RequiresRoles({"admin"})
        public Result saveOrUpdate(@RequestBody RolePermission rolePermission) {
            Integer count = rolePermissionService.lambdaQuery()
                    .eq(RolePermission::getRoleId, rolePermission.getRoleId())
                    .eq(RolePermission::getPermissionId, rolePermission.getPermissionId())
                    .ne(rolePermission.getId() != null, RolePermission::getId, rolePermission.getId())
                    .count();
            if (count > 0) return Result.fail("授权已存在");
            rolePermissionService.saveOrUpdate(rolePermission);
            return Result.success();
        }

        @ApiOperation(value = "根据id删除角色和权限关系")
        @PostMapping("/removeById")
        @RequiresPermissions({"rolePermission:delete"})
        @RequiresRoles({"admin"})
        public Result removeById(@RequestBody RolePermissionVo rolePermissionVO) {
            rolePermissionService.removeById(rolePermissionVO.getId());
            return Result.success();
        }

        @ApiOperation(value = "分页查询角色和权限关系")
        @GetMapping("/selectPage")
        @RequiresRoles({"admin"})
        @RequiresPermissions({"rolePermission:select"})
        public Result selectPage(RolePermissionVo rolePermissionVO) {
            return Result.success(rolePermissionService.selectPage(rolePermissionVO));
        }

        @ApiOperation(value = "根据id查询角色和权限关系")
        @GetMapping("/getById")
        @RequiresRoles({"admin"})
        @RequiresPermissions({"rolePermission:select"})
        public Result getById(RolePermissionVo rolePermissionVO) {
            RolePermission rolePermission = rolePermissionService.getById(rolePermissionVO.getId());
            if (rolePermission != null) {
                Role role = roleService.getById(rolePermission.getRoleId());
                Permission permission = permissionService.getById(rolePermission.getPermissionId());
                rolePermission.setRole(role);
                rolePermission.setPermission(permission);
            }
            return Result.success(rolePermission);





        }
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Autowired RolePermissionMapper RolePermissionMapper;
    ;


    @GetMapping("/getByRoleId")

    public com.example.springboot.common.Result selectquanxian(@RequestParam("roleId") int roleId) {
        List<Map<String, Object>> resultSet = RolePermissionMapper.selectquanxian(roleId);

        List<Map<String, Object>> permissions = new ArrayList<>();
        for (Map<String, Object> result : resultSet) {

            Long role_id2 = (Long) result.get("role_id");
            int state = (int) result.get("state");
            Long permission_id = (Long) result.get("permission_id"); // 注意这里的类型是Long
            String permissionName = (String) result.get("name");

            Map<String, Object> permission = new HashMap<>();
            permission.put("roleId", role_id2.intValue());
            permission.put("name", permissionName);
            permission.put("permission_id", permission_id.intValue()); // 将Long类型转换为int类型
            permission.put("state", state);
            permissions.add(permission);
        }

        Map<String, Object> map = new HashMap<>();
        map.put("permissionList", permissions);
        return com.example.springboot.common.Result.success(map);
    }


    @PostMapping("/savePermissions")
    public Result savePermissions(@RequestBody Map<String, Object> requestBody) {
        try {
            // 获取权限数据列表
            List<Map<String, Object>> permissions = (List<Map<String, Object>>) requestBody.get("permissions");
            // 遍历接收到的权限数据
            for (Map<String, Object> permission : permissions) {
                // 获取权限项的roleId、name、state和permission_id
                int roleId = (int) permission.get("roleId");
                String name = (String) permission.get("name");
                int state = (int) permission.get("state");
                int permissionId = (int) permission.get("permission_id");

                // 根据roleId和permissionId查询是否已存在该权限记录
                boolean exists = RolePermissionMapper.checkExists(roleId, permissionId);

                if (exists) {
                    // 如果已存在该权限记录，则更新状态
                    RolePermissionMapper.updateState(roleId, permissionId, state);
                } else {
                    // 如果不存在该权限记录，则新增一条权限记录
                    RolePermissionMapper.insert(roleId, permissionId, state);
                }
            }

            return Result.success(); // 成功保存权限后返回结果
        } catch (Exception e) {
            e.printStackTrace();
            return Result.fail("保存权限失败"); // 保存权限失败时返回错误信息
        }
    }







}