package com.javaweb.platform.controller;


import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.TreeSet;
import java.util.stream.Collectors;

import javax.servlet.http.HttpServletRequest;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import com.javaweb.platform.constant.ApplyStatus;
import com.javaweb.platform.constant.DrillType;
import com.javaweb.platform.domain.FrontUser;
import com.javaweb.platform.domain.HoleInfo;
import com.javaweb.platform.domain.HoleRecord;
import com.javaweb.platform.domain.LayerInfo;
import com.javaweb.platform.domain.Point;
import com.javaweb.platform.domain.ProjectApply;
import com.javaweb.platform.domain.ProjectApplyHole;
import com.javaweb.platform.domain.ProjectInfo;
import com.javaweb.platform.domain.ReturnInfo;
import com.javaweb.platform.domain.SampleInfo;
import com.javaweb.platform.domain.StageInfo;
import com.javaweb.platform.domain.TestInfo;
import com.javaweb.platform.domain.UserMsg;
import com.javaweb.platform.mapper.LayerInfoMapper;
import com.javaweb.platform.mapper.ProjectInfoMapper;
import com.javaweb.platform.mapper.UserMsgMapper;
import com.javaweb.platform.service.IProjectApplyService;
import com.javaweb.platform.service.IProjectInfoService;
import com.javaweb.platform.service.IReturnInfoService;
import com.javaweb.platform.service.ISampleInfoService;
import com.javaweb.platform.service.IStageInfoService;
import com.javaweb.platform.service.ITestInfoService;
import com.javaweb.platform.service.IHoleInfoService;
import com.javaweb.platform.service.IHoleRecordService;
import com.javaweb.platform.service.ILayerInfoService;
import com.javaweb.platform.service.IProjectApplyHoleService;
import com.javaweb.platform.utils.TdtUtils;
import com.javaweb.platform.utils.UserAuthCacheUtils;
import com.javaweb.common.annotation.UserAuth;
import com.javaweb.common.core.controller.BaseController;
import com.javaweb.common.core.domain.AjaxResult;
import com.javaweb.common.utils.IdGenerate;
import com.javaweb.common.utils.StringUtils;
import com.javaweb.hydrology.domain.HydrologyHoleInfo;
import com.javaweb.hydrology.mapper.HydrologyHoleInfoMapper;
import com.javaweb.hydrology.service.impl.HydrologyHoleInfoServiceImpl;

/**
 * @author zmk
 * @date 2022-03-08
 */
@Controller
@RequestMapping("/webgis")
public class WebGisController extends BaseController
{


	@Autowired
	private IProjectInfoService projectInfoService;
	
	@Autowired
	private ProjectInfoMapper projectInfoMapper;
	
	@Autowired
	private IProjectApplyService projectApplyService;
	
	@Autowired
	private IHoleInfoService holeInfoService;
	
	@Autowired
	private IHoleRecordService holeRecordService;
	
    @Autowired
    private ILayerInfoService layerInfoService;
    @Autowired
    private ISampleInfoService sampleInfoService;
    @Autowired
    private ITestInfoService testInfoService;
    @Autowired
    private IStageInfoService stageInfoService;
    @Autowired
    private IReturnInfoService returnInfoService;
    
    
    @Autowired
    private IProjectApplyHoleService projectApplyHoleService;
    

    /**
     * 矩形查询  多边形查询
     * @param points
     * @return
     */
	@PostMapping("/polygonQuery")
	@ResponseBody
	public List<ProjectInfo> polygonQuery(@RequestBody List<Point> points) {
		
		String polygon = "";
		StringBuffer sBuffer = new StringBuffer();
		for (Point point : points) {
			sBuffer.append(point.getLng()).append(" ").append(point.getLat()).append(",");
		}
		String lnglat = sBuffer.toString();
		lnglat = lnglat.substring(0, lnglat.length() - 1);

		
		polygon = "POLYGON((" + lnglat + "))";
		List<ProjectInfo> list = projectInfoService.selectByPolygon(polygon);

		return list;
	}
	/**
	 * 圆形查询
	 * @param lat
	 * @param lng
	 * @param radius
	 * @return
	 */
	@PostMapping("/cicleQuery")
	@ResponseBody
	public List<ProjectInfo> cicleQuery(Double lat,Double lng,Double radius) {
		List<ProjectInfo> list = projectInfoService.selectBynCircle(lat, lng, radius);
		return list;
	}
	
	@PostMapping("/projectQuery")
	@ResponseBody
	public List<ProjectInfo> projectQuery(@RequestBody ProjectInfo projectInfo) throws Exception {
		List<ProjectInfo> list=new ArrayList<>();
		try {
			
			list= projectInfoService.selectProjectInfoList(projectInfo);
		} catch (Exception e) {
			logger.debug(e.toString());
		}	
		return list;
	}
	/**
	 * 項目信息
	 * @param id
	 * @return
	 */
	@PostMapping("/ProjectInfo")
	@ResponseBody
	public ProjectInfo ProjectInfo(String id) {

		ProjectInfo info = projectInfoService.selectProjectInfoById(id);
		return info;
	}
	
	/**
	 * 钻孔信息
	 * @param id
	 * @return
	 */
	@UserAuth("frontUser")
	@PostMapping("/DrillInfo")
	@ResponseBody
	public HoleInfo DrillInfo(String id,HttpServletRequest request) {
		String token =request.getParameter("token");
		if(token==null || !UserAuthCacheUtils.userCaches.containsKey(token)){
			return null;
		}
		HoleInfo info = holeInfoService.selectHoleInfoById(id);
		return info;
	}
	
	/**
	 * 申请钻孔
	 * @param apply
	 * @return
	 */
	@UserAuth("frontUser")
	@PostMapping("/apply")
	@ResponseBody
	public AjaxResult apply(@RequestBody ProjectApply apply,HttpServletRequest request) {
		try {
			String token =request.getParameter("token");
			if(token==null || !UserAuthCacheUtils.userCaches.containsKey(token)){
				return AjaxResult.error("权限认证失败，无法申请！");
			}
					
			//List<String> holeIdList = apply.getHoleIdList();
			
			List<ProjectApplyHole> applyHoles = apply.getApplyHoles();
			
			if(applyHoles.size()> ApplyStatus.applyCount){
				return AjaxResult.error("申请钻孔数量超过限制10个");
				
			}
			String  applyId ="P" + IdGenerate.nextId();		
			apply.setId(applyId);
			apply.setCreateTime(new Date());
			apply.setStatus(ApplyStatus.under_review);

			projectApplyService.insertProjectApply(apply);
			
			ProjectApplyHole applyHole=null;
			
			for(ProjectApplyHole tmp : applyHoles){
				applyHole=new ProjectApplyHole();
				applyHole.setId(IdGenerate.nextId());
				applyHole.setApplyId(applyId);
				
				applyHole.setHoleId(tmp.getHoleId());
				if(tmp.getHoleType() !=null && tmp.getHoleType().equals(DrillType.DXS.getInfo())){
					applyHole.setHoleType(DrillType.DXS.getInfo());
				}else{
					applyHole.setHoleType(DrillType.DZ.getInfo());
				}
				
				
				applyHole.setUserId(apply.getCreateBy());
				applyHole.setCreateTime(new Date());
				applyHole.setStatus(ApplyStatus.under_review);
				projectApplyHoleService.insertProjectApplyHole(applyHole);
				
			}
		} catch (Exception e) {
			logger.info(e.toString());
			return AjaxResult.error();
		}

		return AjaxResult.success();
	}
	
	 
	/**
	 * 用户申请记录
	 * @param userid
	 * @return
	 */
	@UserAuth("frontUser")
    @PostMapping("/userApplyList")
    @ResponseBody
    public List<ProjectApply> userApply(String userid,HttpServletRequest request)
    {
		String token =request.getParameter("token");
		if(token==null || !UserAuthCacheUtils.userCaches.containsKey(token)){
			return null;
		}
	    FrontUser user = (FrontUser) UserAuthCacheUtils.getCahce(token);
	    if(!user.getUserName().equals(userid)){
	    	return null;
	    }
	        
    	ProjectApply apply= new ProjectApply();
    	apply.setCreateBy(userid);
        return projectApplyService.selectProjectApplyList(apply);
    }
    /**
     * 申请记录对应的钻孔
     * @param applyId
     * @return
     */
	@UserAuth("frontUser")
    @PostMapping("/userApplyHoleList")
    @ResponseBody
    public List<ProjectApplyHole> userApplyHoleList(String applyId,HttpServletRequest request)
    {
		
		String token =request.getParameter("token");
		if(token==null || !UserAuthCacheUtils.userCaches.containsKey(token)){
			return null;
		}
		
    	ProjectApplyHole projectApplyHole=new ProjectApplyHole();
    	projectApplyHole.setApplyId(applyId);
    	List<ProjectApplyHole> holes= projectApplyHoleService.selectProjectApplyHoleListJoinHoleInfo(projectApplyHole);
    	return holes;
    	
    }
	
	@UserAuth("frontUser")
    @PostMapping("/userApproveHoleList")
    @ResponseBody
    public AjaxResult userApproveHoleList(String holeId,String userId,HttpServletRequest request)
    {
    	
    	String token =request.getParameter("token");
		if(token==null || !UserAuthCacheUtils.userCaches.containsKey(token)){
			return null;
		}
		
    	ProjectApplyHole projectApplyHole=new ProjectApplyHole();
    	projectApplyHole.setHoleId(holeId);
    	projectApplyHole.setUserId(userId);
    	projectApplyHole.setStatus(ApplyStatus.apply_approve);
    	List<ProjectApplyHole> list = projectApplyHoleService.selectProjectApplyHoleList(projectApplyHole);
    	
		int count = StringUtils.isEmpty(list) ? 0 : 1;

		AjaxResult ajaxResult=new AjaxResult();
		ajaxResult.put("count", count);
		
    	return ajaxResult;
   
    	
    }
    
    @PostMapping("/getGeocoding")
    @ResponseBody
    public AjaxResult getGeocoding() throws Exception
    {
        List<ProjectInfo> list= projectInfoMapper.selectEmptyLnglat();
        
        for(ProjectInfo info : list){
        	String address=info.getAddress();
        	List<String> lnglat=TdtUtils.getGeocoding(address);
        	info.setLat(Double.valueOf(lnglat.get(0)));
        	info.setLng(Double.valueOf(lnglat.get(1)));
        	projectInfoMapper.updateProjectInfo(info);
        	
        }
        return AjaxResult.success();
    
    }

    /**
     * 根据地名字查找 经纬度
     * @param address
     * @return
     * @throws Exception
     */
	@PostMapping("/findGeocodingByPlace")
	@ResponseBody
	public AjaxResult findGeocodingByPlace(String address) throws Exception {
		List<String> lnglat = new ArrayList<>();
		try {
			 lnglat = TdtUtils.getGeocoding(address);
		} catch (Exception e) {

		}
		return AjaxResult.success(lnglat);

	}
	
	/**
	 * 根据项目id找钻孔
	 * @param projectId
	 * @return
	 * @throws Exception
	 */
	@UserAuth("frontUser")
	@PostMapping("/findHoleByProject")
	@ResponseBody
	public List<HoleInfo> findHoleByProject(String projectId,HttpServletRequest request) throws Exception {
		String token =request.getParameter("token");
		if(token==null || !UserAuthCacheUtils.userCaches.containsKey(token)){
			return null;
		}
		HoleInfo holeInfo= new HoleInfo();
		holeInfo.setProjNo(projectId);
        return holeInfoService.selectHoleInfoList(holeInfo);
	}
	
	@UserAuth("frontUser")
	@PostMapping("/findRecordByHole")
	@ResponseBody
	public List<HoleRecord> findRecordByHole(String holeId,HttpServletRequest request) throws Exception {
		String token =request.getParameter("token");
		if(token==null || !UserAuthCacheUtils.userCaches.containsKey(token)){
			return null;
		}
		HoleRecord holeRecord= new HoleRecord();
		holeRecord.setDrillId(holeId);
        return holeRecordService.selectHoleRecordList(holeRecord);
	}
	
	@UserAuth("frontUser")
	@PostMapping("/findLayerByProjectAndHole")
	@ResponseBody
	public Map<String,Object> findLayerByProjectAndHole(String projId,String holeId,HttpServletRequest request) throws Exception {		
		String token =request.getParameter("token");
		if(token==null || !UserAuthCacheUtils.userCaches.containsKey(token)){
			return null;
		}
		String projectNo=projectInfoService.selectProjectInfoById(projId).getProjectNo();
		LayerInfo layerInfo=new LayerInfo();	
		layerInfo.setProjNo(projId);
		layerInfo.setHoleNo(holeId);
		int length=layerInfoService.selectLayerInfoList(layerInfo).size();
		Map<String,Object> map=new HashMap<String,Object>();
		map.put("projectNo", projectNo);
		map.put("length",length);
        return map;
	}
	
    /**
     * 获取钻孔信息
     * @param holeId
     * @return
     * @throws Exception
     */
    @UserAuth("frontUser")
	@PostMapping("/findHoleInfoByHoleId")
	@ResponseBody
	public Map<String,Object> findHoleInfoByHoleId(String holeId,HttpServletRequest request) throws Exception {		
    	String token =request.getParameter("token");
		if(token==null || !UserAuthCacheUtils.userCaches.containsKey(token)){
			return null;
		}
		HoleInfo holeInfo=holeInfoService.selectHoleInfoById(holeId);
		String projectId=holeInfo.getProjNo();
		ProjectInfo projectInfo=projectInfoService.selectProjectInfoById(projectId);
		
		//孔深
		LayerInfo layerInfo=new LayerInfo();
		List<LayerInfo> listLayer=new ArrayList<LayerInfo>();
		layerInfo.setHoleNo(holeId);
		listLayer.addAll(layerInfoService.selectLayerInfoList(layerInfo));
		listLayer.sort((x, y) -> Double.compare(x.getBottomDepth(), y.getBottomDepth()));
		Double holeDepth=listLayer.get(listLayer.size()-1).getBottomDepth();
		String holeInfo1="";
		String holeInfo2="";
		if(projectInfo.getProjectName()!=null&&!projectInfo.getProjectName().equals("")) {
			holeInfo1+="所属项目："+projectInfo.getProjectName();
		}
		if(holeDepth!=null&&!holeDepth.equals("")) {
			holeInfo1+="&nbsp;&nbsp;&nbsp;&nbsp;孔深："+holeDepth;
		}
		if(holeInfo.getStartDate()!=null&&!holeInfo.getStartDate().equals("")) {
			SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
			holeInfo1+="&nbsp;&nbsp;&nbsp;&nbsp;开始时间："+sdf.format(holeInfo.getStartDate());
		}
		if(projectInfo.getExprorationUnit()!=null&&!projectInfo.getExprorationUnit().equals("")) {
			holeInfo2+="勘察单位："+projectInfo.getExprorationUnit();
		}
		if(holeInfo.getHoleNo()!=null&&!holeInfo.getHoleNo().equals("")) {
			holeInfo2+="&nbsp;&nbsp;&nbsp;&nbsp;钻孔编号："+holeInfo.getHoleNo();
		}
		if(holeInfo.getEndDate()!=null&&!holeInfo.getEndDate().equals("")) {
			SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
			holeInfo2+="&nbsp;&nbsp;&nbsp;&nbsp;结束时间："+sdf.format(holeInfo.getEndDate());
		}
		Map<String,Object> map=new HashMap<String,Object>();
		map.put("holeInfo1", holeInfo1);
		map.put("holeInfo2", holeInfo2);
        return map;
	}
	
    /**
     * 绘制钻孔柱状图
     * @param holeId
     * @return
     */
    @UserAuth("frontUser")
    @RequestMapping(value = "drawHole")
    @ResponseBody
    public List<Map<Object,Object>> drawHole(String holeId,HttpServletRequest request) {
    	String token =request.getParameter("token");
		if(token==null || !UserAuthCacheUtils.userCaches.containsKey(token)){
			return null;
		}
    	List<Map<Object,Object>> mapList=new ArrayList<>();
    	//地层
    	LayerInfo layerInfo=new LayerInfo();
		List<LayerInfo> listLayer=new ArrayList<LayerInfo>();
		layerInfo.setHoleNo(holeId);
		listLayer.addAll(layerInfoService.selectLayerInfoList(layerInfo));
		listLayer=listLayer.stream().filter(v->v.getTopdepth()!=null&&v.getBottomDepth()!=null).collect(Collectors.toList());
		listLayer = listLayer.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(LayerInfo :: getBottomDepth))), ArrayList::new));
		try {
			listLayer.sort((x, y) -> Double.compare(x.getBottomDepth(), y.getBottomDepth()));
		}
		catch(Exception e) {
			System.out.print(e);
		}
		for(LayerInfo layer:listLayer) {
			Map<Object,Object> map=new HashMap<Object,Object>();
			map.put("id", layer.getId());
			map.put("type", "岩土");
			map.put("code", layer.getRecordNo());
			map.put("typeName", layer.getRockType()+'-'+layer.getRockName());
			map.put("layerName", layer.getRockName());
			map.put("begin", layer.getTopdepth());
			map.put("end", layer.getBottomDepth());
			map.put("medias",new String[0]);
			String title="";
			if(layer.getRockType()!=null&&!layer.getRockType().equals("")) {
				title+="岩土类型："+layer.getRockType()+";";
			}
			if(layer.getRockName()!=null&&!layer.getRockName().equals("")) {
				title+="岩土定名："+layer.getRockName()+";";
			}
			if(layer.getColour()!=null&&!layer.getColour().equals("")) {
				title+="颜色："+layer.getColour()+";";
			}
			if(layer.getDensity()!=null&&!layer.getDensity().equals("")) {
				title+="密实度："+layer.getDensity()+";";
			}
			if(layer.getHumidity()!=null&&!layer.getHumidity().equals("")) {
				title+="湿度："+layer.getHumidity()+";";
			}
			if(layer.getBlockDiameterRangeSmall()!=null&&!layer.getBlockDiameterRangeSmall().equals("")) {
				title+="一般粒径小："+layer.getBlockDiameterRangeSmall()+";";
			}
			if(layer.getBlockDiameterRangeBig()!=null&&!layer.getBlockDiameterRangeBig().equals("")) {
				title+="一般粒径大："+layer.getBlockDiameterRangeBig()+";";
			}
			if(layer.getBlockDiameterRangeMax()!=null&&!layer.getBlockDiameterRangeMax().equals("")) {
				title+="最大粒径："+layer.getBlockDiameterRangeMax()+";";
			}
			if(layer.getState()!=null&&!layer.getState().equals("")) {
				title+="状态："+layer.getState()+";";
			}
			if(layer.getIncluding()!=null&&!layer.getIncluding().equals("")) {
				title+="包含物："+layer.getIncluding()+";";
			}
			if(layer.getParticalShape()!=null&&!layer.getParticalShape().equals("")) {
				title+="颗粒形状："+layer.getParticalShape()+";";
			}
			if(layer.getParticalLine()!=null&&!layer.getParticalLine().equals("")) {
				title+="颗粒排列："+layer.getParticalLine()+";";
			}
			if(layer.getParticalSizeDistribution()!=null&&!layer.getParticalSizeDistribution().equals("")) {
				title+="颗粒级配："+layer.getParticalSizeDistribution()+";";
			}
			map.put("title", title);
			mapList.add(map);
		}
		//水位
    	StageInfo stageInfo=new StageInfo();		
		List<StageInfo> listStage=new ArrayList<StageInfo>();
		stageInfo.setHoleNo(holeId);
		listStage.addAll(stageInfoService.selectStageInfoList(stageInfo));
		listStage=listStage.stream().filter(v->v.getInitialWaterLevel()!=null&&v.getStaticWaterLevel()!=null).collect(Collectors.toList());
		try {
			listStage.sort((x, y) -> Double.compare(x.getInitialWaterLevel(),y.getInitialWaterLevel()));
		}
		catch(Exception e) {
			System.out.print(e);
		}
		for(StageInfo stage:listStage) {
			Map<Object,Object> map=new HashMap<Object,Object>();
			map.put("id", stage.getId());
			map.put("type", "水位");
			map.put("code", stage.getRecordNo());
			map.put("typeName", "地下水");
			map.put("begin", stage.getInitialWaterLevel());
			map.put("end", stage.getStaticWaterLevel());
			map.put("medias",new String[0]);
			String title="";
			if(stage.getInitialWaterLevel()!=null&&!stage.getInitialWaterLevel().equals("")) {
				title+="初见水位："+stage.getInitialWaterLevel()+";";
			}
			if(stage.getStaticWaterLevel()!=null&&!stage.getStaticWaterLevel().equals("")) {
				title+="稳定水位："+stage.getStaticWaterLevel()+";";
			}
			map.put("title", title);
			mapList.add(map);
		}
		try {
			mapList.sort((x, y) -> Double.compare(Double.parseDouble(x.get("begin").toString()),Double.parseDouble(y.get("begin").toString())));
		}
		catch(Exception e) {
			System.out.print(e);
		}
		//回次
		ReturnInfo returnInfo=new ReturnInfo();		
		List<ReturnInfo> listReturn=new ArrayList<ReturnInfo>();
		returnInfo.setHoleNo(holeId);
		listReturn.addAll(returnInfoService.selectReturnInfoList(returnInfo));
		listReturn=listReturn.stream().filter(v->v.getStartDepth()!=null&&v.getEndDepth()!=null).collect(Collectors.toList());
		try {
			listReturn.sort((x, y) -> Double.compare(x.getEndDepth(),y.getEndDepth()));
		}
		catch(Exception e) {
			System.out.print(e);
		}
		for(ReturnInfo return1:listReturn) {
			Map<Object,Object> map=new HashMap<Object,Object>();
			map.put("id", return1.getId());
			map.put("type", "回次");
			map.put("code", return1.getRecordNo());
			map.put("typeName", return1.getDrillMethod()+'-'+return1.getWallProtectMethod());
			map.put("begin", return1.getStartDepth());
			map.put("end", return1.getEndDepth());
			map.put("medias",new String[0]);
			String title="";
			if(return1.getDrillMethod()!=null&&!return1.getDrillMethod().equals("")) {
				title+="钻进方法："+return1.getDrillMethod()+";";
			}
			if(return1.getWallProtectMethod()!=null&&!return1.getWallProtectMethod().equals("")) {
				title+="护壁方法："+return1.getWallProtectMethod()+";";
			}
			if(return1.getBoreDiameter()!=null&&!return1.getBoreDiameter().equals("")) {
				title+="钻孔孔径："+return1.getBoreDiameter()+";";
			}
			if(return1.getStartDepth()!=null&&!return1.getStartDepth().equals("")) {
				title+="起始深度："+return1.getStartDepth()+";";
			}
			if(return1.getEndDepth()!=null&&!return1.getEndDepth().equals("")) {
				title+="终止深度："+return1.getEndDepth()+";";
			}
			map.put("title", title);
			mapList.add(map);
		}
		//取样
		SampleInfo sampleInfo=new SampleInfo();		
		List<SampleInfo> listSample=new ArrayList<SampleInfo>();
		sampleInfo.setHoleNo(holeId);
		listSample.addAll(sampleInfoService.selectSampleInfoList(sampleInfo));
		listSample=listSample.stream().filter(v->v.getSampleStartDepth()!=null&&v.getSampleEndDepth()!=null).collect(Collectors.toList());
		try {
			listSample.sort((x, y) -> Double.compare(x.getSampleEndDepth(),y.getSampleEndDepth()));
		}
		catch(Exception e) {
			System.out.print(e);
		}
		for(SampleInfo sample:listSample) {
			Map<Object,Object> map=new HashMap<Object,Object>();
			map.put("id", sample.getId());
			map.put("type", "取土");
			map.put("code",sample.getRecordNo());
			map.put("typeName", "取土");
			map.put("begin", sample.getSampleStartDepth());
			map.put("end", sample.getSampleEndDepth());
			map.put("medias",new String[0]);
			String title="";
			if(sample.getQualityLevel()!=null&&!sample.getQualityLevel().equals("")) {
				title+="土样质量等级："+sample.getQualityLevel()+";";
			}
			if(sample.getSamplingTool()!=null&&!sample.getSamplingTool().equals("")) {
				title+="取样工具和方法："+sample.getSamplingTool()+";";
			}
			map.put("title", title);
			mapList.add(map);
		}
		//测试
		TestInfo testInfo=new TestInfo();		
		List<TestInfo> listTest=new ArrayList<TestInfo>();
		testInfo.setHoleNo(holeId);
		listTest.addAll(testInfoService.selectTestInfoList(testInfo));
		try {
			listTest.sort((x, y) -> Double.compare(x.getExpectDepthStart(),y.getExpectDepthStart()));
		}
		catch(Exception e) {
			System.out.print(e);
		}
		for(TestInfo test:listTest) {
			if(test.getExpectDepthStart()!=null&&!test.getExpectDepthStart().equals("")&&test.getExpectDepthStart()!=0) {
				Map<Object,Object> map=new HashMap<Object,Object>();
				map.put("id", test.getId());
				if(test.getRecordType().equals("JL001")) {
					map.put("type", "动探");
					map.put("typeName", "动探");
				}
				else if(test.getRecordType().equals("JL013")) {
					map.put("type", "标贯");
					map.put("typeName", "标贯");
				}
				map.put("code", test.getRecordNo());
				map.put("begin", test.getExpectDepthStart());
				Double endDepth=0.0;
				if(test.getThirdDepthEnd()!=null&&!test.getThirdDepthEnd().equals("")) {
					endDepth=test.getThirdDepthEnd();
				}
				else if(test.getSecondDepthEnd()!=null&&!test.getSecondDepthEnd().equals("")) {
					endDepth=test.getSecondDepthEnd();
				}
				else if(test.getFirstDepthEnd()!=null&&!test.getFirstDepthEnd().equals("")) {
					endDepth=test.getFirstDepthEnd();
				}
				else if(test.getExpectDepthEnd()!=null&&!test.getExpectDepthEnd().equals("")) {
					endDepth=test.getExpectDepthEnd();
				}
				map.put("end", endDepth);
				map.put("medias",new String[0]);
				String title="";
				
				if(test.getPipeLenth()!=null&&!test.getPipeLenth().equals("")) {
					title+="钻杆长度："+test.getPipeLenth()+";";
				}
				if(test.getExpectDepthStart()!=null&&!test.getExpectDepthStart().equals("")&&test.getExpectHammerTimes()!=null&&!test.getExpectHammerTimes().equals("")&&test.getExpectHammerTimes()!=0) {
					title+="<br/>预："+test.getExpectDepthStart()+"m~"+test.getExpectDepthEnd()+"m="+test.getExpectHammerTimes()+";";
				}
				if(test.getFirstDepthStart()!=null&&!test.getFirstDepthStart().equals("")&&test.getFirstHammerTimes()!=null&&!test.getFirstHammerTimes().equals("")&&test.getFirstHammerTimes()!=0) {
					title+="<br/>1："+test.getFirstDepthStart()+"m~"+test.getFirstDepthEnd()+"m="+test.getFirstHammerTimes()+";";
				}
				if(test.getSecondDepthStart()!=null&&!test.getSecondDepthStart().equals("")&&test.getSecondHammerTimes()!=null&&!test.getSecondHammerTimes().equals("")&&test.getSecondHammerTimes()!=0) {
					title+="<br/>2："+test.getSecondDepthStart()+"m~"+test.getSecondDepthEnd()+"m="+test.getSecondHammerTimes()+";";
				}
				if(test.getThirdDepthStart()!=null&&!test.getThirdDepthStart().equals("")&&test.getThirdHammerTimes()!=null&&!test.getThirdHammerTimes().equals("")&&test.getThirdHammerTimes()!=0) {
					title+="<br/>3："+test.getThirdDepthStart()+"m~"+test.getThirdDepthEnd()+"m="+test.getThirdHammerTimes()+";";
				}
				map.put("title", title);
				mapList.add(map);
			}
		}
    	return mapList;
    }
    
    @Autowired
    private LayerInfoMapper LayerInfoMapper;
    
	@PostMapping("/insertDepth")
	@ResponseBody
	public void insertDepth() throws Exception {	
		HoleInfo holeInfo=new HoleInfo();
		
		List<HoleInfo> holeList=holeInfoService.selectHoleInfoList(holeInfo);
		LayerInfo layerInfo=null;
		for(HoleInfo hole:holeList) {
			try {
			    layerInfo=new LayerInfo();
				
				layerInfo.setHoleNo(hole.getId());
				Double max =LayerInfoMapper.findMaxHoleDepth(layerInfo);
		
				hole.setHoleDepth(max);
				
				holeInfoService.updateHoleInfo(hole);
			}
			catch(Exception e) {
				System.out.print(e);
			}
		}		
	}
	
	
    @RequestMapping(value = "isTokenValid")
    @ResponseBody
    public Boolean isTokenValid(String userId,HttpServletRequest request) {
    	String token =request.getParameter("token");
		if(token!=null && UserAuthCacheUtils.userCaches.containsKey(token)){
		 	FrontUser user = (FrontUser) UserAuthCacheUtils.getCahce(token);
		    if(user.getUserName().equals(userId)){
		    	return true;
		    }
		    else {
				return false;
		    }
		}
    	return false;
	}
    
    
    @Autowired
    private UserMsgMapper UserMsgMapper;
    
    /**
     * 消息列表
     * @param userid
     * @param request
     * @return
     */
	@UserAuth("frontUser")
    @PostMapping("/userMsgList")
    @ResponseBody
    public List<UserMsg> userMsgList(String userid,HttpServletRequest request)
    {
		String token =request.getParameter("token");
		if(token==null || !UserAuthCacheUtils.userCaches.containsKey(token)){
			return null;
		}
	    FrontUser user = (FrontUser) UserAuthCacheUtils.getCahce(token);
	    if(!user.getUserName().equals(userid)){
	    	return null;
	    }
	    UserMsg userMsg=new UserMsg();
	    userMsg.setUserName(userid);
	    List<UserMsg> msgs= UserMsgMapper.selectUserMsgList(userMsg)  ; 
	    return msgs;

    }
	
	
	@Autowired
	private HydrologyHoleInfoMapper hydrologyHoleInfoMapper;
	
	
	/**
	 * 水位数据列表
	 * @param userid
	 * @param request
	 * @return
	 */
	//@UserAuth("frontUser")
    @PostMapping("/hydrologyList")
    @ResponseBody
    public List<HydrologyHoleInfo> hydrologyList(String userid,HttpServletRequest request)
    {
    	List<HydrologyHoleInfo> list = hydrologyHoleInfoMapper.selectSpecificFiledList(new HydrologyHoleInfo());
	    return list;

    }
    
    @Autowired
    private HydrologyHoleInfoServiceImpl hydrologyHoleInfoServiceImpl;
    
    /**
     *地下水 折线图
     * @param userid
     * @param holeNum
     * @param request
     * @return
     */
    @PostMapping("/hydrologyChart")
    @ResponseBody
    public AjaxResult hydrologyChart(String userid,String holeNum ,HttpServletRequest request)
    {
    	AjaxResult result = hydrologyHoleInfoServiceImpl.hydrologyChart(holeNum);
    	 
	    return result;
    }
    
    
	/**
	 * 圆形查询
	 * @param lat
	 * @param lng
	 * @param radius
	 * @return
	 */
	@PostMapping("/cicleQueryDxs")
	@ResponseBody
	public List<HydrologyHoleInfo> cicleQueryDxs(Double lat,Double lng,Double radius) {
		List<HydrologyHoleInfo> list = hydrologyHoleInfoMapper.selectByCircle(lat, lng, radius);
		return list;
	}
}