package com.ruoyi.project.mobile.service;


import com.fasterxml.jackson.databind.ObjectMapper;
import com.github.pagehelper.util.StringUtil;
import com.ruoyi.common.constant.Constants;
import com.ruoyi.common.exception.BusinessException;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.MessageUtils;
import com.ruoyi.common.utils.RegexUtil;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.framework.manager.AsyncManager;
import com.ruoyi.framework.manager.factory.AsyncFactory;
import com.ruoyi.framework.shiro.service.PasswordService;
import com.ruoyi.project.mobile.domain.ApiRequestHeader;
import com.ruoyi.project.mobile.domain.ApiResult;
import com.ruoyi.project.system.company.domain.Company;
import com.ruoyi.project.system.company.service.ICompanyService;
import com.ruoyi.project.system.role.service.IRoleService;
import com.ruoyi.project.system.user.domain.User;
import com.ruoyi.project.system.user.service.IUserService;
import com.ruoyi.project.system.userLoginInfo.domain.UserLoginInfo;
import com.ruoyi.project.system.userLoginInfo.service.IUserLoginInfoService;
import com.ruoyi.project.tr.JpushMsg.domain.JpushMsg;
import com.ruoyi.project.tr.JpushMsg.service.IJpushMsgService;
import com.ruoyi.project.tr.hiddenDangerCheck.domain.HiddenDangerCheck;
import com.ruoyi.project.tr.hiddenDangerCheck.service.IHiddenDangerCheckService;
import com.ruoyi.project.tr.hiddenDangerCheckPoint.domain.HiddenDangerCheckPoint;
import com.ruoyi.project.tr.hiddenDangerCheckPoint.service.IHiddenDangerCheckPointService;
import com.ruoyi.project.tr.report.mapper.ReportMapper;
import com.ruoyi.project.tr.report.service.ReportService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import java.math.BigDecimal;
import java.text.DateFormat;
import java.text.NumberFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;


@Service
public class ApiSystemService extends BaseApiService {

    private static Logger logger = LoggerFactory.getLogger(ApiSystemService.class);

    @Autowired
    IUserService userService;//用户Service

    @Autowired
    IUserLoginInfoService userLoginInfoService;//客户端用户登录信息Service

    @Autowired
    private PasswordService passwordService;//密码验证Service

    @Autowired
    private ReportService reportService;

    @Autowired
    IHiddenDangerCheckService hiddenDangerCheckService;//隐患

    @Autowired
    IHiddenDangerCheckPointService hiddenDangerCheckPointService;//隐患

    @Autowired
    private ReportMapper reportMapper;

    @Autowired
    private IJpushMsgService jpushMsgService;

    @Autowired
    private IRoleService roleService;


    @Autowired
    private ICompanyService companyService;

    /**
     * 客户端登陆时返回给客户端的封装信息ApiResult
     *
     * @param str
     * @param header
     * @return
     */
    public ApiResult login(String str, ApiRequestHeader header) {
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String loginName = header.loginName;
        try {
            User userAppLoginInfo = new ObjectMapper().readValue(str, User.class);
            if (StringUtils.isEmpty(header.deviceType)) {
                return ApiResult.error("设备类型不能为空");
            }
            if (StringUtils.isEmpty(header.deviceId)) {
                return ApiResult.error("设备id不能为空");
            }
            if (StringUtils.isEmpty(header.appType)) {
                return ApiResult.error("app类型不能为空");
            }
            if (StringUtils.isEmpty(header.loginName)) {
                return ApiResult.error("用户登录帐号不能为空");
            }

            String username = loginName;//用户名
            String password = userAppLoginInfo.getPassword();//密码

            // 查询用户信息
            User user = userService.selectUserByLoginName(username);
//            if(user.getCompanyId().equals(16L)){
//                return ApiResult.error("用户已封禁，请联系管理员");
//            }
            if (user == null) {
                AsyncManager.me().execute(AsyncFactory.recordLogininfor(username, Constants.LOGIN_FAIL, MessageUtils.message("user.not.exists")));
                return ApiResult.error("用户名不存在");
            }
            //验证用户名/密码是否匹配
            if (!passwordService.matches(user, password)) {
                AsyncManager.me().execute(AsyncFactory.recordLogininfor(username, Constants.LOGIN_FAIL, MessageUtils.message("user.password.not.match")));
                return ApiResult.error("密码错误,请重新输入");
            } else {
                AsyncManager.me().execute(AsyncFactory.recordLogininfor(username, Constants.LOGIN_SUCCESS, MessageUtils.message("user.login.success")));

                //设置客户端用户登录信息
                String token = UUID.randomUUID().toString();//生成token
                UserLoginInfo queryUserLoginInfo = userLoginInfoService.selectUserLoginInfoById(user.getUserId());


                // 网络协议
                String networkProtocol = request.getScheme();
                // 网络ip
                String ip = request.getServerName();
                // 端口号
                int port = request.getServerPort();
                // 项目发布名称
                String webApp = request.getContextPath();
                String urlPrefix = networkProtocol + "://" + ip + ":" + port + webApp;

                if (queryUserLoginInfo == null) {
                    UserLoginInfo userLoginInfo = new UserLoginInfo();
                    userLoginInfo.setCreateBy(user.getUserId().toString());
                    userLoginInfo.setCreateTime(DateUtils.getNowDate());
                    userLoginInfo.setUserId(user.getUserId());
                    userLoginInfo.setToken(token);
                    userLoginInfo.setDeviceType(header.deviceType);
                    userLoginInfo.setDeviceId(header.deviceId);
                    userLoginInfo.setAppType(header.appType);
                    userLoginInfoService.insertUserLoginInfo(userLoginInfo);
                    userLoginInfo.setCompanyId(user.getCompany().getCompanyId());
                    userLoginInfo.setCompanyName(user.getCompany().getCompanyName());
                    userLoginInfo.setLoginName(user.getLoginName());
                    userLoginInfo.setUserName(user.getUserName());
                    userLoginInfo.setAvatar(StringUtil.isEmpty(user.getAvatar())?
                            (urlPrefix +   "/img/profile.png") : (urlPrefix +   user.getAvatar()));
                    userLoginInfo.setDeptId(user.getDeptId());
                    userLoginInfo.setDeptName(user.getDept().getDeptName());

                    Set<String> stringSet = roleService.selectRoleKeys(user.getUserId());
                    if (stringSet.contains("straightRegionUser")){
                        userLoginInfo.setRegionUser("straightRegionUser");
                        userLoginInfo.setRoleName("straightRegionUser");
                    }else if (stringSet.contains("regionUser")){
                        userLoginInfo.setRegionUser("regionUser");
                        userLoginInfo.setRoleName("regionUser");
                    }else if (stringSet.contains("common")) {
                        //判断是否有子公司
                        Company sonQuery = new Company();
                        sonQuery.setParentId(user.getCompanyId());
                        List<Company> sonList = companyService.selectCompanyList(sonQuery);
                        if(sonList.size()==0){
                            userLoginInfo.setRoleName("commonUser");
                        }else{
                            userLoginInfo.setRoleName("companyAdminUser");
                        }
                    }else{
                        userLoginInfo.setRoleName("commonUser");
                    }
                    return ApiResult.success("登录成功", userLoginInfo);
                } else {
                    queryUserLoginInfo.setUpdateBy(user.getUserId().toString());
                    queryUserLoginInfo.setUpdateTime(DateUtils.getNowDate());
                    queryUserLoginInfo.setToken(token);
                    queryUserLoginInfo.setDeviceType(header.deviceType);
                    queryUserLoginInfo.setDeviceId(header.deviceId);
                    queryUserLoginInfo.setAppType(header.appType);
                    userLoginInfoService.updateUserLoginInfo(queryUserLoginInfo);
                    queryUserLoginInfo.setCompanyId(user.getCompany().getCompanyId());
                    queryUserLoginInfo.setCompanyName(user.getCompany().getCompanyName());
                    queryUserLoginInfo.setLoginName(user.getLoginName());
                    queryUserLoginInfo.setUserName(user.getUserName());
                    queryUserLoginInfo.setAvatar(StringUtil.isEmpty(user.getAvatar())?
                            (urlPrefix +   "/img/profile.png") : (urlPrefix +   user.getAvatar()));
                    queryUserLoginInfo.setDeptId(user.getDeptId());
                    queryUserLoginInfo.setDeptName(user.getDept().getDeptName());

                    Set<String> stringSet = roleService.selectRoleKeys(user.getUserId());
                    if (stringSet.contains("straightRegionUser")){
                        queryUserLoginInfo.setRegionUser("straightRegionUser");
                        queryUserLoginInfo.setRoleName("straightRegionUser");
                    }else if (stringSet.contains("regionUser")){
                        queryUserLoginInfo.setRegionUser("regionUser");
                        queryUserLoginInfo.setRoleName("regionUser");
                    }else if (stringSet.contains("common")) {
                        //判断是否有子公司
                        Company sonQuery = new Company();
                        sonQuery.setParentId(user.getCompanyId());
                        List<Company> sonList = companyService.selectCompanyList(sonQuery);
                        if(sonList.size()==0){
                            queryUserLoginInfo.setRoleName("commonUser");
                        }else{
                            queryUserLoginInfo.setRoleName("companyAdminUser");
                        }
                    }else{
                        queryUserLoginInfo.setRoleName("commonUser");
                    }
                    return ApiResult.success("登录成功", queryUserLoginInfo);
                }
            }
        } catch (Exception e) {
            ApiResult.error("异常");
        }
        return ApiResult.error("异常");
    }


    /**
     * 客户端退出登陆
     *
     * @param str
     * @param header
     * @return
     */
    public ApiResult logout(String str, ApiRequestHeader header) {
        //验证userId,loginName,token,deviceType,deviceId,appType 是否一致
        ApiRequestHeader requestHeader = getHeader(header);
        if (!(header.equals(requestHeader))) {
            return ApiResult.errorToken("验证userId,loginName,token,deviceType,deviceId,appType 不一致");
        }

        try {
            UserLoginInfo queryUserLoginInfo = userLoginInfoService.selectUserLoginInfoById(Long.valueOf(header.userId));
            queryUserLoginInfo.setUpdateBy(header.loginName);
            queryUserLoginInfo.setUpdateTime(DateUtils.getNowDate());
            queryUserLoginInfo.setToken("-1");
            queryUserLoginInfo.setDeviceType(header.deviceType);
            queryUserLoginInfo.setDeviceId(header.deviceId);
            queryUserLoginInfo.setAppType(header.appType);
            queryUserLoginInfo.setRemark("该账号已于" + DateUtils.getTime() + "退出登录");
            userLoginInfoService.updateUserLoginInfo(queryUserLoginInfo);
            return ApiResult.success("退出登录成功", queryUserLoginInfo);
        } catch (Exception e) {
            return ApiResult.error("异常");
        }
    }


    /**
     * 客户端修改密码
     *
     * @param str
     * @param header
     * @return
     */
    public ApiResult resetPwd(String str, ApiRequestHeader header) {
        //验证userId,loginName,token,deviceType,deviceId,appType 是否一致
        ApiRequestHeader requestHeader = getHeader(header);
        if (!(header.equals(requestHeader))) {
            return ApiResult.errorToken("验证userId,loginName,token,deviceType,deviceId,appType 不一致");
        }
        try {
            Map<String, String> parameters = new ObjectMapper().readValue(str, HashMap.class);
            String oldPassword = parameters.get("oldPassword");//旧密码
            String newPassword = parameters.get("newPassword");//新密码
            if(StringUtils.isEmpty(newPassword)){
                return ApiResult.error("新密码不能为空");
            }
            if(!RegexUtil.isPassword(newPassword)){
                return ApiResult.error("密码无效。密码必须包含至少一个大写字母、一个小写字母和一个数字，并且至少10个字符长。");
            }
            User user = userService.selectUserById(Long.valueOf(header.userId));
            if (StringUtils.isNotEmpty(oldPassword)) {
                if (StringUtils.isNotEmpty(newPassword)) {
                    if (passwordService.matches(user, oldPassword)) {
                        user.setPassword(newPassword);
                        if (userService.resetUserPwd(user) > 0) {
                            return ApiResult.success("修改密码成功");
                        }
                        return ApiResult.error("修改密码失败");
                    } else {
                        return ApiResult.error("修改密码失败，旧密码错误");
                    }
                } else {
                    return ApiResult.error("修改密码失败，新密码不能为空");
                }
            } else {
                return ApiResult.error("修改密码失败，旧密码不能为空");
            }
        } catch (Exception e) {
            return ApiResult.error("异常");
        }
    }


    /**
     * 未执行任务 数量
     *
     * @param str
     * @param header
     * @return
     */
    public ApiResult getTaskCount(String str, ApiRequestHeader header) {
        //验证userId,loginName,token,deviceType,deviceId,appType 是否一致
        ApiRequestHeader requestHeader = getHeader(header);
        if (!(header.equals(requestHeader))) {
            return ApiResult.errorToken("验证userId,loginName,token,deviceType,deviceId,appType 不一致");
        }
        try {
            Map<String, String> parameters = new ObjectMapper().readValue(str, HashMap.class);
            String companyIdTemp = parameters.get("companyId");//公司ID

            Long companyId = Long.valueOf(companyIdTemp);
            Long userId = Long.valueOf(header.userId);

            int identityCount = reportMapper.selectRiskIdentityCount(companyId, userId);
            int evaluationCount = reportMapper.selectRiskEvaluationCount(userId);
            int reviewCount = reportMapper.selectRiskReviewCount(userId);
            int troubleCheckCount = reportMapper.selectTroubleCheckCount(userId);
            int troubleReportCount = reportMapper.selectTroubleReportCount(userId);
            int troubleExamineCount = reportMapper.selectTroubleExamineCount(userId);
            int troubleRectifyCount = reportMapper.selectTroubleRectifyCount(userId);
            int troubleAcceptCount = reportMapper.selectTroubleAcceptCount(userId);
            HashMap<String, Object> map = new HashMap<>();
            map.put("identityCount", identityCount);
            map.put("evaluationCount", evaluationCount);
            map.put("reviewCount", reviewCount);
            map.put("troubleCheckCount", troubleCheckCount);
            map.put("troubleReportCount", troubleReportCount);
            map.put("troubleExamineCount", troubleExamineCount);
            map.put("troubleRectifyCount", troubleRectifyCount);
            map.put("troubleAcceptCount", troubleAcceptCount);
            HiddenDangerCheck hiddenDangerCheck = new HiddenDangerCheck();
            hiddenDangerCheck.setScheduleCheckUserId(Long.valueOf(header.userId));//定时任务排查执行人
            hiddenDangerCheck.setScheduleCheckStatus("0");//定时任务排查状态（未排查）
            List<HiddenDangerCheck> resultList = hiddenDangerCheckService.selectHiddenDangerCheckList(hiddenDangerCheck);
            map.put("troubleScheduleCount",resultList.size());//定时任务未处理数量
            map.put("troubleTotal", troubleCheckCount+troubleReportCount+troubleExamineCount+troubleRectifyCount+troubleAcceptCount+resultList.size());//隐患模块未执行总数量

            //全年整改数和全年整改率 start
            HiddenDangerCheckPoint rectifyThisYear = new HiddenDangerCheckPoint();
            Calendar cal = Calendar.getInstance();
            int year = cal.get(Calendar.YEAR);
            String beginTime = year+"-01-01";
            SimpleDateFormat matter1=new SimpleDateFormat("yyyy-MM-dd");
            String endTime =  matter1.format(new Date());
            Map params = new HashMap();
            params.put("beginTime",beginTime);
            params.put("endTime",endTime);
            rectifyThisYear.setParams(params);
            rectifyThisYear.setRectifyUserIdIsNotNull("1");//隐患整改人ID  不为空
            rectifyThisYear.setCompanyId(companyId);
            List<HiddenDangerCheckPoint> rectifyThisYearList = hiddenDangerCheckPointService.selectHiddenDangerCheckPointList(rectifyThisYear);

            int thisYearRectifyNum = 0;//全年整改数
            for (HiddenDangerCheckPoint hdcp : rectifyThisYearList) {
                if (!StringUtils.isEmpty(hdcp.getStage())) {
                    if ("5".equals(hdcp.getStage())) {
                        if (!StringUtil.isEmpty(hdcp.getAcceptStatus())) {
                            thisYearRectifyNum++;
                        }
                    }
                }
            }
            int thisYearDangerNum = rectifyThisYearList.size();
            String thisYearRectifyRate = "100%";//全年整改率
            if (thisYearDangerNum > 0) {
                //计算整改率
                BigDecimal a = ApiHiddenDangerCheckService.divide(thisYearRectifyNum, thisYearDangerNum, 4);
                //下面将结果转化成百分比
                NumberFormat percent1 = NumberFormat.getPercentInstance();
                percent1.setMaximumFractionDigits(2);
                thisYearRectifyRate = percent1.format(a.doubleValue());
            }
            map.put("thisYearRectifyNum", thisYearRectifyNum);
            map.put("thisYearRectifyRate", thisYearRectifyRate);
            //全年整改数和全年整改率 end

            return ApiResult.success("获取数据成功", map);
        } catch (Exception e) {
            return ApiResult.error("异常");
        }
    }



    /**
     * 获取极光推送列表
     *
     * @param str
     * @param header
     * @return
     */
    public ApiResult getJpushMsgList(String str, ApiRequestHeader header) {
        //验证userId,loginName,token,deviceType,deviceId,appType 是否一致
        ApiRequestHeader requestHeader = getHeader(header);
        if (!(header.equals(requestHeader))) {
            return ApiResult.errorToken("验证userId,loginName,token,deviceType,deviceId,appType 不一致");
        }
        try {
            JpushMsg jpushMsg = new ObjectMapper().readValue(str, JpushMsg.class);
            jpushMsg.setUserId(header.userId);
            List<JpushMsg> jpushMsgList = jpushMsgService.selectJpushMsgList(jpushMsg);
            return ApiResult.success("获取数据成功", jpushMsgList);
        } catch (Exception e) {
            return ApiResult.error("异常");
        }
    }

}