package com.thhy.engineering.modules.biz.engineering.service.impl;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.github.pagehelper.util.StringUtil;
import com.thhy.engineering.modules.biz.engineering.entity.ProSunDto.*;
import com.thhy.engineering.modules.biz.engineering.entity.SysDict;
import com.thhy.engineering.modules.biz.engineering.service.SysProjectService;
import com.thhy.engineering.modules.biz.engineering.entity.SysProject;
import com.thhy.engineering.modules.biz.engineering.mapper.SysProjectMapper;
import com.thhy.general.common.BasicResult;
import com.thhy.general.config.SysUserInfo;
import com.thhy.general.utils.UserInfoUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import javax.crypto.MacSpi;
import java.text.SimpleDateFormat;
import java.util.*;

@Service
public class SysProjectServiceImpl implements SysProjectService {

    @Resource
    private SysProjectMapper projectMapper;


    @Override
    @Transactional
    public BasicResult projectInsert(Map<String, Object> values) {
        SysUserInfo sysUserInfo = UserInfoUtils.getInstance().getUserInfo();
        String companyId = sysUserInfo.getCompanyId();

        String proName = values.get("proName").toString();
        String proId = projectMapper.proNameByOne(proName);

        if(!StringUtil.isEmpty(proId)){
            BasicResult.faild("11111","error","项目名称被占用");
        }
        String proNumber ="";
        SysProject project = projectMapper.newByProject();
        if(project!=null){
            proNumber = project.getProNumber();
        }

        if(StringUtil.isEmpty(proNumber)){
            values.put("proNumber","001");
        }else {
            Integer integer = Integer.valueOf(proNumber);
            if(integer<=9){
                Integer con =(integer+1);
                if(con>9){
                    String s=("0"+con);
                    values.put("proNumber",s);
                }else {
                    String s=("00"+con);
                    values.put("proNumber",s);
                }
            }else if(integer<=99){
                Integer con =(integer+1);
                if(con>99){
                    String s=con.toString();
                    values.put("proNumber",s);
                }else {
                    String s=("0"+con);
                    values.put("proNumber",s);
                }
            }else if (integer<=999){
                Integer con =(integer+1);
                if(con>999){
                    String s=con.toString();
                    values.put("proNumber",s);
                    return BasicResult.faild("11111","error","已超过最大生成编号");
                }else {
                    String s=con.toString();
                    values.put("proNumber",s);
                }
            }
        }

        //添加
        values.put("proId","");
        values.put("companyId",companyId);
        projectMapper.projectInsert(values);
        //项目id
        String pro_id = values.get("proId").toString();
        //转向
        List<String> turns = (List<String>) values.get("turns");
            for (String turn :turns){
                HashMap<String,Object> map = new HashMap<>();
                map.put("proId",pro_id);
                map.put("turn",turn);
                projectMapper.proTurnsInsert(map);
            }
        //尺寸
        List<String> sizes = (List<String>) values.get("sizes");
            for (String sizess :sizes){
                HashMap<String,Object> map = new HashMap<>();
                map.put("id","");
                map.put("proId",pro_id);
                map.put("sizes",sizess);
                projectMapper.proSizesInsert(map);
            }
        //配筋
        List<String> hass = (List<String>) values.get("hass");
            for (String has :hass){
                HashMap<String,Object> map = new HashMap<>();
                map.put("id","");
                map.put("proId",pro_id);
                map.put("hasSteel",has);
                projectMapper.proHasInsert(map);
            }
        //注浆孔
        List<String> groutings = (List<String>) values.get("groutings");
            System.out.println("哈哈哈哈哈哈"+groutings.size());
            for (String grouting :groutings){
                System.out.println("----------"+grouting);
                HashMap<String,Object> map = new HashMap<>();
                map.put("id","");
                map.put("proId",pro_id);
                map.put("groutingHoles",grouting);
                projectMapper.proGroutingInsert(map);
            }
        //块号
        List<String> bloks = (List<String>) values.get("bloks");
            for (String blok :bloks){
                HashMap<String,Object> map = new HashMap<>();
                map.put("id","");
                map.put("proId",pro_id);
                map.put("blockNum",blok);
                projectMapper.proBlokInsert(map);
            }

        return BasicResult.success("添加成功");
    }

    @Override
    public BasicResult projectList(Map<String, Object> values) {

        SysUserInfo sysUserInfo = UserInfoUtils.getInstance().getUserInfo();
        //分公司id
        String companyId = sysUserInfo.getCompanyId();
        values.put("companyId",companyId);
        Object pageSize = values.get("pageSize");
        Object pageNum = values.get("pageNum");
        PageHelper.startPage((Integer) pageNum,(Integer) pageSize);
        List<SysProject> sysProjects = projectMapper.projectList(values);
        for (SysProject sysProject: sysProjects){
           List<SysProBlok> proBloks = projectMapper.proBlokSelect(sysProject.getProId());
           sysProject.setProBloks(proBloks);
            List<SysProGrouting> proGrouting = projectMapper.proGroutingSelect(sysProject.getProId());
            sysProject.setProGroutings(proGrouting);
            List<SysProHas> proHas = projectMapper.proHasSelect(sysProject.getProId());
            sysProject.setProHas(proHas);
            List<SysProSizes> proSizes = projectMapper.proSizesSelect(sysProject.getProId());
            sysProject.setProSizes(proSizes);
            List<SysProTurn> proTurns = projectMapper.proTurnSelect(sysProject.getProId());
            sysProject.setProTurns(proTurns);
        }
        PageInfo<SysProject> sysProjectPageInfo = new PageInfo<>(sysProjects);
        return BasicResult.success(sysProjectPageInfo);
    }

    @Override
    public BasicResult projectInfo(String proId) {
        SysProject sysProject = projectMapper.projectInfo(proId);
        List<SysProBlok> proBloks = projectMapper.proBlokSelect(sysProject.getProId());
        sysProject.setProBloks(proBloks);
        List<SysProGrouting> proGrouting = projectMapper.proGroutingSelect(sysProject.getProId());
        sysProject.setProGroutings(proGrouting);
        List<SysProHas> proHas = projectMapper.proHasSelect(sysProject.getProId());
        sysProject.setProHas(proHas);
        List<SysProSizes> proSizes = projectMapper.proSizesSelect(sysProject.getProId());
        sysProject.setProSizes(proSizes);
        List<SysProTurn> proTurns = projectMapper.proTurnSelect(sysProject.getProId());
        sysProject.setProTurns(proTurns);
        return BasicResult.success(sysProject);
    }

    @Override
    public BasicResult projectDel(String proId) {
        projectMapper.projectDel(proId);
        return BasicResult.success("删除成功");
    }

    @Override
    @Transactional
    public BasicResult projectUpdate(Map<String, Object> values) {
        projectMapper.projectUpdate(values);
        //项目id
        String proId = values.get("proId").toString();
        //删除关联表数据
        projectMapper.proBlokDel(proId);
        projectMapper.proGroutingDel(proId);
        projectMapper.proHasDel(proId);
        projectMapper.proSizesDel(proId);
        projectMapper.proTurnsDel(proId);
        //重新添加
        List<String> turns = (List<String>) values.get("turns");
        for (String turn :turns){
            HashMap<String,Object> map = new HashMap<>();
            map.put("proId",proId);
            map.put("turn",turn);
            projectMapper.proTurnsInsert(map);
        }
        //尺寸
        List<String> sizes = (List<String>) values.get("sizes");
        for (String sizess :sizes){
            HashMap<String,Object> map = new HashMap<>();
            map.put("id","");
            map.put("proId",proId);
            map.put("sizes",sizess);
            projectMapper.proSizesInsert(map);
        }
        //配筋
        List<String> hass = (List<String>) values.get("hass");
        for (String has :hass){
            HashMap<String,Object> map = new HashMap<>();
            map.put("id","");
            map.put("proId",proId);
            map.put("hasSteel",has);
            projectMapper.proHasInsert(map);
        }
        //注浆孔
        List<String> groutings = (List<String>) values.get("groutings");
        for (String grouting :groutings){
            HashMap<String,Object> map = new HashMap<>();
            map.put("id","");
            map.put("proId",proId);
            map.put("groutingHoles",grouting);
            projectMapper.proGroutingInsert(map);
        }
        //块号
        List<String> bloks = (List<String>) values.get("bloks");
        for (String blok :bloks){
            HashMap<String,Object> map = new HashMap<>();
            map.put("id","");
            map.put("proId",proId);
            map.put("blockNum",blok);
            projectMapper.proBlokInsert(map);
        }
        return BasicResult.success("修改成功");
    }

    @Override
    public BasicResult projectPull(Map<String, Object> values) {
        String proId = values.get("proId").toString();//项目id
        Integer dictType = Integer.valueOf(values.get("dictType").toString());//字典表类型
        //尺寸
        if(dictType==1){
            List<SysDict> dicts = projectMapper.projectPullSize(proId,dictType);
            return BasicResult.success(dicts);
        }else if(dictType==2){//配筋
            List<SysDict> dicts = projectMapper.projectPullReinforcement(proId,dictType);
            return BasicResult.success(dicts);
        }else if(dictType==5){//块号
            List<SysDict> dicts = projectMapper.projectPullBlock(proId,dictType);
            return BasicResult.success(dicts);
        }else {
            return BasicResult.success("没有改类型");
        }
    }

    @Override
    public BasicResult projectListPull() {
        SysUserInfo sysUserInfo = UserInfoUtils.getInstance().getUserInfo();
        String companyId = sysUserInfo.getCompanyId();
        List<ProjectPullDto> projectPullDtos = projectMapper.projectListPull(companyId);
        return BasicResult.success(projectPullDtos);
    }

    @Override
    public BasicResult projectSizeList(Map<String,Object> values) {
        SysUserInfo sysUserInfo = UserInfoUtils.getInstance().getUserInfo();
        values.put("companyId",sysUserInfo.getCompanyId());
        Integer pageSize = Integer.valueOf(values.get("pageSize").toString());
        Integer pageNum = Integer.valueOf(values.get("pageNum").toString());
        PageHelper.startPage(pageNum,pageSize);
        List<ProjectSizeDto> projectSizeDtos = projectMapper.projectSizeList(values);
        PageInfo<ProjectSizeDto> projectSizeDtoPageInfo = new PageInfo<>(projectSizeDtos);
        return BasicResult.success(projectSizeDtoPageInfo);
    }

    @Override
    public BasicResult projectProList(String proId) {
        Map<String, Object> hashMap = new HashMap<>();
        List<ProjcetHasDto> hasDtos = projectMapper.proHasList(proId);
        List<ProjectBlokDto> blokDtos = projectMapper.proBlokList(proId);
        hashMap.put("hasDtos",hasDtos);
        hashMap.put("blokDtos",blokDtos);
        return BasicResult.success(hashMap);
    }

    @Override
    public BasicResult projectSizeThingJsList(String token) {
        SysUserInfo sysUserInfo = UserInfoUtils.getInstance().getUserInfo(token);
        String companyId = sysUserInfo.getCompanyId();
        List<ProjectSizeDto> projectSizeDtos = projectMapper.projectSizeThingJsList(companyId);
        //ArrayList<Map<String, Object>> maps = new ArrayList<>();
        for (ProjectSizeDto projectSizeDto : projectSizeDtos){
            //Map<String, Object> hashMap = new HashMap<>();
            List<ProjcetHasDto> hasDtos = projectMapper.proHasList(projectSizeDto.getProId());
            List<ProjectBlokDto> blokDtos = projectMapper.proBlokList(projectSizeDto.getProId());
//            hashMap.put("projectSizeDtos",projectSizeDtos);
//            hashMap.put("hasDtos",hasDtos);
//            hashMap.put("blokDtos",blokDtos);
//            maps.add(hashMap);
            projectSizeDto.setBlokDtos(blokDtos);
            projectSizeDto.setHasDtos(hasDtos);
        }
        return BasicResult.success(projectSizeDtos);
    }

}