package com.rzyc.controller;

import com.alibaba.fastjson.JSONObject;
import com.common.utils.model.Code;
import com.common.utils.model.Message;
import com.alibaba.fastjson.JSONArray;
import com.common.utils.StringUtils;
import com.common.utils.encryption.PasswdFactory;
import com.common.utils.jwt.JwtUtil;
import com.common.utils.model.SingleResult;
import com.rzyc.bean.user.dto.LoginDto;
import com.rzyc.config.MethodAnnotation;
import com.rzyc.config.RedisUtil;
import com.rzyc.model.dto.*;
import com.rzyc.model.ent.EntUser;
import com.rzyc.service.PcBusinessService;
import com.rzyc.service.UserLoginService;
import com.rzyc.bean.user.dto.WeChartLoginDto;
import com.rzyc.model.ent.SysEnterprise;
import com.rzyc.model.user.SysUser;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
import javax.validation.constraints.NotNull;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;


/**
 * 个人中心系统
 * @author dong
 * @author Xuwanxin
 * @date 2022-09-16 14:19
 * @Version V1.0
 */
@Api(tags = "个人中心系统")
@CrossOrigin("*")
@RequestMapping("personal")
@RestController
@Validated
public class PersonalController extends BaseController{

    UserLoginService userLoginService;

    PcBusinessService pcBusinessService;

    RedisUtil redisUtil;

    @Autowired
    public PersonalController(UserLoginService userLoginService, PcBusinessService pcBusinessService, RedisUtil redisUtil) {
        this.userLoginService = userLoginService;
        this.pcBusinessService = pcBusinessService;
        this.redisUtil = redisUtil;
    }

    /**
     * 用户登录
     * @version v1.0
     */
    @ApiOperation(value = "用户登录", notes = "用户登录")
    @PostMapping(value = "/login")
    public SingleResult<String> login(@Valid LoginDto loginDto)throws Exception{
        SingleResult<String> result = new SingleResult<>();

        String generateCode = request.getSession().getAttribute(constantsConfigure.getGenerateCodeKey())+"";
        //验证码只能使用一次
        request.getSession().removeAttribute(constantsConfigure.getGenerateCodeKey());

        if(loginDto.getGenerateCode().equals(generateCode)) {
            String loginResult = userLoginService.login(loginDto.sysusername, loginDto.getSyspassword());
            if (Objects.isNull(loginResult)) {
                result.setCode(Code.PASSWORD_OR_ACCOUNT_ERROR.getCode());
                result.setMessage(Message.PASSWORD_OR_ACCOUNT_ERROR);
            } else {
                System.out.println("登陆成功");
                result.setData(loginResult);
            }
        }else {
            result.setCode(Code.CODE_ERROT.getCode());
            result.setMessage(Message.CODE_ERROT);
        }
        return result;
    }

    /**
     * 企业登录
     * @param loginDto
     * @return
     * @throws Exception
     */
    @ApiOperation(value = "企业登录", notes = "企业登录")
    @PostMapping(value = "/entlogin")
    @ResponseBody
    public SingleResult<SysUser> applogin(@Valid WeChartLoginDto loginDto)throws Exception{
        SingleResult<SysUser> result = new SingleResult<>();
        System.out.println("loginDto -> "+JSONArray.toJSONString(loginDto));
        String sysusername = loginDto.getSysusername();
        String syspassword = loginDto.getSyspassword();
        System.out.println("sessionid -> "+request.getSession().getId());
        SysUser sysUser = sysUserMapper.findBySysUserName(sysusername);
        if(null != sysUser && StringUtils.isNotBlank(sysUser.getUsertype())){
            if("企业用户".equals(sysUser)){
                //如果企业被禁用 直接返回登录失败
                SysEnterprise sysEnterprise = sysEnterpriseMapper.selectByPrimaryKey(sysUser.getSysunitorentid());
                if(null == sysEnterprise){
                    result.setCode(Code.TOKEN_EXPIRE.getCode());
                    result.setMessage(Message.TOKEN_EXPIRE);
                    return result;
                }
            }
            String ps = PasswdFactory.encryptPasswd(sysUser.getSysuserid(), sysusername, syspassword);
            if(sysUser.getSyspassword().equals(ps) || "guest".equals(sysUser.getUsertype())){
                sysUser.setSyspassword("");


                sysUser.setSyspassword("");

                //获取职务
                sysUser = getUserDuty(sysUser);

//                if(StringUtils.isNotBlank())

                //通过角色判断是否为安办 或者 部门管理员
                if(StringUtils.isNotBlank(sysUser.getUserroles())){
                    Integer userRole = this.getUserRole(sysUser.getUserroles());
                    sysUser.setUserRole(userRole);
                }

                //用户权限
                userAuth(sysUser);

                this.addLogAuth(sysUser.getSysuserid(),"登录","成功","");
                String userToken = JwtUtil.createToken(sysUser.getSysuserid());
                sysUser.setUserToken(userToken);
                result.setData(sysUser);

            }else{
                this.addLogAuth(sysUser.getSysuserid(),"登录","失败","");
                result.setCode(Code.PASSWORD_ERROR.getCode());
                result.setMessage(Message.PASSWORD_ERROR);
            }
        }else{
            result.setCode(Code.PASSWORD_ERROR.getCode());
            result.setMessage(Message.PASSWORD_ERROR);
        }
        return result;
    }


    /**
     * 企业用户组织树
     * @param enterpriseId 企业id
     * @param postId 企业用户id
     * @return 企业用户树
     * @throws Exception
     */
    @ApiOperation(value = "企业用户组织树", notes = "企业用户组织树")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "enterpriseId", value = "公司id", required = true, dataType = "string"),
            @ApiImplicitParam(name = "postId", value = "企业用户岗位id",required = false, dataType = "string"),
    })
    @GetMapping(value = "/entUserTree")
    @PreAuthorize("hasAnyAuthority('entUserTree','entUserTree:update')")
    @MethodAnnotation(authorizations = {"entUserTree","entUserTree:update"},name = "企业用户组织树")
    @ResponseBody
    public SingleResult<List<EntUser>> entUserTree(@NotNull(message = "公司id不能为null") String enterpriseId, String postId)throws Exception{
        return  pcBusinessService.entUserTree(enterpriseId,postId);
    }


    /**
     * 企业用户工作要务
     * @param entUserPostListDto 企业用户工作要务
     * @return 企业用户工作要务
     * @throws Exception
     */
    @ApiOperation(value = "企业用户工作要务", notes = "企业用户工作要务")
    @GetMapping(value = "/entUserPostList")
    @PreAuthorize("hasAnyAuthority('entUserPostList','entUserPostList:update')")
    @MethodAnnotation(authorizations = {"entUserPostList","entUserPostList:update"},name = "企业用户工作要务")
    @ResponseBody
    public SingleResult entUserPostList(@RequestBody EntUserPostListDto entUserPostListDto)throws Exception{
        return  pcBusinessService.entUserPostList(entUserPostListDto);
    }


    /**
     * 企业用户工作清单
     * @return 企业用户工作清单
     * @throws Exception
     */
    @ApiOperation(value = "企业用户工作清单", notes = "企业用户工作清单")
    @GetMapping(value = "/entUserPostTask")
    @PreAuthorize("hasAnyAuthority('entUserPostTask','entUserPostTask:update')")
    @MethodAnnotation(authorizations = {"entUserPostTask","entUserPostTask:update"},name = "企业用户工作清单")
    @ResponseBody
    public SingleResult entUserPostTask(@RequestBody EntUserPostTaskDto entUserPostTaskDto)throws Exception{
        return  pcBusinessService.entUserPostTask(entUserPostTaskDto);
    }


    /**
     * 企业用户岗位职责
     * @param entUserPostDutyDto 企业用户岗位职责参数对象
     * @return 企业用户岗位职责
     * @throws Exception
     */
    @ApiOperation(value = "企业用户岗位职责", notes = "企业用户岗位职责")
    @GetMapping(value = "/entUserPostDuty")
    @PreAuthorize("hasAnyAuthority('entUserPostDuty','entUserPostDuty:update')")
    @MethodAnnotation(authorizations = {"entUserPostDuty","entUserPostDuty:update"},name = "企业用户岗位职责")
    @ResponseBody
    public SingleResult entUserPostDuty(@RequestBody EntUserPostDutyDto entUserPostDutyDto)throws Exception{
        return  pcBusinessService.entUserPostDuty(entUserPostDutyDto);
    }

    /**
     * 企业用户证照表
     * @param entUserId 企业用户id
     * @return 企业用户证照表
     * @throws Exception
     */
    @ApiOperation(value = "企业用户证照表", notes = "企业用户证照表")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "entUserId", value = "企业用户id",required = true, dataType = "string"),
            @ApiImplicitParam(name = "page", value = "page",required = true, dataType = "int"),
            @ApiImplicitParam(name = "pageSize", value = "pageSize",required = true, dataType = "int"),
    })
    @GetMapping(value = "/entUserCredential")
    @PreAuthorize("hasAnyAuthority('entUserCredential','entUserCredential:update')")
    @MethodAnnotation(authorizations = {"entUserCredential","entUserCredential:update"},name = "企业用户证照表")
    @ResponseBody
    public SingleResult entUserCredential(@NotNull(message = "企业用户id不能为null") String entUserId, @NotNull(message = "页码不能为null") Integer page, @NotNull(message = "条数不能为null")Integer pageSize)throws Exception{
        return  pcBusinessService.entUserCredential(null,entUserId,page,pageSize);
    }

    /**
     * 企业用户证照表-新增,修改
     * @param entUserCredentialUpdateDto 企业用户证件对象
     * @return 成功或失败
     * @throws Exception
     */
    @ApiOperation(value = "企业用户证照表-新增,修改", notes = "企业用户证照表-新增,修改")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "entUserId", value = "企业用户id",required = true, dataType = "string"),
    })
    @PostMapping(value = "/entUserCredentialUpdate")
    @PreAuthorize("hasAnyAuthority('entUserCredentialUpdate:update')")
    @MethodAnnotation(authorizations = {"entUserCredentialUpdate:update"},name = "企业用户证照表-新增,修改")
    @ResponseBody
    public SingleResult entUserCredentialUpdate(@RequestBody EntUserCredentialUpdateDto entUserCredentialUpdateDto)throws Exception{
        List<EntUserCredentialUpdateDto>entUserCredentialUpdateDtos = new ArrayList<>();
        entUserCredentialUpdateDtos.add(entUserCredentialUpdateDto);
        return  pcBusinessService.entUserCredentialUpdate(entUserCredentialUpdateDtos);
    }


    /**
     * 企业用户证照表-删除
     * @param credentialId 企业用户证件表删除
     * @return 成功或失败
     * @throws Exception
     */
    @ApiOperation(value = "企业用户证照表-删除", notes = "企业用户证照表-删除")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "credentialId", value = "证件照id",required = true, dataType = "string"),
    })
    @PostMapping(value = "/entUserCredentialDelete")
    @PreAuthorize("hasAnyAuthority('entUserCredentialDelete')")
    @MethodAnnotation(authorizations = {"entUserCredentialDelete"},name = "企业用户证照表-删除")
    @ResponseBody
    public SingleResult entUserCredentialDelete(@NotNull(message = "证件照id不能为null") String credentialId)throws Exception{
        return  pcBusinessService.entUserCredentialDelete(credentialId);
    }


    /**
     * 企业岗位总体信息列表
     * @param keyContent
     * @return list
     * @throws Exception
     */
    @ApiOperation(value = "企业岗位总体信息列表", notes = "企业岗位总体信息列表")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "keyContent", value = "搜索关键字",required = true, dataType = "string"),
            @ApiImplicitParam(name = "page", value = "page",required = true, dataType = "int"),
            @ApiImplicitParam(name = "pageSize", value = "pageSize",required = true, dataType = "int"),
    })
    @GetMapping(value = "/entUserList")
    @PreAuthorize("hasAnyAuthority('entUserList','entUserList:update')")
    @MethodAnnotation(authorizations = {"entUserList","entUserList:update"},name = "企业岗位总体信息列表")
    @ResponseBody
    public SingleResult entUserList(@NotNull(message = "搜索关键字不能为null") String keyContent,
                                    @NotNull(message = "页码不能为null") Integer page,
                                    @NotNull(message = "条数不能为null") Integer pageSize)throws Exception{
        return  pcBusinessService.entUserList(keyContent,page,pageSize);
    }


    /**
     * 新增和修改公司岗位人员
     * @param addOrUpdateEntUserDto
     * @return list
     * @throws Exception
     */
    @ApiOperation(value = "新增和修改公司岗位人员", notes = "新增和修改公司岗位人员")
    @PostMapping(value = "/addOrUpdateEntUser")
    @PreAuthorize("hasAnyAuthority('addOrUpdateEntUser:update')")
    @MethodAnnotation(authorizations = {"addOrUpdateEntUser:update"},name = "新增和修改公司岗位人员")
    @ResponseBody
    @Transactional(rollbackFor = Exception.class)
    public SingleResult addOrUpdateEntUser(@RequestBody AddOrUpdateEntUserDto addOrUpdateEntUserDto)throws Exception{
        return  pcBusinessService.addOrUpdateEntUser(addOrUpdateEntUserDto);
    }


    /**
     * 新增和修改公司岗位
     * @param addOrUpdateEntPostDto
     * @return list
     * @throws Exception
     */
    @ApiOperation(value = "新增和修改公司岗位", notes = "新增和修改公司岗位")
    @PostMapping(value = "/addOrUpdateEntPost")
    @PreAuthorize("hasAnyAuthority('addOrUpdateEntPost:update')")
    @MethodAnnotation(authorizations = {"addOrUpdateEntPost:update"},name = "新增和修改公司岗位")
    @ResponseBody
    @Transactional(rollbackFor = Exception.class)
    public SingleResult addOrUpdateEntPost(@RequestBody AddOrUpdateEntPostDto addOrUpdateEntPostDto)throws Exception{
        return  pcBusinessService.addOrUpdateEntPost(addOrUpdateEntPostDto);
    }









}