package com.xzx.gc.common.utils.gdmap;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.http.HttpUtil;
import cn.hutool.json.JSONArray;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.github.pagehelper.PageInfo;
import com.xzx.gc.common.Result;
import com.xzx.gc.common.constant.Constants;
import com.xzx.gc.common.dto.gdmap.*;
import com.xzx.gc.common.utils.BusinessUtil;
import com.xzx.gc.entity.AddressInfo;
import com.xzx.gc.model.dto.GdAreaDto;
import lombok.experimental.UtilityClass;
import lombok.extern.slf4j.Slf4j;

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

@UtilityClass
@Slf4j
public class GdMapUtil {


    //逆地理编码URL
    private static final String REVERSE_GEOCODING="https://restapi.amap.com/v3/geocode/regeo";
    //地理编码URL
    private static final String GEOCODING="https://restapi.amap.com/v3/geocode/geo";
    //电子围栏
    private static final String FENCE_URL="https://restapi.amap.com/v4/geofence/meta?key=";
    private static final String FENCE_STATUS_URL="https://restapi.amap.com/v4/geofence/status";
    //poi
    private static final String POI_URL="https://restapi.amap.com/v3/place/text";
    //行政区域查询
    private static final String ACODE_URL="https://restapi.amap.com/v3/config/district";
    //周边搜索
    private static final String AROUND_URL="https://restapi.amap.com/v3/place/around";

    //小区POI
    public static final String HOUSE_POI="120300";


    /**
     * 地理编码：将地址转成经纬度
     */
    public Result getLocationByAddress( GdGEODto gdReverseGEODto){
        Result result=new Result();
        Map<String, Object> stringObjectMap = BeanUtil.beanToMap(gdReverseGEODto);
        String s = HttpUtil.get(GEOCODING, stringObjectMap);
        JSONObject jsonObject = JSONUtil.parseObj(s);
        if(Constants.FAIL.equals(jsonObject.getStr("status"))){
            result.setCode(-1);
            result.setMsg(jsonObject.getStr("info"));
            log.error("地理编码失败，原因：{},key:{}",result.getMsg(),gdReverseGEODto.getKey());
        }else{
            JSONArray regeocode = jsonObject.getJSONArray("geocodes");
            if(regeocode!=null&&regeocode.size()>0){
                JSONObject jsonObject1= (JSONObject) regeocode.get(0);
                String location = jsonObject1.getStr("location");
                result.setData(location);
            }
            log.info("地理编码成功,结果：{}",result.getData());
        }
        return result;
    }

    /**
     * 批量查询
     * @param gdReverseGEODto
     * @return
     */
    public Result getBatchAreaInfo(GdReverseGEODto gdReverseGEODto){
        Result result=new Result();
        gdReverseGEODto.setBatch(true);
        Map<String, Object> stringObjectMap = BeanUtil.beanToMap(gdReverseGEODto);
        String s;
        try {
            s = HttpUtil.get(REVERSE_GEOCODING, stringObjectMap);
        } catch (Exception e) {
            log.error("逆地理编码失败，原因：{},key:{}",e.getMessage(),gdReverseGEODto.getKey());
            return Result.error(-1,"获取位置失败");
        }
        JSONObject jsonObject = JSONUtil.parseObj(s);
        if(Constants.FAIL.equals(jsonObject.getStr("status"))){
            result.setCode(-1);
            result.setMsg(jsonObject.getStr("info"));
            log.error("逆地理编码失败，原因：{},key:{}",result.getMsg(),gdReverseGEODto.getKey());
        }else{
            JSONArray regeocodes = jsonObject.getJSONArray("regeocodes");
            result.setData(regeocodes);

        }
        return result;
    }
    /**
     * 逆地理编码：将经纬度转换为详细结构化的地址，且返回附近周边的POI、AOI信息。
     * @param gdReverseGEODto  逆编码实体
     * @param level 层级  1查询省  2 查询市 3查询区信息  0查询所有
     */
    public Result getAreaInfo(GdReverseGEODto gdReverseGEODto, int level){
        Result result=new Result();
        Map<String, Object> stringObjectMap = BeanUtil.beanToMap(gdReverseGEODto);
        String s = null;
        try {
            s = HttpUtil.get(REVERSE_GEOCODING, stringObjectMap);
        } catch (Exception e) {
            log.error("逆地理编码失败，原因：{},key:{}",e.getMessage(),gdReverseGEODto.getKey());
            return Result.error(-1,"获取位置失败");
        }
        JSONObject jsonObject = JSONUtil.parseObj(s);
        if(Constants.FAIL.equals(jsonObject.getStr("status"))){
            result.setCode(-1);
            result.setMsg(jsonObject.getStr("info"));
            log.error("逆地理编码失败，原因：{},key:{}",result.getMsg(),gdReverseGEODto.getKey());
        }else{
            JSONObject regeocode = jsonObject.getJSONObject("regeocode");
            //结构化地址信息包括：省份＋城市＋区县＋城镇＋乡村＋街道＋门牌号码
            String address = regeocode.getStr("formatted_address");
            JSONObject addressComponent = regeocode.getJSONObject("addressComponent");
            String district = addressComponent.getStr("district");
            String city = addressComponent.getStr("city");
            String province = addressComponent.getStr("province");
            String citycode = addressComponent.getStr("citycode");
            String adcode = addressComponent.getStr("adcode");
            if(Convert.toInt(3)==level){
                result.setData(district);
            }else if(Convert.toInt(2)==level){
                result.setData(city);
            }else if(Convert.toInt(1)==level){
                result.setData(province);
            }else {
                AddressInfo addressInfo=new AddressInfo();
                addressInfo.setProvinceName(province);
                addressInfo.setTownshipName(district);
                addressInfo.setCityName(city);
                addressInfo.setCitycode(citycode);
                addressInfo.setAdcode(adcode);
                addressInfo.setFormatAddress(address);
                addressInfo.setLongitude(gdReverseGEODto.getLocation().split(",")[0]);
                addressInfo.setLatitude(gdReverseGEODto.getLocation().split(",")[1]);
                result.setData(addressInfo);
            }
//            log.info("逆地理编码成功,结果：{}",result.getData());
        }
        return result;
    }

    /**
     * 根据关键字搜索
     */
    public AddressInfo getLocationByPOI(GdPOIDto gdPOIDto,AddressInfo addressInfo){
        if(StrUtil.isNotBlank(addressInfo.getAdcode())){
            gdPOIDto.setCity(addressInfo.getAdcode());
        }else if(StrUtil.isNotBlank(addressInfo.getCitycode())){
            gdPOIDto.setCity(addressInfo.getCitycode());
        }else if(StrUtil.isNotBlank(addressInfo.getCityName())){
            gdPOIDto.setCity(addressInfo.getCityName());
        }else{
            gdPOIDto.setCity(Constants.CHANGSHA_CODE);
        }
        Map<String, Object> stringObjectMap = BeanUtil.beanToMap(gdPOIDto);
        String s = null;
        try {
            s = HttpUtil.get(POI_URL, stringObjectMap);
        } catch (Exception e) {
            log.error("地理关键字搜索失败，原因：{},key:{}",e.getMessage(),gdPOIDto.getKey());
            return addressInfo;
        }
        JSONObject jsonObject = JSONUtil.parseObj(s);
        if(Constants.FAIL.equals(jsonObject.getStr("status"))){
            String msg=jsonObject.getStr("info");
            log.error("地理关键字搜索失败，原因：{},key:{}",msg,gdPOIDto.getKey());
        }else{
            JSONArray regeocode = jsonObject.getJSONArray("pois");
            if(regeocode!=null&&regeocode.size()>0){
                JSONObject jsonObject1= (JSONObject) regeocode.get(0);
                String data = jsonObject1.getStr("location");
                if(StrUtil.isNotBlank(data)) {
//                    String[] split = data.split(",");
//                    addressInfo.setLongitude(   NumberUtil.roundStr(split[0],6,RoundingMode.DOWN));
//                    addressInfo.setLatitude(   NumberUtil.roundStr(split[1],6,RoundingMode.DOWN));
                }
                String pcode = jsonObject1.getStr("pcode");
                addressInfo.setPcode(pcode);
                String pname =jsonObject1.getStr("pname");
                addressInfo.setProvinceName(pname);
                String citycode =jsonObject1.getStr("citycode");
                addressInfo.setCitycode(citycode);
                String cityname =jsonObject1.getStr("cityname");
                addressInfo.setCityName(cityname);
                String adcode = jsonObject1.getStr("adcode");
                addressInfo.setAdcode(adcode);
                String adname = jsonObject1.getStr("adname");
                adname=new BusinessUtil().changeArea(adname);
                addressInfo.setTownshipName(adname);
                log.info("地理关键字搜索成功,关键字：{},结果：{}",gdPOIDto.getKeywords(),jsonObject1);
            }else {
                log.error("地理关键字搜索失败，：{}",gdPOIDto.getKeywords());
            }

        }
        return addressInfo;
    }


    /**
     * 创建围栏
     * @param createFenceDto
     * @return
     */
    public Result<String> createFence(String key,CreateFenceDto createFenceDto){
        Result result=new Result();
        String post = HttpUtil.post(FENCE_URL+key, JSONUtil.toJsonStr(createFenceDto));
        JSONObject jsonObject = JSONUtil.parseObj(post);
        Integer errcode = jsonObject.getInt("errcode");
        String errmsg = jsonObject.getStr("errmsg");
        if(errcode.intValue()==0){
            JSONObject data = jsonObject.getJSONObject("data");
            String status = data.getStr("status");
            String message = data.getStr("message");
            if(Constants.DEL_NOT_FLAG== Convert.toInt(status)){
                String gid = data.getStr("gid");
                result.setData(gid);
                result.setCode(0);
                log.info("电子围栏创建成功,ID：{}",gid);
            }else{
                result.setCode(Convert.toInt(status));
                result.setMsg(message);
                log.error("电子围栏创建失败，原因：{}",message);
            }
        }else{
            result.setCode(errcode);
            result.setMsg(errmsg);
            log.error("电子围栏创建失败，原因：{}",errmsg);
        }
        return result;
    }


    /**
     * 更新围栏
     * @param createFenceDto
     * @return
     */
    public Result<String> updateFence(CreateFenceDto createFenceDto,String key,String gid){
        Result result=new Result();
        String post = HttpUtil.post(FENCE_URL+key+"&gid="+gid+"&method=patch", JSONUtil.toJsonStr(createFenceDto));
        JSONObject jsonObject = JSONUtil.parseObj(post);
        Integer errcode = jsonObject.getInt("errcode");
        String errmsg = jsonObject.getStr("errmsg");
        if(errcode.intValue()==0){
            JSONObject data = jsonObject.getJSONObject("data");
            String status = data.getStr("status");
            String message = data.getStr("message");
            if(Constants.DEL_NOT_FLAG== Convert.toInt(status)){
                result.setCode(0);
                result.setData(gid);
                log.info("电子围栏更新成功,ID：{}",gid);

            }else{
                result.setCode(Convert.toInt(status));
                result.setMsg(message);
                log.error("电子围栏更新失败，原因：{}",message);
            }
        }else{
            result.setCode(errcode);
            result.setMsg(errmsg);
            log.error("电子围栏更新失败，原因：{}",errmsg);
        }
        return result;
    }


    /**
     * 根据id或名字(非中文)查询围栏  都不传 则查询所有
     * @param name  围栏名字
     * @param gid  围栏Id
     * @return
     */
    public Result<JSONArray> findFence(String key,String gid,String name){
        Result result=new Result();
        Map<String,Object> map=new HashMap<>();
        if(StrUtil.isNotBlank(gid)) {
            map.put("gid",gid);
        }else{
            map.put("name", name);
        }
        String post = HttpUtil.get(FENCE_URL+key,map);
        JSONObject jsonObject = JSONUtil.parseObj(post);
        Integer errcode = jsonObject.getInt("errcode");
        String errmsg = jsonObject.getStr("errmsg");
        if(errcode.intValue()==0){
            //成功
            JSONObject data = jsonObject.getJSONObject("data");
            //围栏ID
            JSONArray jsonArray = data.getJSONArray("rs_list");
            if(jsonArray.size()>0) {
                for (Object o : jsonArray) {
                    JSONObject jsonObject1 = JSONUtil.parseObj(o);
                    String relGid = jsonObject1.getStr("gid");
                    String relName = jsonObject1.getStr("name");
                    String points = jsonObject1.getStr("points");
                    log.info("电子围栏查询成功,名字：{}，gid:{}", relName,relGid);
                }
                result.setData(jsonArray);
                result.setCode(0);
            }else{
                result.setCode(-1);
                log.info("电子围栏不存在,名字：{},gid:{}", name,gid);
            }
        }else{
            result.setCode(errcode);
            result.setMsg(errmsg);
            log.error("电子围栏查询失败，原因：{},key:{}",errmsg,key);
        }
        return  result;
    }


    /**
     * 查询设备是否存在围栏内
     * @param location  数据为坐标数据和坐标产生的时间戳数据，至少包含一个坐标对和时间戳。
     *
     * 1、传入1个点时，直接判断交互关系。
     *
     * 2、当传入多个点时，可以通过前后时间判断动态交互关系。
     *
     * 格式: x1,y1,unix_ts1;x2,y2,unix_ts2
     *
     * 动态交互判断方法：第一个点作为当前时间的点，然后从其余点中选出在当前点之前10s～1小时范围内的最早点，用这两个时间点的位置判断设备与围栏的动态交互关系。若数据无效交互关系默认返回leave。
     *
     * @param  diu 设备唯一标识符，作为记录依据，不影响判断结果。Android设备一般使用imei号码，iOS一般使用idfv号，其余设备可根据业务自定义。
     *             大于13位小于16位（13<diu<16）
     * @return
     */
    public Result isInFence(String location,String diu,String key){
        Result result=new Result();
        Map<String,Object> map=new HashMap<>();
        map.put("key",key);
        map.put("locations",location);
        map.put("diu",diu);
        String post = HttpUtil.get(FENCE_STATUS_URL,map);
        JSONObject jsonObject = JSONUtil.parseObj(post);
        Integer errcode = jsonObject.getInt("errcode");
        String errmsg = jsonObject.getStr("errmsg");
        if(errcode.intValue()==0){
                //成功
                JSONObject data = jsonObject.getJSONObject("data");
                Integer status = data.getInt("status");
                String message = data.getStr("message");
                if(Constants.DEL_NOT_FLAG== Convert.toInt(status)){
                    //围栏ID
                    JSONArray jsonArray = data.getJSONArray("fencing_event_list");
                    //围栏距离设备的距离，没有命中围栏时返回。单位：米
                    Double nearestFenceDistance = data.getDouble("nearest_fence_distance");
                    String nearestFenceGid = data.getStr("nearest_fence_gid");
                    if (jsonArray.size() > 0) {
                        for (Object o : jsonArray) {
                            JSONObject jsonObject1 = JSONUtil.parseObj(jsonArray.get(0));
                            String client_status = jsonObject1.getStr("client_status");
                            JSONObject fenceInfo = jsonObject1.getJSONObject("fence_info");
                            String fenceGid = fenceInfo.getStr("fence_gid");
                            String fenceName = fenceInfo.getStr("fence_name");
                            if ("in".equals(client_status)) {
                                result.setCode(0);
                                result.setData(fenceGid);
                                log.debug("电子围栏监控成功,状态：{},命中的围栏ID:{},围栏名称：{}", client_status,fenceGid,fenceName);
                                break;
                            } else {
                                result.setCode(-1);
                            }
                        }
                    } else {
                        result.setCode(-1);
                        log.debug("电子围栏未监控到此设备,坐标：{},最近的围栏：{}，相差:{} 米", location,nearestFenceGid,nearestFenceDistance);
                    }
                }else{
                    result.setCode(status);
                    result.setMsg(message);
                    log.error("电子围栏监控失败,原因：{}，key:{}", message,key);
                }
        }else{
            result.setCode(errcode);
            result.setMsg(errmsg);
            log.error("电子围栏监控失败，原因：{},key:{}",errmsg,key);
        }
        return  result;
    }
    /**
     * 删除围栏
     * @param gid
     * @return
     */
    public Result deleteFence(String key,String gid){
        Result result=new Result();
        String post = HttpUtil.post(FENCE_URL+key+"&gid="+gid+"&method=delete", "{}");
        JSONObject jsonObject = JSONUtil.parseObj(post);
        Integer errcode = jsonObject.getInt("errcode");
        String errmsg = jsonObject.getStr("errmsg");
        if(errcode.intValue()==0){
            //成功
            JSONObject data = jsonObject.getJSONObject("data");
            String message = data.getStr("message");
            String status = data.getStr("status");
            if(Constants.DEL_NOT_FLAG== Convert.toInt(status)){
                result.setCode(0);
                log.info("电子围栏删除成功,ID：{}",gid);
            }else{
                result.setCode(Convert.toInt(status));
                result.setMsg(message);
                log.error("电子围栏删除失败,原因：{}",message);
            }
        }else{
            result.setCode(errcode);
            result.setMsg(errmsg);
            log.error("电子围栏删除失败,原因：{}",errmsg);
        }
        return result;
    }


    /**
     * 获取设备标识 15位 Android设备一般使用imei号码，iOS一般使用idfv号
     * @param diu
     * @return
     */
    public String getDiu(String diu){
        if(StrUtil.isBlank(diu)){
            return RandomUtil.randomString(15);
        }else {
            if (diu.length() > 15) {
                return StrUtil.subWithLength(diu, 0, 15);
            } else  if(diu.length()<15){
                return StrUtil.fill(diu, Convert.toChar("0"), 15, false);
            }else{
                return diu;
            }
        }
    }


    /**
     * 行政区域查询
     * @param keyword
     * @return
     */
    public Result<List<GdAreaDto>> findByAreaName(String keyword){
        Map<String,Object> map=new HashMap<>();
        map.put("key",Constants.GD_MAP_KEY);
        map.put("keywords",keyword);
        map.put("subdistrict",0);
        String result = HttpUtil.get(ACODE_URL,map);
        JSONObject jsonObject = JSONUtil.parseObj(result);
        Integer status = jsonObject.getInt("status");
        String info = jsonObject.getStr("info");
        List<GdAreaDto> list=CollUtil.newArrayList();
        if(1==status.intValue()){
            JSONArray districts = jsonObject.getJSONArray("districts");
            if(districts.size()>0){
                for (Object district : districts) {
                    JSONObject jsonObject1 = JSONUtil.parseObj(district);
                    String citycode = jsonObject1.getStr("citycode");
                    String adcode = jsonObject1.getStr("adcode");
                    GdAreaDto gdAreaDto=new GdAreaDto();
                    gdAreaDto.setAdcode(adcode);
                    gdAreaDto.setCitycode(citycode);
                    gdAreaDto.setName(keyword);
                    list.add(gdAreaDto);
                }
            }
            return   Result.success(list);
        }else {
            return Result.error("行政区域查询失败:"+info);
        }
    }


    /**120302
     * 查找周边
     */
    public Result<PageInfo<GdAroundResDto>> findAroundPOI(GdAroundDto gdAroundDto){
        Result result=new Result();
        Map<String, Object> stringObjectMap = BeanUtil.beanToMap(gdAroundDto);
        String s = HttpUtil.get(AROUND_URL, stringObjectMap);
        JSONObject jsonObject = JSONUtil.parseObj(s);
        if(Constants.FAIL.equals(jsonObject.getStr("status"))){
            result.setCode(-1);
            result.setMsg(jsonObject.getStr("info"));
            log.error("搜索周边POI失败，原因：{},key:{}",result.getMsg(),gdAroundDto.getKey());
        }else{
            PageInfo<GdAroundResDto> pageInfo=new PageInfo<>();
            pageInfo.setPageNum(gdAroundDto.getPage());
            pageInfo.setPageSize(gdAroundDto.getOffset());
            List<GdAroundResDto> list=new ArrayList<>();
            JSONArray regeocode = jsonObject.getJSONArray("pois");
            int count = jsonObject.getInt("count");
            pageInfo.setTotal(count);
            if(regeocode!=null&&regeocode.size()>0){
                for (Object o : regeocode) {
                    JSONObject jsonObject1= (JSONObject)o;
                    GdAroundResDto gdAroundResDto = BeanUtil.toBean(jsonObject1, GdAroundResDto.class);
                    list.add(gdAroundResDto);
                }
                pageInfo.setList(list);
            }
            result.setData(pageInfo);
            log.info("搜索周边POI成功,结果：{}",result.getData());
        }
        return result;
    }

    public static void main(String[] args) {
//        String gid="c5489f7f-ba0b-4b09-9e78-a447fc135db3";
//        Result fence = GdMapUtil.findFence("b591ccdeaab2372d14dde1b0f1eed361", gid, null);
//        if(fence.getCode()==0) {
//            JSONArray data = (JSONArray) fence.getData();
//            JSONObject jsonObject1 = JSONUtil.parseObj(data.get(0));
//            //围栏所在地区adcode
//            String adcode = jsonObject1.getStr("adcode");
//            System.out.println(adcode);
//        }

//        Result result = findByAreaName("朝阳区");
//        List<GdAreaDto> list = (List<GdAreaDto>) result.getData();
//        System.out.println(list.size());

        GdAroundDto gdAroundDto =new GdAroundDto();
        gdAroundDto.setLocation("112.943809,28.132178");
        gdAroundDto.setTypes("120300");
        gdAroundDto.setExtensions("base");
//        gdAroundDto.setPage(2);
//        gdAroundDto.setOffset(25);
//        gdAroundDto.setKeywords("西雅韵");
        Result<PageInfo<GdAroundResDto>> aroundPOI = findAroundPOI(gdAroundDto);
        PageInfo<GdAroundResDto> data = aroundPOI.getData();
        System.out.println(data.getTotal());
        List<GdAroundResDto> list = data.getList();
        for (GdAroundResDto gdAroundResDto : list) {
            System.out.println(gdAroundResDto.getName()+" "+gdAroundResDto.getType());
        }

    }

}