package com.dsh.other.controller;


import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.dsh.other.entity.*;
import com.dsh.other.feignclient.model.*;
import com.dsh.other.model.*;
import com.dsh.other.model.dto.siteDto.StoreInfoDto;
import com.dsh.other.service.*;
import com.dsh.other.util.GDMapGeocodingUtil;
import com.dsh.other.util.GeodesyUtil;
import com.dsh.other.util.ResultUtil;
import com.dsh.other.util.ToolUtil;
import com.sun.javafx.binding.StringFormatter;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.util.*;
import java.util.stream.Collectors;

@RestController
@RequestMapping("")
public class StoreController {

    @Autowired
    private StoreService storeService;


    @Autowired
    private GDMapGeocodingUtil gdMapGeocodingUtil;

    @Autowired
    private TStoreOtherService tStoreOtherService;

    @Autowired
    private TBackRecordService backRecordService;

    /**
     * 获取根据门店id 获取店长信息
     */
    @RequestMapping(value = "/getStoreInfo")
    public StoreInfoDto getStoreInfo(@RequestBody Integer id) {

        return storeService.getStoreInfo(id);
    }

    /**
     * 根据城市管理员id获取门店
     */
    @RequestMapping("base/site/getStoreByCityManagerId")
    public Object getStoreByCityManagerId(@RequestBody Integer id) {
        return storeService.getStoreByCityManagerId(id);
    }

    /**
     * 根据员工id获取门店
     */
    @RequestMapping("base/site/getStoreByStoreStaffId")
    public Object getStoreByStoreStaffId(@RequestBody Integer id) {
        return storeService.getStoreByStoreStaffId(id);
    }

    /**
     * 根据门店id获取门店信息
     */
    @RequestMapping("base/site/getStoreById")
    public Store getStoreById(@RequestBody Integer id) {
        return storeService.getOne(new QueryWrapper<Store>().eq("id", id));
    }

    /**
     * 选择市区 展示全部门店
     */
    @RequestMapping("base/store/getStore")
    public List<Store> getStore(@RequestBody String city) {
        return storeService.list(new QueryWrapper<Store>().eq("city", city));
    }

    /**
     * 根据所选门店 查询经营时间
     *
     * @param oneId
     * @return
     */
    @RequestMapping("base/store/getTime")
    public Store getTime(@RequestBody String oneId) {
        return storeService.getOne(new QueryWrapper<Store>().eq("name", oneId));
    }


    @PostMapping("/base/protocol/storeDetail/courseOfSto")
    public StoreDetailOfCourse getCourseOfStore(@RequestBody Integer storeId) {
        StoreDetailOfCourse ofCourse = new StoreDetailOfCourse();
        Store store = storeService.getById(storeId);
        if (null != store) {
            ofCourse.setStoreName(store.getName());
            ofCourse.setStoreAddr(store.getAddress());
        }
        return ofCourse;
    }

    @PostMapping("/base/protocol/storeDetail/nearbyStore")
    public List<StoreInfo> getAllNearbyStoreList(@RequestBody GetAllNearbyStoreList list) {
        List<StoreInfo> storeInfos = new ArrayList<>();
        if (ToolUtil.isEmpty(list.getLongitude()) && ToolUtil.isEmpty(list.getLatitude())) {
            return storeInfos;
        }
        String current = list.getLongitude() + "," + list.getLatitude();
        String cityCode = "";
        try {
            Map<String, String> geocode = gdMapGeocodingUtil.geocode(list.getLongitude(), list.getLatitude());
            cityCode = geocode.get("cityCode");
        } catch (Exception e) {
            e.printStackTrace();
        }
        List<Store> storeList = storeService.list(new QueryWrapper<Store>()
                .eq("state", 1)
                .eq("cityCode", cityCode));
        if (storeList.size() > 0) {
            for (Store store : storeList) {
                String storeLon = store.getLon();
                String storeLat = store.getLat();
//                String result = storeLon + "," + storeLat;
//                String distanceTOKilometer = gdMapGeocodingUtil.getDistanceTOKilometer(current, result);
                long l = 0;
//                try {
//                    l = Long.parseLong(distanceTOKilometer);
//                }catch (Exception e){
//                    l = 0;
//                }
                StoreInfo info = new StoreInfo();
                info.setStoreId(store.getId());
                info.setStoreName(store.getName());
                info.setStoreImg(store.getCoverDrawing());
//                info.setDistance( Double.parseDouble(distanceTOKilometer));

                Map<String, Double> distance = GeodesyUtil.getDistance(list.getLongitude() + "," + list.getLatitude(), storeLon + "," + storeLat);
                double wgs84 = new BigDecimal(distance.get("WGS84")).divide(new BigDecimal(1000)).setScale(2, RoundingMode.HALF_EVEN).doubleValue();
                info.setDistance(wgs84);


                String str = store.getAddress();
                str = str.substring(str.indexOf("省") + 1);

                // 去掉第一个“市”及之前的字符串
                str = str.substring(str.indexOf("市") + 1);

                // 去掉第一个“区”及之前的字符串
                str = str.substring(str.indexOf("区") + 1);

                info.setStoreAddr(str);
                info.setLatitude(storeLat);
                info.setLongitude(storeLon);

                storeInfos.add(info);
            }
//            Comparator<StoreInfo> distanceComparator = new Comparator<StoreInfo>() {
//                @Override
//                public int compare(StoreInfo store1, StoreInfo store2) {
//                    return Long.compare(store1.getDistance(), store2.getDistance());
//                }
//            };
//            Collections.sort(storeInfos, distanceComparator);
            storeInfos = storeInfos.stream().sorted(Comparator.comparing(StoreInfo::getDistance)).collect(Collectors.toList());
        }
        return storeInfos;
    }

    /**
     * 根据门店坐标与传入坐标，计算距离
     *
     * @param distanceVo
     * @return
     */
    @PostMapping("/base/protocol/storeDetail/distanceCal")
    public String calculateDistance(@RequestBody GetDistanceVo distanceVo) {
        String current = distanceVo.getLongitude() + "," + distanceVo.getLatitude();
        Store store = storeService.getById(distanceVo.getStoreId());
        String result = store.getLon() + "," + store.getLat();


        if (ToolUtil.isNotEmpty(distanceVo.getLongitude()) && ToolUtil.isNotEmpty(distanceVo.getLatitude())) {
            Map<String, Double> distance = GeodesyUtil.getDistance(distanceVo.getLongitude() + "," + distanceVo.getLatitude(), store.getLon() + "," + store.getLat());
            double wgs84 = new BigDecimal(distance.get("WGS84")).divide(new BigDecimal(1000)).setScale(2, RoundingMode.HALF_EVEN).doubleValue();
//            packageResponse.setDistance(wgs84);
            return wgs84 + "";
        }
        return "";

//        return gdMapGeocodingUtil.getDistanceTOKilometer(current, result);
    }


    @PostMapping("/base/protocol/storeDetail/citycodeLoLa")
    public List<StoreDetailList> getQueryStoreList(@RequestBody StoreOfCitycodeResp citycodeResp) throws Exception {
        List<StoreDetailList> detailLists = new ArrayList<>();

        if (citycodeResp.getCityCode() == null) {
            Map<String, String> geocode = gdMapGeocodingUtil.geocode(citycodeResp.getLongitude(), citycodeResp.getLatitude());
            if(null != geocode){
                String cityCode = geocode.get("cityCode");
                citycodeResp.setCityCode(cityCode);
            }
        }

        List<Store> list = storeService.list(new QueryWrapper<Store>()
                .eq("state", 1)
                .eq("cityCode", citycodeResp.getCityCode()));
        if (list.size() > 0) {
            for (Store store : list) {
                String current = citycodeResp.getLongitude() + "," + citycodeResp.getLatitude();
                String result = store.getLon() + "," + store.getLat();
                Map<String, Double> distance = GeodesyUtil.getDistance(current, result);
                StoreDetailList detailList = new StoreDetailList();
                detailList.setStoreId(store.getId());
                detailList.setStoreImg(store.getCoverDrawing());
                detailList.setStoreName(store.getName());
                detailList.setStoreAddress(store.getAddress());
                detailList.setStorePhone(store.getPhone());
                detailList.setStoreTime(store.getStartTime() + "-" + store.getEndTime());
                detailList.setStoreInfo(store.getIntroduce());
                detailList.setStoreDistance(null != distance ? Double.valueOf(String.format("%.2f", distance.get("WGS84") / 1000)) : 0D);
                detailLists.add(detailList);
            }
        }
        return detailLists;
    }


    /**
     * 获取门店列表
     *
     * @return
     */
    @ResponseBody
    @PostMapping("/store/queryStoreList")
    public List<Store> queryStoreList(QueryStoreList queryStoreList) {
        try {
            return storeService.queryStorsList(queryStoreList.getProvinceCode(), queryStoreList.getCityCode());
        } catch (Exception e) {
            e.printStackTrace();
            return new ArrayList<>();
        }
    }


    /**
     * 获取门店列表
     *
     * @return
     */
    @ResponseBody
    @PostMapping("/store/queryStoreByIds")
    public List<Store> queryStoreByIds(@RequestBody List<Integer> ids) {
        try {
            List<Store> list = storeService.list(new LambdaQueryWrapper<Store>()
                    .in(Store::getId, ids));
            for (Store store : list) {
                Integer operatorId = store.getOperatorId();
                if (operatorId == null) {
                    operatorId = -1;
                }
                String name = storeService.getOName(operatorId);
                store.setOName(name);
            }
            return list;
        } catch (Exception e) {
            e.printStackTrace();
            return new ArrayList<>();
        }
    }

    @ResponseBody
    @PostMapping("/store/queryStoreIdByCityCode")
    List<Integer> queryStoreIdByCityCode(@RequestBody List<String> collect) {
        try {
            return storeService.list(new LambdaQueryWrapper<Store>()
                    .in(Store::getCityCode, collect)).stream().map(Store::getId).collect(Collectors.toList());
        } catch (Exception e) {
            e.printStackTrace();
            return new ArrayList<>();
        }
    }

    @ResponseBody
    @PostMapping("/store/querySiteIdById")
    public List<Integer> querySiteIdById(@RequestBody List<Integer> storeIds) {
        List<Site> list = siteService.list(new LambdaQueryWrapper<Site>().in(Site::getStoreId, storeIds));
        List<Integer> collect = list.stream().map(Site::getId).collect(Collectors.toList());
        return collect;
    }


    @ResponseBody
    @PostMapping("/base/store/queryStoreLists")
    @ApiOperation(value = "获取门店列表", tags = {"APP-加入玩湃", "APP-课程列表", "用户—预约场地"})
    @ApiImplicitParams({
            @ApiImplicitParam(value = "经纬", name = "lon", dataType = "string", required = false),
            @ApiImplicitParam(value = "纬度", name = "lat", dataType = "string", required = false),
            @ApiImplicitParam(value = "cityCode", name = "cityCode", dataType = "string", required = false),
    })
    public ResultUtil<List<BaseVo>> queryStoreLists(String lon, String lat, String cityCode) {
        try {
            List<BaseVo> baseVos = storeService.queryStoreLists(lon, lat, cityCode);
            return ResultUtil.success(baseVos);
        } catch (Exception e) {
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }


    /**
     * 根据门店模糊搜索店铺
     *
     * @param name
     * @return
     */
    @ResponseBody
    @PostMapping("/store/queryStoreListByName")
    public List<Store> queryStoreListByName(@RequestBody String name) {
        try {
            List<Store> stores = storeService.list(new QueryWrapper<Store>().eq("state", 1).like("name", name));
            return stores;
        } catch (Exception e) {
            e.printStackTrace();
            return new ArrayList<>();
        }
    }


    /**
     * 根据门店
     *
     * @param id
     * @return
     */
    @ResponseBody
    @PostMapping("/store/queryStoreById")
    public Store queryStoreById(@RequestBody Integer id) {
        try {
            return storeService.getById(id);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    @ResponseBody
    @PostMapping("/store/queryByStoreId")
    public OperatorUser queryByStoreId(@RequestBody Integer id) {
        try {
            return storeService.queryByStoreId(id);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }


    @Autowired
    private ISiteService siteService;

    @ResponseBody
    @PostMapping("/store/querySiteId")
    public List<Integer> querySiteId(@RequestBody Integer storeId) {
        List<Site> list = siteService.list(new LambdaQueryWrapper<Site>().eq(Site::getStoreId, storeId).eq(Site::getSign, 1));
        List<Integer> collect = list.stream().map(Site::getId).collect(Collectors.toList());
        return collect;
    }


    @PostMapping("/store/addBackRecord")
    public void addBackRecord(@RequestBody String s) {
        TBackRecord tBackRecord = new TBackRecord();
        String[] split = s.split("_");
        tBackRecord.setMoney(Double.valueOf(split[0]));
        tBackRecord.setUserId(Integer.valueOf(split[1]));
        tBackRecord.setTime(new Date());
        backRecordService.save(tBackRecord);
    }


    @ResponseBody
    @PostMapping("/base/store/queryStoreFreeBenefit")
    @ApiOperation(value = "获取门店免费福利", tags = {"APP-免费福利"})
    @ApiImplicitParams({
            @ApiImplicitParam(value = "门店id", name = "id", dataType = "int", required = true),
    })
    public ResultUtil<StoreFreeBenefitVo> queryStoreFreeBenefit(Integer id) {
        try {
            Store store = storeService.getById(id);
            StoreFreeBenefitVo storeFreeBenefitVo = new StoreFreeBenefitVo();
            storeFreeBenefitVo.setPhone(store.getPhone());
            storeFreeBenefitVo.setImg(store.getWelfarePicture());
            return ResultUtil.success(storeFreeBenefitVo);
        } catch (Exception e) {
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }

    @Autowired
    private TStoreOtherConfigTrueService tStoreOtherConfigTrueService;

    @ResponseBody
    @PostMapping("/base/store/queryIndexSet")
    @ApiOperation(value = "获取门店首页设置 2.0", tags = {"APP-免费福利"})
    @ApiImplicitParams({
            @ApiImplicitParam(value = "门店id", name = "id", dataType = "int", required = true),
    })
    public ResultUtil<List<TStoreOtherConfigTrue>> queryIndexSet(Integer id) {
        try {
            List<TStoreOtherConfigTrue> tStoreOtherConfigTrues = new ArrayList<>();

            List<TStoreOther> list = tStoreOtherService.list(new LambdaQueryWrapper<TStoreOther>().eq(TStoreOther::getStoreId, id).eq(TStoreOther::getState, 1));
            if (list.size() > 0) {
                tStoreOtherConfigTrues = tStoreOtherConfigTrueService.list(new LambdaQueryWrapper<TStoreOtherConfigTrue>().in(TStoreOtherConfigTrue::getPid, list.stream().map(TStoreOther::getId).collect(Collectors.toList())).eq(TStoreOtherConfigTrue::getState, 1));
            }
            for (TStoreOtherConfigTrue tStoreOtherConfigTrue : tStoreOtherConfigTrues) {
                for (TStoreOther tStoreOther : list) {
                    if (tStoreOtherConfigTrue.getPid() == tStoreOther.getId()) {
                        tStoreOtherConfigTrue.setSort(tStoreOther.getSort());
                    }
                }
            }
            return ResultUtil.success(tStoreOtherConfigTrues);
        } catch (Exception e) {
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }


    @ResponseBody
    @PostMapping("/base/store/queryProvinceAndCity")
    @ApiOperation(value = "获取省市数据", tags = {"APP-加入玩湃"})
    @ApiImplicitParams({
            @ApiImplicitParam(value = "省编号", name = "pcode", dataType = "string", required = false),
    })
    public ResultUtil<List<ProvinceAndCityVo>> queryProvinceAndCity(String pcode) {
        try {
            List<ProvinceAndCityVo> provinceAndCityVos = storeService.queryProvinceAndCity(pcode);
            return ResultUtil.success(provinceAndCityVos);
        } catch (Exception e) {
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }


    @ResponseBody
    @PostMapping("/base/store/queryAllCity")
    @ApiOperation(value = "获取所有开通城市", tags = {"APP-赛事活动列表", "用户—预约场地"})
    @ApiImplicitParams({
    })
    public ResultUtil<List<ProvinceAndCityVo>> queryAllCity() {
        try {
            List<ProvinceAndCityVo> provinceAndCityVos = storeService.queryAllCity();
            return ResultUtil.success(provinceAndCityVos);
        } catch (Exception e) {
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }


    @ResponseBody
    @PostMapping("/base/store/queryStoreByCityCode")
    @ApiOperation(value = "获取城市code获取门店", tags = {"APP-加入玩湃"})
    @ApiImplicitParams({
            @ApiImplicitParam(value = "城市code", name = "cityCode", dataType = "string", required = true),
    })
    public ResultUtil<List<BaseVo>> queryStoreByCityCode(String provinceCode, String cityCode) {
        try {
            List<BaseVo> list = storeService.queryStoreByCityCode(provinceCode, cityCode);
            return ResultUtil.success(list);
        } catch (Exception e) {
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }
}