package com.moral.api.service.impl;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.ObjectUtils;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;

import javax.swing.text.AbstractDocument;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.moral.api.entity.Allocation;
import com.moral.api.entity.ApproveTable;
import com.moral.api.entity.ResponsibilityUnit;
import com.moral.api.entity.SysDictData;
import com.moral.api.entity.SysDictType;
import com.moral.api.mapper.AllocationMapper;
import com.moral.api.mapper.ApproveTableMapper;
import com.moral.api.mapper.ResponsibilityUnitMapper;
import com.moral.api.mapper.SysAreaMapper;
import com.moral.api.mapper.SysDictDataMapper;
import com.moral.api.mapper.SysDictTypeMapper;
import com.moral.api.pojo.dto.allocation.AllocationUnitDto;
import com.moral.api.service.AllocationService;
import com.moral.constant.Constants;
import com.moral.constant.RedisConstants;
import com.moral.util.DateUtils;
import com.moral.util.TokenUtils;


@Service
@Slf4j
public class AllocationServiceImpl extends ServiceImpl<AllocationMapper, Allocation> implements AllocationService {

    @Autowired
    private SysDictTypeMapper sysDictTypeMapper;
    @Autowired
    private SysDictDataMapper sysDictDataMapper;
    @Autowired
    private ResponsibilityUnitMapper responsibilityUnitMapper;
    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private AllocationMapper allocationMapper;
    @Autowired
    private ApproveTableMapper approveTableMapper;

    /**
     * 根据字典类型获取字典数据
     * @param dictType
     * @return
     */
    @Override
    public List<Map<String, Object>> sysDictData(String dictType) {
        QueryWrapper<SysDictType> typeQueryWrapper = new QueryWrapper<>();
        typeQueryWrapper.select("id").eq("name", dictType);
        SysDictType sysDictType = sysDictTypeMapper.selectOne(typeQueryWrapper);
        QueryWrapper<SysDictData> dataQueryWrapper = new QueryWrapper<>();
        dataQueryWrapper.select("dataKey", "dataValue").eq("dict_type_id", sysDictType.getId()).eq("is_delete", Constants.NOT_DELETE);
        return sysDictDataMapper.selectMaps(dataQueryWrapper);
    }

    /**
     * 查询责任主体
     * @return
     */
    @Override
    public List<ResponsibilityUnit> seleteUnit() {
        QueryWrapper<ResponsibilityUnit> wrapper = new QueryWrapper<>();
        wrapper.select("unit_name","unit_id");
        wrapper.eq("is_del",Constants.NOT_DELETE);
        wrapper.eq("state",0);
        wrapper.eq("is_invalid",0);
        //获取用户信息
        Map<String, Object> userInfo = (Map<String, Object>) TokenUtils.getUserInfo();
        Object code = userInfo.get("code");
        if (!ObjectUtils.isEmpty(code)){
            wrapper.eq("area_code",code);
        }
        List<ResponsibilityUnit> responsibilityUnits = responsibilityUnitMapper.selectList(wrapper);
        return responsibilityUnits;
    }


    /**
     * 添加交办单
     * @param allocation
     * @return
     */
    @Override
    @Transactional
    public Integer insertAllocation(Allocation allocation) {
        ApproveTable approveTable = new ApproveTable();
        //获取用户信息
        Map<String, Object> userInfo = (Map<String, Object>) TokenUtils.getUserInfo();
        String dateString = DateUtils.dateToDateString(new Date(), DateUtils.yyyyMMdd_EN);
        QueryWrapper<Allocation> wrapper = new QueryWrapper<>();
        Object o = redisTemplate.opsForValue().get(RedisConstants.JBD_DATA);
        int i;
        if (ObjectUtils.isEmpty(o)){
            wrapper.last("limit 1");
            Allocation selectOne = allocationMapper.selectOne(wrapper);
            String allocationNum = selectOne.getAllocationNum();
            String num = allocationNum.substring(10);
             i = Integer.parseInt(num)+1;
        }else {
             i = Integer.parseInt(o.toString()) + 1;
        }
        //单号
        String allocationNum = "JBD" + dateString + String.format("%04d", i);
        allocation.setAllocationNum(allocationNum);
        allocation.setIsDel("0");
        allocation.setIsInvalid("0");
        allocation.setCreateId(Integer.parseInt(userInfo.get("userId").toString()));
        allocation.setCreateTime(new Date());
        allocation.setCreateName(userInfo.get("account").toString());
        allocation.setUpdateId(Integer.parseInt(userInfo.get("userId").toString()));
        allocation.setUpdateTime(new Date());
        allocation.setUpdateName(userInfo.get("account").toString());
        //获取新建图片
        allocationMapper.insert(allocation);

        redisTemplate.opsForValue().set(RedisConstants.JBD_DATA,i);
        //添加流程数据
        approveTable.setRelationId(allocation.getAllocationId());
        approveTable.setState(Integer.parseInt(allocation.getState()));
        approveTable.setApproveModule(null);
        approveTable.setStateName(null);
        approveTable.setIsDel(0);
        approveTableMapper.insert(approveTable);
        return null;
    }


    /**
     * 查看表单
     * @param id
     * @return
     */
    @Override
    public AllocationUnitDto check(Integer id) {
        AllocationUnitDto allocationUnitDto = new AllocationUnitDto();
        Allocation allocation = allocationMapper.selectById(id);
        BeanUtils.copyProperties(allocation,allocationUnitDto);
        ResponsibilityUnit responsibilityUnit = responsibilityUnitMapper.selectById(allocation.getUnitId());
        allocationUnitDto.setUnitName(responsibilityUnit.getUnitName());
        allocationUnitDto.setEscalationUnitName(responsibilityUnit.getUnitName());
        Map<String, List<SysDictData>> map = (Map<String, List<SysDictData>>) redisTemplate.opsForValue().get(RedisConstants.DICT_DATA_KEY);
        List<SysDictData> contaminate = map.get("contaminate");
        for (SysDictData sysDictData : contaminate) {
            if (sysDictData.getDataKey().equals(allocation.getPolluteType().toString())){
                allocationUnitDto.setPolluteTypeName(sysDictData.getDataValue());
                break;
            }
        }
        allocationUnitDto.setChangeTypeName(allocation.getChangeType()==0?"限期整改":"立即整改");
        allocationUnitDto.setInvestigationTypeName(allocation.getChangeType()==0?"现场":"无人机");

        //获取图片
        return allocationUnitDto;
    }

    /**
     * 修改交办单
     * @param allocation
     */
    @Override
    public void updateAll(Allocation allocation) {
        //获取用户信息
        Map<String, Object> userInfo = (Map<String, Object>) TokenUtils.getUserInfo();
        if (allocation.getState().equals("1")){
            //获取整改图片
            allocation.setChangeTime(new Date());
        }else {
            //获取审核图片
            allocation.setCheckTime(new Date());
        }
        allocation.setUpdateId(Integer.parseInt(userInfo.get("userId").toString()));
        allocation.setUpdateTime(new Date());
        allocation.setUpdateName(userInfo.get("account").toString());
        allocationMapper.updateById(allocation);
    }


    /**
     * 根据条件查询
     * @param map
     * @return
     */
    @Override
    public List<Allocation> selectAll(Map<String, Object> map) {

        Object unitId = map.get("unitId");
        Object state = map.get("state");
        Object polluteType = map.get("polluteType");
        Object investigationType = map.get("investigationType");
        Object changeType = map.get("changeType");
        Object escalationTime = map.get("escalationTime");
        Object isInvalid = map.get("isInvalid");
//        int page = Integer.parseInt(map.get("page").toString());
//        int size = Integer.parseInt(map.get("size").toString());
        QueryWrapper<Allocation> wrapper = new QueryWrapper<>();

        //责任主体
        if (!ObjectUtils.isEmpty(unitId)){
            wrapper.eq("unit_id",Integer.parseInt(unitId.toString()));
        }
        //流程状态
        if (!ObjectUtils.isEmpty(state)){
            wrapper.eq("state",Integer.parseInt(state.toString()));
        }
        //污染分类
        if (!ObjectUtils.isEmpty(polluteType)){
            wrapper.eq("pollute_type",Integer.parseInt(polluteType.toString()));
        }
        //排查方式
        if (!ObjectUtils.isEmpty(investigationType)){
            wrapper.eq("investigation_type",Integer.parseInt(investigationType.toString()));
        }
        //整改类型
        if (!ObjectUtils.isEmpty(changeType)){
            wrapper.eq("change_type",Integer.parseInt(changeType.toString()));
        }
        //是否作废
        if (!ObjectUtils.isEmpty(isInvalid)){
            wrapper.eq("is_invalid",Integer.parseInt(isInvalid.toString()));
        }
        if (!ObjectUtils.isEmpty(escalationTime)){
//            wrapper.eq("is_invalid",Integer.parseInt(isInvalid.toString()));
        }
        List<Allocation> allocations = allocationMapper.selectList(wrapper);
        ArrayList<AllocationUnitDto> rsList = new ArrayList<>();
        for (Allocation allocation : allocations) {
            AllocationUnitDto allocationUnitDto = new AllocationUnitDto();
            BeanUtils.copyProperties(allocation,allocationUnitDto);
            allocation.getEscalationTime();
            Date dateOfDay = DateUtils.getDateOfDay(allocation.getEscalationTime(), allocation.getChangeDay());
            Date date = new Date();
            //获取两个日期的天数
            int days = DateUtils.getDays(dateOfDay, date);
            allocationUnitDto.setChangeDay(days);
            rsList.add(allocationUnitDto);
        }
        return null;
    }
}