package com.ruoyi.station.service.impl;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.ruoyi.common.exception.BusinessException;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.IdUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.security.Md5Utils;
import com.ruoyi.station.domain.MjDept;
import com.ruoyi.station.domain.MjTeamMember;
import com.ruoyi.station.domain.MjWorkOrder;
import com.ruoyi.station.mapper.*;
import com.ruoyi.station.model.CountModel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ruoyi.station.domain.MjWorkUser;
import com.ruoyi.station.service.IMjWorkUserService;
import com.ruoyi.common.core.text.Convert;

/**
 * 工作人员Service业务层处理
 *
 * @author ruoyi
 * @date 2020-08-07
 */
@Service
@Slf4j
public class MjWorkUserServiceImpl implements IMjWorkUserService
{
    @Autowired
    private MjWorkUserMapper mjWorkUserMapper;

    @Autowired
    private MjDeptMapper mjDeptMapper;

    @Autowired
    private MjFingerprintMapper fingerprintMapper;

    @Autowired
    private MjWorkOrderMapper mjWorkOrderMapper;

    @Autowired
    private MjTeamMemberMapper mjTeamMemberMapper;
    /**
     * 查询工作人员
     *
     * @param id 工作人员ID
     * @return 工作人员
     */
    @Override
    public MjWorkUser selectMjWorkUserById(Long id)
    {

        MjWorkUser mjWorkUser = mjWorkUserMapper.selectMjWorkUserById(id);
        return  mjWorkUser;
    }

    /**
     * 查询工作人员列表
     *
     * @param mjWorkUser 工作人员
     * @return 工作人员
     */
    @Override
    public List<MjWorkUser> selectMjWorkUserList(MjWorkUser mjWorkUser)
    {

        if(mjWorkUser != null && (mjWorkUser.getDeptId()==null||"".equals(mjWorkUser.getDeptId())
                ||mjWorkUser.getDeptParentId()==null||"".equals(mjWorkUser.getDeptParentId()))){
            List<MjWorkUser> mjWorkUsers = mjWorkUserMapper.selectMjWorkUserListAll(mjWorkUser);
            for (MjWorkUser workUser : mjWorkUsers) {
                int count = fingerprintMapper.selectCountByUserId(workUser.getId().toString());
                workUser.setTempDataCount(count);
            }
            return mjWorkUsers;
        }else {
            List<MjWorkUser> mjWorkUsers = mjWorkUserMapper.selectMjWorkUserList(mjWorkUser);
            /*List<MjWorkUser> list = mjWorkUsers.parallelStream()
                    .filter(mjWorkUser1 -> mjWorkUser1.getDelFlag() == 0)
                    .collect(Collectors.toList());*/
            for (MjWorkUser workUser : mjWorkUsers) {
                int count = fingerprintMapper.selectCountByUserId(workUser.getId().toString());
                workUser.setTempDataCount(count);
            }
            return mjWorkUsers;
        }
    }

    /**
     * 新增工作人员
     *
     * @param mjWorkUser 工作人员
     * @return 结果
     */
    @Override
    public int insertMjWorkUser(MjWorkUser mjWorkUser)
    {
        mjWorkUser.setCreateTime(DateUtils.getNowDate());
        mjWorkUser.setUpdateTime(DateUtils.getNowDate());
        mjWorkUser.setUserId(IdUtils.fastSimpleUUID());
        //增加部门名称
        MjDept mjDept = mjDeptMapper.selectMjDeptByIdorName(mjWorkUser.getDeptId(),mjWorkUser.getDeptName());
        mjWorkUser.setDeptId(mjDept.getId());
        mjWorkUser.setDeptName(mjDept.getDeptName());
        mjWorkUser.setPass(Md5Utils.hash(mjWorkUser.getPass()));
        if(mjWorkUser.getDelFlag()==null){
            mjWorkUser.setDelFlag(0);
        }
        return mjWorkUserMapper.insertMjWorkUser(mjWorkUser);
    }

    /**
     * 修改工作人员
     *
     * @param mjWorkUser 工作人员
     * @return 结果
     */
    @Override
    public int updateMjWorkUser(MjWorkUser mjWorkUser)
    {
        mjWorkUser.setUpdateTime(DateUtils.getNowDate());
        //增加部门名称
        MjDept mjDept = mjDeptMapper.selectMjDeptByIdorName(mjWorkUser.getDeptId(),mjWorkUser.getDeptName());
        mjWorkUser.setDeptId(mjDept.getId());
        mjWorkUser.setDeptName(mjDept.getDeptName());
        mjWorkUser.setPass(Md5Utils.hash(mjWorkUser.getPass()));
        return mjWorkUserMapper.updateMjWorkUser(mjWorkUser);
    }

    /**
     * 删除工作人员对象
     *
     * @param ids 需要删除的数据ID
     * @return 结果
     */
    @Override
    public int deleteMjWorkUserByIds(String ids)
    {
        int count=0;
        String[] strings = Convert.toStrArray(ids);
        for (String string : strings) {
            MjWorkUser mjWorkUser = mjWorkUserMapper.selectMjWorkUserById(Long.parseLong(string));
            mjWorkUser.setDelFlag(1);
            mjWorkUserMapper.updateMjWorkUser(mjWorkUser);
            count++;
        }
        return count;
    }

    /**
     * 删除工作人员信息
     *
     * @param id 工作人员ID
     * @return 结果
     */
    @Override
    public int deleteMjWorkUserById(Long id)
    {

        MjWorkUser mjWorkUser = mjWorkUserMapper.selectMjWorkUserById(id);
        mjWorkUser.setDelFlag(1);
        return mjWorkUserMapper.updateMjWorkUser(mjWorkUser);
    }

    @Override
    public String importUser(List<MjWorkUser> userList, boolean isUpdateSupport, String operName) {
        if (StringUtils.isNull(userList) || userList.size() == 0)
        {
            throw new BusinessException("导入用户数据不能为空！");
        }
        int successNum = 0;
        int failureNum = 0;
        StringBuilder successMsg = new StringBuilder();
        StringBuilder failureMsg = new StringBuilder();
        //String password = configService.selectConfigByKey("sys.user.initPassword");
        for (MjWorkUser user : userList)
        {
            try
            {
                // 验证是否存在这个用户
                List<MjWorkUser> userList1 = mjWorkUserMapper.selectUserByLoginName(user.getUserName());
                if (userList1.size()==0)
                {
                    //user.setPass(Md5Utils.hash(user.getUserName() + password));
                    user.setCreateBy(operName);
                    MjDept mjDept = mjDeptMapper.selectMjDeptByIdorName(user.getDeptId(),null);
                    if(!mjDept.getDeptName().equals(user.getDeptName())){
                        failureNum++;
                        failureMsg.append("<br/>" + failureNum + "、账号 " + user.getUserName() + " 部门id和名称不匹配");
                    }
                    this.insertMjWorkUser(user);
                    successNum++;
                    successMsg.append("<br/>" + successNum + "、账号 " + user.getUserName() + " 导入成功");
                }
               /* else if (isUpdateSupport)
                {
                    user.setUpdateBy(operName);
                    this.updateMjWorkUser(user);
                    successNum++;
                    successMsg.append("<br/>" + successNum + "、账号 " + user.getUserName() + " 更新成功");
                }*/
                else
                {
                    failureNum++;
                    failureMsg.append("<br/>" + failureNum + "、账号 " + user.getUserName() + " 已存在");
                }
            }
            catch (Exception e)
            {
                failureNum++;
                String msg = "<br/>" + failureNum + "、账号 " + user.getUserName() + " 导入失败：";
                failureMsg.append(msg + e.getMessage());
                log.error(msg, e);
            }
        }
        if (failureNum > 0)
        {
            failureMsg.insert(0, "很抱歉，导入失败！共 " + failureNum + " 条数据格式不正确，错误如下：");
            throw new BusinessException(failureMsg.toString());
        }
        else
        {
            successMsg.insert(0, "恭喜您，数据已全部导入成功！共 " + successNum + " 条，数据如下：");
        }
        return successMsg.toString();
    }

    /**
     * 获取用户数量
     */
    @Override
    public Integer selectWorkUserCount() {

        return mjWorkUserMapper.selectWorkUserCount();
    }

    /**
     * 获取用户授权方式
     * @return
     */
    @Override
    public Map<String, Object> getWorkUserAuthorizationType(List<MjWorkUser> mjWorkUserList) {
        Integer monthCount = null;
        int longAuth = 0; //长期授权
        int shortAuth = 0; //短期授权
        int ERPAuth = 0; //ERP授权
        if(mjWorkUserList != null && mjWorkUserList.size() > 0) {
            for(MjWorkUser mjWorkUser : mjWorkUserList) {
                if(mjWorkUser != null) {
                    MjWorkOrder mjWorkOrder = mjWorkOrderMapper.selectValidOrderByUserId(mjWorkUser.getId());
                    if(mjWorkOrder != null && mjWorkOrder.getStartTime() != null && mjWorkOrder.getEndTime() != null) {
                        shortAuth++;
                        /*try {
                            monthCount = monthsBetween(mjWorkOrder.getStartTime(), mjWorkOrder.getEndTime()); //获取工单有效月份
                            if(monthCount != null) {
                                if(monthCount >= 12) {  //判断有效年份是否超过一年，超过则为长期授权否则短期授权
                                    longAuth++;
                                }else {
                                    shortAuth++;
                                }
                            }
                        }catch (ParseException e) {
                            e.printStackTrace();
                            return null;
                        }*/
                    }
                }
            }
        }

        //长期
        int count = mjTeamMemberMapper.selectCountMember();
        //临时授权
        int temporary = mjWorkOrderMapper.selectCountTemporary();
        //工作票
        int erp = mjWorkOrderMapper.selectCountERP();
        //总数
        int num = count + temporary + erp;

        List<CountModel> list = new ArrayList<>();

        CountModel model= new CountModel();
        model.setValue(count).setName("长期授权");
        CountModel model1= new CountModel();
        model1.setValue(temporary).setName("临时授权");
        CountModel model2= new CountModel();
        model2.setValue(erp).setName("工作票授权");

        list.add(model);
        list.add(model1);
        list.add(model2);
        System.out.println(list);

        List<MjTeamMember> mjTeamMembers = mjTeamMemberMapper.selectMjTeamMemberList(null);
        if(mjTeamMembers != null && mjTeamMembers.size() > 0) {
            longAuth = mjTeamMembers.size();
        }
        Map<String, Object> map = new HashMap<>();
        map.put("longAuth", longAuth);
        map.put("shortAuth", shortAuth);
        map.put("ERPAuth", ERPAuth);
        map.put("model", list);
        map.put("num", num);
        return map;
    }

    @Override
    public int monthsBetween(Date start, Date end) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Calendar startDate = Calendar.getInstance();
        Calendar endDate = Calendar.getInstance();
        startDate.setTime(sdf.parse(sdf.format(start)));
        endDate.setTime(sdf.parse(sdf.format(end)));
        int result = yearsBetween(sdf.format(start), sdf.format(end)) * 12 + endDate.get(Calendar.MONTH) - startDate.get(Calendar.MONTH);
        return result == 0 ? 1 : Math.abs(result);

    }

    @Override
    public String getUserName(Long userId) {
        return mjWorkUserMapper.getUserName(userId);
    }

    @Override
    public List<String> getUserNames(List<Long> userIds) {
        return mjWorkUserMapper.getUserNames(userIds);
    }

    public int yearsBetween(String start, String end) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Calendar startDate = Calendar.getInstance();
        Calendar endDate = Calendar.getInstance();
        startDate.setTime(sdf.parse(start));
        endDate.setTime(sdf.parse(end));
        return (endDate.get(Calendar.YEAR) - startDate.get(Calendar.YEAR));
    }
}