package com.dy.pipIrrBase.role;

import com.alibaba.fastjson2.JSONArray;
import com.dy.common.aop.SsoAop;
import com.dy.common.mybatis.envm.Deleted;
import com.dy.common.webUtil.BaseResponse;
import com.dy.common.webUtil.BaseResponseUtils;
import com.dy.common.webUtil.QueryResultVo;
import com.dy.common.webUtil.ResultCodeMsg;
import com.dy.pipIrrBase.result.SystemResultCode;
import com.dy.pipIrrGlobal.pojoBa.BaRole;
import com.dy.pipIrrGlobal.pojoBa.BaRolePermissions;
import com.dy.pipIrrGlobal.voBa.VoRole;
import com.dy.pipIrrGlobal.voSe.VoActiveCard;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.responses.ApiResponses;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.MediaType;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.*;

import java.util.*;

@Slf4j
@Tag(name = "角色管理", description = "角色增删改查等操作")
@RestController
@RequestMapping(path="role")
@RequiredArgsConstructor
@SuppressWarnings("unchecked")//java版本越高，对泛型约束越严，所以配置SuppressWarnings("unchecked")
public class RoleCtrl {

    private final RoleSv roleSv;

    /**
     * 根据指定条件（角色编号、角色名称）获取角色列表
     * 当获取一条记录时，传入roleId即可
     * @param vo
     * @return
     */
    @Operation(summary = "获得一页角色记录", description = "返回一页角色数据")
    @ApiResponses(value = {
            @ApiResponse(
                    responseCode = ResultCodeMsg.RsCode.SUCCESS_CODE,
                    description = "返回一页控制器数据（BaseResponse.content:QueryResultVo[{}]）",
                    content = {@Content(mediaType = MediaType.APPLICATION_JSON_VALUE,
                            schema = @Schema(implementation = VoActiveCard.class))}
            )
    })
    @GetMapping(path = "/roles")
    @SsoAop()
    public BaseResponse<QueryResultVo<List<VoRole>>> getRoles(QueryVo vo){
        try {
            //BaRolePermissions baRolePermissions = roleSv.getRolePermissionsById(2023122018334500002L);
            //return BaseResponseUtils.buildSuccess(baRolePermissions);

            QueryResultVo<List<VoRole>> res = roleSv.getRoles(vo);
            if(res.itemTotal != null && res.itemTotal > 0) {
                return BaseResponseUtils.buildSuccess(res);
            }else {
                return BaseResponseUtils.buildSuccess(SystemResultCode.NO_ROLES.getMessage());
            }

        } catch (Exception e) {
            log.error("获取开卡记录异常", e);
            return BaseResponseUtils.buildException(e.getMessage()) ;
        }
    }

    /**
     * 角色授权
     * 1. 如果roleid和roleName都空：提示错误信息
     * 2. 如果roleid为空：新建角色且授权
     *      1. 添加角色记录
     *      2. 添加角色、权限关联记录
     * 3. 如果roleid不为空：修改角色及授权
     *      1. 删除角色、权限记录
     *      2. 修改角色信息
     *      3. 添加角色、权限记录
     * @param po
     * @param bindingResult
     * @return
     */
    @Operation(summary = "授权", description = "授权")
    @ApiResponses(value = {
            @ApiResponse(
                    responseCode = ResultCodeMsg.RsCode.SUCCESS_CODE,
                    description = "操作结果：true：成功，false：失败（BaseResponse.content）",
                    content = {@Content(mediaType = MediaType.APPLICATION_JSON_VALUE,
                            schema = @Schema(implementation = Boolean.class))}
            )
    })
    @PostMapping(path = "addPermissions", consumes = MediaType.APPLICATION_JSON_VALUE)
    @Transactional(rollbackFor = Exception.class)
    @SsoAop()
    public BaseResponse<Boolean> permission(@RequestBody  @Valid DtoRole po, BindingResult bindingResult){
        if(bindingResult != null && bindingResult.hasErrors()){
            return BaseResponseUtils.buildFail(Objects.requireNonNull(bindingResult.getFieldError()).getDefaultMessage());
        }

        Long roleId = Optional.ofNullable(po.getRoleId()).orElse(0L);
        String roleName = Optional.ofNullable(po.getRoleName()).orElse("");
        JSONArray permissions = Optional.ofNullable(JSONArray.parseArray(po.getPermissions())).orElse(JSONArray.parseArray("[]"));
        Long operator = Optional.ofNullable(po.getOperator()).orElse(0L);

        if(roleId == 0 && roleName.length() == 0)
            return BaseResponseUtils.buildFail(SystemResultCode.PERMISSION_ERROR.getMessage());

        // 新建角色且授权
        if(roleId == 0) {
            BaRole baRole = new BaRole();
            baRole.setName(roleName);
            baRole.setOperator(operator);
            Date operateTime = new Date();
            baRole.setOperateDt(operateTime);
            baRole.setDeleted(Deleted.NO.getCode());
            roleId = Optional.ofNullable(roleSv.addRole(baRole)).orElse(0L);

            BaRolePermissions baRolePermissions = new BaRolePermissions();
            baRolePermissions.setRoleid(roleId);
            baRolePermissions.setPermissions(permissions);
            roleSv.addPermissions(baRolePermissions);
            return BaseResponseUtils.buildSuccess(true) ;
        }

        // 修改角色信息
        BaRole baRole = new BaRole();
        baRole.setId(roleId);
        baRole.setName(roleName);
        baRole.setOperator(operator);
        Date operateTime = new Date();
        baRole.setOperateDt(operateTime);
        roleSv.updateRole(baRole);

        // 修改角色授权
        BaRolePermissions baRolePermissions = new BaRolePermissions();
        baRolePermissions.setRoleid(roleId);
        baRolePermissions.setPermissions(permissions);
        roleSv.delPermissionsByRoleId(roleId);
        roleSv.addPermissions(baRolePermissions);

        return BaseResponseUtils.buildSuccess(true) ;
    }

    /**
     * 删除角色
     *  逻辑删除角色记录，物理删除角色授权记录
     * @param map
     * @return 是否成功
     */
    @Operation(summary = "删除角色", description = "提交角色ID，进行逻辑删除")
    @ApiResponses(value = {
            @ApiResponse(
                    responseCode = ResultCodeMsg.RsCode.SUCCESS_CODE,
                    description = "操作结果：true：成功，false：失败（BaseResponse.content）",
                    content = {@Content(mediaType = MediaType.APPLICATION_JSON_VALUE,
                            schema = @Schema(implementation = Boolean.class))}
            )
    })
    //@GetMapping(path = "delete", consumes = MediaType.TEXT_PLAIN_VALUE)
    @PostMapping(path = "delete", consumes = MediaType.APPLICATION_JSON_VALUE)
    @Transactional(rollbackFor = Exception.class)
    @SsoAop()
    public BaseResponse<Boolean> delete(@RequestBody Map map){
        Long id = Optional.ofNullable(Long.parseLong(map.get("id").toString())).orElse(0L);

        if(id == 0)
            return BaseResponseUtils.buildException(SystemResultCode.PLEASE_INPUT_ROLE_ID.getMessage());

        try {
            // 逻辑删除角色记录，物理删除角色授权记录
            Integer res_role = Optional.ofNullable(roleSv.deleteRoleById(id)).orElse(0);
            Integer res_per = Optional.ofNullable(roleSv.delPermissionsByRoleId(id)).orElse(0);
            if(res_role == 0 || res_per == 0)
                return BaseResponseUtils.buildFail(SystemResultCode.DELETE_ROLE_FAIL.getMessage());

            return BaseResponseUtils.buildSuccess(true);
        } catch (Exception e) {
            return BaseResponseUtils.buildException(e.getMessage()) ;
        }
    }

}