package cn.com.goldenwater.dcproj.controller.system;

import cn.com.goldenwater.core.web.BaseController;
import cn.com.goldenwater.core.web.BaseResponse;
import cn.com.goldenwater.dcproj.param.GetRoleByUserIdParam;
import cn.com.goldenwater.dcproj.service.OlBisInspOrgService;
import cn.com.goldenwater.dcproj.target.VerifyBean;
import cn.com.goldenwater.id.util.UuidUtil;
import cn.com.goldenwater.dcproj.dto.RoleDto;
import cn.com.goldenwater.dcproj.model.Role;
import cn.com.goldenwater.dcproj.param.RoleParam;
import cn.com.goldenwater.dcproj.param.RolePrivParam;
import cn.com.goldenwater.dcproj.param.UserRoleParam;
import cn.com.goldenwater.dcproj.service.RoleService;
import cn.com.goldenwater.dcproj.service.UserRoleService;
import com.github.pagehelper.PageInfo;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;

/**
 * @author lune
 * @date 2018-2-13
 */
@Api(value = "角色管理", tags = "003角色管理")
@RestController
@RequestMapping("/sys/roles")
public class RoleController extends BaseController {

    private Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private RoleService roleService;
    @Autowired
    private UserRoleService userRoleService;
    @Autowired
    private OlBisInspOrgService olBisInspOrgService;

    @ApiOperation(value = "添加角色(关联权限)")
    @RequestMapping(value = "insertRole", method = RequestMethod.POST)
    public BaseResponse<String> insertRole(@ApiParam(name = "role", value = "Role", required = true)
                                           @RequestBody Role role) {
        Assert.notNull(role, "角色对象不能为空");
        String uuid = UuidUtil.uuid();  // 生成uuid
        role.setId(uuid);
        if(!"".equals(olBisInspOrgService.getProvince(getCurrentOrgId()))) {
            role.setOrgId(getCurrentOrgId());
            if(StringUtils.isBlank(role.getOfcId())){
                role.setOfcId(getCurrentOrgId());
            }
        }

        ArrayList<RolePrivParam> rolePrivParams = new ArrayList<>();
        if (null != role.getPrivIds() && role.getPrivIds().size() > 0) {
            for (String privId : role.getPrivIds()) {
                RolePrivParam rolePrivParam = new RolePrivParam();
                rolePrivParam.setPrivId(privId);
                rolePrivParam.setRoleId(role.getId());
                rolePrivParams.add(rolePrivParam);
            }
        }

        RolePrivParam param = new RolePrivParam();
        param.setRoleId(role.getId());
        roleService.insertRole(role, rolePrivParams, param);
        return buildSuccessResponse();
    }

    @ApiOperation(value = "修改角色(关联权限)")
    @RequestMapping(value = "updateRole", method = RequestMethod.POST)
    public BaseResponse<String> updateRole(@ApiParam(name = "role", value = "Role", required = true)
                                           @RequestBody Role role) {
        Assert.notNull(role, "角色对象不能为空");

        ArrayList<RolePrivParam> rolePrivParams = new ArrayList<>();
        if (null != role.getPrivIds() && role.getPrivIds().size() > 0) {
            for (String privId : role.getPrivIds()) {
                RolePrivParam rolePrivParam = new RolePrivParam();
                rolePrivParam.setPrivId(privId);
                rolePrivParam.setRoleId(role.getId());
                rolePrivParams.add(rolePrivParam);
            }
        }
        RolePrivParam param = new RolePrivParam();
        param.setRoleId(role.getId());
        roleService.updateRole(role, rolePrivParams, param);
        return buildSuccessResponse();
    }

    @ApiOperation(value = "添加角色")
    @RequestMapping(value = "", method = RequestMethod.POST)
    public BaseResponse<String> insert(@ApiParam(name = "role", value = "Role", required = true) @RequestBody Role role) {
        String uuid = UuidUtil.uuid();  // 生成uuid
        role.setId(uuid);
        int ret = roleService.insert(role);
        return buildSuccessResponse(uuid);
    }

    @ApiOperation(value = "根据ID删除角色")
    @RequestMapping(value = "/{id}", method = RequestMethod.POST)
    public BaseResponse delete(@ApiParam(name = "id", value = "id", required = true) @PathVariable String id) {
        int ret = roleService.deleteInFlag(id);
        return buildSuccessResponse();
    }

    @ApiOperation(value = "更新角色信息")
    @RequestMapping(value = "/update", method = RequestMethod.POST)
    public BaseResponse update(@ApiParam(name = "role", value = "Role", required = true) @RequestBody Role role) {
        Assert.notNull(role.getId(), "主键id为必填参数");
        int ret = roleService.update(role);
        return buildSuccessResponse();
    }

    @ApiOperation(value = "根据ID获取角色（单表）")
    @RequestMapping(value = "/{id}", method = RequestMethod.GET)
    public BaseResponse<Role> get(@ApiParam(name = "id", value = "id", required = true) @PathVariable String id) {
        Role role = roleService.get(id);
        return buildSuccessResponse(role);
    }

    @ApiOperation(value = "批量增加用户角色关系表（角色id和用户id）")
    @RequestMapping(value = "insert-user-role", method = RequestMethod.POST)
    public BaseResponse<String> insertList(@ApiParam(name = "list", value = "userRoleParam数组（角色id和用户id）", required = true) @RequestBody List<UserRoleParam> list) {
        int ret = userRoleService.addList(list);
        return buildSuccessResponse();
    }

    @ApiOperation(value = "批量删除用户角色关系表（角色id和用户id）")
    @RequestMapping(value = "delete-user-role", method = RequestMethod.POST)
    public BaseResponse<String> deleteList(@ApiParam(name = "list", value = "userRoleParam数组（角色id和用户id）", required = true) @RequestBody List<UserRoleParam> list) {
        int ret = userRoleService.deleteList(list);
        return buildSuccessResponse();
    }

    @VerifyBean
    @ApiOperation(value = "根据用户ID获取角色")
    @RequestMapping(value = "/list-by-user", method = RequestMethod.POST)
    public BaseResponse<PageInfo<RoleDto>> getRoleByUserId(@RequestBody GetRoleByUserIdParam param) throws Exception {
        param.setOrgId(getCurrentOrgId());
        return buildSuccessResponse(roleService.getRoleByUserId(param));
    }

    @ApiOperation(value = "获取所有角色")
    @RequestMapping(value = "/findList", method = RequestMethod.POST)
    public BaseResponse<List<Role>> findList(@ApiParam(name = "roleParam", value = "RoleParam", required = false) @RequestBody RoleParam param) {
        List<Role> list = roleService.findList(param);
        return buildSuccessResponse(list);
    }

    @ApiOperation(value = "根据条件分页获取角色列表-不包含分页信息（currentUser=true为当前用户角色）")
    @RequestMapping(value = "/page", method = RequestMethod.POST)
    public BaseResponse<List<RoleDto>> listRolePage(@ApiParam(name = "roleParam", value = "条件（机构id和用户id必填）", required = true) @RequestBody RoleParam roleParam) {

        List<RoleDto> list = roleService.findPageDto(roleParam);
        return buildSuccessResponse(list);
    }

    @ApiOperation(value = "根据条件分页获取角色列表-包含分页信息（currentUser=true为当前用户角色）")
    @RequestMapping(value = "/pageInfoCascades", method = RequestMethod.POST)
    public BaseResponse<PageInfo<RoleDto>> listRolePageInfo(@ApiParam(name = "roleParam", value = "条件（机构id和用户id必填）", required = true) @RequestBody RoleParam roleParam) {

        PageInfo<RoleDto> page = roleService.findPageInfoDto(roleParam);
        return buildSuccessResponse(page);
    }


    @ApiOperation(value = "分页获取角色列表-包含分页信息")
    @RequestMapping(value = "/pageInfo", method = RequestMethod.POST)
    public BaseResponse<PageInfo<Role>> getMenuPageInfo(@ApiParam(name = "roleParam", value = "RoleParam", required = false) @RequestBody RoleParam roleParam) {
        PageInfo<Role> page = roleService.findPageInfo(roleParam);
        return buildSuccessResponse(page);
    }

    @ApiOperation(value = "更新用户与角色的关联关系")
    @RequestMapping(value = "/updateUserRole", method = RequestMethod.POST)
    public BaseResponse updateUserRole(@ApiParam(name = "string", value = "roleIds", required = true) @RequestBody List<String> roleIds, String userId) {
        Assert.notEmpty(roleIds, "角色Id集合不能为空");
        Assert.notNull(userId, "用户Id不能为空");
        ArrayList<UserRoleParam> userRoleParams = new ArrayList<>();
        for (String roleId : roleIds) {
            UserRoleParam userRoleParam = new UserRoleParam();
            userRoleParam.setUserId(userId);
            userRoleParam.setRoleId(roleId);
            userRoleParams.add(userRoleParam);
        }
        UserRoleParam param = new UserRoleParam();
        param.setUserId(userId);
        userRoleService.updateUserRole(userRoleParams, param);
        return buildSuccessResponse();
    }
}