package com.xzx.gc.user.service;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.comparator.PropertyComparator;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.ReUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.extra.emoji.EmojiUtil;
import com.github.pagehelper.PageInfo;
import com.xzx.gc.common.Result;
import com.xzx.gc.common.constant.Constants;
import com.xzx.gc.common.constant.UserEnum;
import com.xzx.gc.common.dto.gdmap.*;
import com.xzx.gc.common.exception.RestException;
import com.xzx.gc.common.utils.BusinessUtil;
import com.xzx.gc.common.utils.ExceptionUtils;
import com.xzx.gc.common.utils.StringUtils;
import com.xzx.gc.common.utils.gdmap.GdMapUtil;
import com.xzx.gc.entity.AddressInfo;
import com.xzx.gc.entity.AddressLevelInfo;
import com.xzx.gc.entity.OrderInfo;
import com.xzx.gc.entity.UserInfo;
import com.xzx.gc.model.admin.LongiLatiModel;
import com.xzx.gc.model.user.AddressReq;
import com.xzx.gc.model.user.AddressVo;
import com.xzx.gc.user.mapper.*;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import tk.mybatis.mapper.common.base.update.UpdateByPrimaryKeySelectiveMapper;
import tk.mybatis.mapper.entity.Example;

import javax.servlet.http.HttpServletRequest;
import javax.xml.ws.soap.Addressing;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

@Service
@Slf4j
@Transactional
public class AddressService{
    @Autowired
    AddressMapper addressMapper;

    @Autowired
    private UserTargetInfoService userTargetInfoService;

    @Autowired
    private HttpServletRequest request;


    @Autowired
    private BusinessUtil businessUtil;

    @Autowired
    private AddressLevelService addressLevelService;


    @Autowired
    private AddressLevelMapper addressLevelInfoMapper;

    @Autowired
    private OrderMapper orderMapper;

    @Autowired
    private UserService userService;


    /**
     * 根据经纬度获取省市区
     * @param lon
     * @param lan
     * @return
     */
    public AddressInfo getByLon(String lon,String lan) {
        GdReverseGEODto gdReverseGEODto = new GdReverseGEODto();
        gdReverseGEODto.setLocation(lon + "," + lan);
        Result areaInfo = GdMapUtil.getAreaInfo(gdReverseGEODto, 0);
        if (areaInfo.getCode() == 0) {
            AddressInfo addressInfo1 = (AddressInfo) areaInfo.getData();
            AddressLevelInfo addressLevelInfo = new AddressLevelInfo();
            addressLevelInfo.setAdcode(addressInfo1.getAdcode());
            AddressLevelInfo addressLevelInfo1 = addressLevelInfoMapper.selectOne(addressLevelInfo);
            if(addressLevelInfo1!=null) {
                addressInfo1.setTownshipId(addressLevelInfo1.getLevel3Id());
                addressInfo1.setProvinceId(addressLevelInfo1.getLevel1Id());
                addressInfo1.setCityId(addressLevelInfo1.getLevel2Id());
                return addressInfo1;
            }
        }
        return null;
    }


    public void add(AddressInfo addressInfo){
        addressInfo.setDelFlag(Constants.DEL_NOT_FLAG+"");
        addressInfo.setCreateTime(DateUtil.now());
        addressMapper.insertSelective(addressInfo);
    }
    
    public long addressAdd(AddressReq addressReq) {
        long returnvalue= 0;
        try {

            addressReq.setDetailAddress(StringUtils.cleanStr(addressReq.getDetailAddress()));
            //若从微信取的地址则自动转换经纬度
            if(StrUtil.isBlank(addressReq.getLatitude())){
                GdGEODto gdGEODto=new GdGEODto();
                if(StrUtil.isNotBlank(addressReq.getCityName())) {
                    gdGEODto.setCity(addressReq.getCityName());
                }
                gdGEODto.setAddress(addressReq.getAddressArea()+addressReq.getDetailAddress());
                Result locationByAddress = GdMapUtil.getLocationByAddress(gdGEODto);
                if(locationByAddress.getCode()==0&&locationByAddress.getData()!=null){
                    addressReq.setLongitude(locationByAddress.getData().toString().split(",")[0]);
                    addressReq.setLatitude(locationByAddress.getData().toString().split(",")[1]);
                }
            }

            if(StrUtil.isBlank(addressReq.getLatitude())){
                throw new RestException(-1,"地址经纬度获取失败");
            }


            AddressInfo addressInfo = new AddressInfo();
            BeanUtils.copyProperties(addressReq, addressInfo);
            //获取省市区ID
            completeAddress(addressReq, addressInfo);

            String userId = request.getHeader("userId");
            addressInfo.setDelFlag(Convert.toStr(Constants.DEL_NOT_FLAG));
            changeLocation(addressInfo);
            addressInfo.setUserId(userId);
            addressInfo.setCreateTime(DateUtil.now());
            addressInfo.setFlag(UserEnum.默认地址.getValue());
            //修改用户的所有地址为非默认
            updateByUserIdSetNoDefault(userId);
            addressMapper.insertSelective(addressInfo);

            returnvalue=addressInfo.getAddressId();
            //修改意向客户的地址   来源是新增地址时
            if(addressReq.getOrigin()==0) {
                userTargetInfoService.updateTargetUserAddr(addressInfo);
            }

            //判断地址是属于哪个围栏 从而获取合伙人ID
//            fenceService.findByPartnerId()


        } catch (BeansException e) {
            ExceptionUtils.err("新增地址失败",e);
        }


        return returnvalue;
    }

    /**
     * 替换经纬度  填补省市区
     * @param addressInfo
     */
    public void changeLocation(AddressInfo addressInfo) {
        GdPOIDto gdGEODto=new GdPOIDto();
        gdGEODto.setKeywords(StrUtil.emptyToDefault(addressInfo.getAddressArea(),"")+StrUtil.emptyToDefault(addressInfo.getDetailAddress(),""));
        //替换地址表的省市区ID
        if(StrUtil.isBlank(addressInfo.getProvinceId())){
            addressInfo = GdMapUtil.getLocationByPOI(gdGEODto, addressInfo);
            AddressReq addressReq = new AddressReq();
            addressReq.setProvinceName(addressInfo.getProvinceName());
            addressReq.setCityName(addressInfo.getCityName());
            addressReq.setTownshipName(addressInfo.getTownshipName());
            List<AddressVo> addressLevelList = addressMapper.queryAreaIdByName(addressReq);
            if (addressLevelList != null && addressLevelList.size() > 0) {
                String provinceId = addressLevelList.get(0).getProvinceId();
                addressInfo.setProvinceId(provinceId);
                String cityId = addressLevelList.get(0).getCityId();
                addressInfo.setCityId(cityId);
                String townshipId = addressLevelList.get(0).getTownshipId();
                addressInfo.setTownshipId(townshipId);
            }
        }
    }

    private void getProvinceAndCityId(AddressReq addressReq, AddressInfo addressInfo) {
        if(StrUtil.isNotBlank(addressReq.getTownshipName())){
            addressReq.setTownshipName(  businessUtil.changeArea(addressReq.getTownshipName()));
        }
        List<AddressVo> addressLevelList= addressMapper.queryAreaIdByName(addressReq);
        if (addressLevelList != null && addressLevelList.size() > 0){
            String provinceId = addressLevelList.get(0).getProvinceId();
            String cityId = addressLevelList.get(0).getCityId();
            String townshipId = addressLevelList.get(0).getTownshipId();
            String citycode = addressLevelList.get(0).getCitycode();
            String adcode = addressLevelList.get(0).getAdcode();
            String pcode = addressLevelList.get(0).getPcode();
            addressInfo.setProvinceId(provinceId);
            addressInfo.setCityId(cityId);
            addressInfo.setTownshipId(townshipId);
            //用于poi筛选
            addressInfo.setCityName(addressReq.getCityName());
            addressInfo.setCitycode(citycode);
            addressInfo.setAdcode(adcode);
            addressInfo.setPcode(pcode);
            addressReq.setProvinceId(provinceId);
            addressReq.setCityId(cityId);
            addressReq.setTownshipId(townshipId);
        }
    }


    
    public void addressModify(AddressReq addressReq) {
        try {
            addressReq.setDetailAddress(StringUtils.cleanStr(addressReq.getDetailAddress()));
            AddressInfo addressInfo = new AddressInfo();
            BeanUtils.copyProperties(addressReq, addressInfo);
            //当某一地址设为默认时,其它地址为非默认
            if (UserEnum.默认地址.getValue().equals(addressReq.getFlag())){
                addressMapper.updateAddressFlag(addressReq);
            }

            //获取省市区ID
            completeAddress(addressReq, addressInfo);

            changeLocation(addressInfo);


            //查询地址修改是否跨区  跨区则删除当前地址新增地址
            AddressInfo addressInfo1 = addressMapper.selectByPrimaryKey(addressInfo.getAddressId());
            String townshipId = addressInfo1.getTownshipId();
            if(!townshipId.equals(addressInfo.getTownshipId())){
                deleteById(addressInfo.getAddressId());
                AddressInfo obj=new AddressInfo();
                BeanUtil.copyProperties(addressInfo,obj);
                obj.setAddressId(null);
                obj.setDelFlag(Constants.DEL_NOT_FLAG+"");
                obj.setCreateTime(DateUtil.now());
                addressMapper.insertSelective(obj);
            }else {
               addressMapper.updateByPrimaryKeySelective(addressInfo);
            }

            if (UserEnum.默认地址.getValue().equals(addressReq.getFlag())) {
                userTargetInfoService.updateTargetUserAddr(addressInfo);
            }
        } catch (BeansException e) {
            ExceptionUtils.err("修改地址失败",e);
        }

    }


    /**
     * 删除地址
     * @param addressId
     */
    public void deleteById(Long addressId){
        AddressInfo addressInfo=new AddressInfo();
        addressInfo.setAddressId(addressId);
        addressInfo.setDelFlag(Constants.DEL_FLAG+"");
        addressMapper.updateByPrimaryKeySelective(addressInfo);
    }

    public void deleteByUserId(String userId){
        AddressInfo addressInfo = new AddressInfo();
        addressInfo.setDelFlag(Constants.DEL_FLAG+"");
        Example example = new Example(AddressInfo.class);
        Example.Criteria criteria = example.createCriteria();
        criteria.andEqualTo("userId", userId);
        addressMapper.updateByExampleSelective(addressInfo,example);
    }

    /**
     * 完善地址信息
     * @param addressReq
     * @param addressInfo
     */
    private void completeAddress(AddressReq addressReq, AddressInfo addressInfo) {
        if (StringUtils.isBlank(addressReq.getProvinceId())) {
            getProvinceAndCityId(addressReq, addressInfo);
        } else {
            //设置adcode
            if (StrUtil.isNotBlank(addressReq.getCityId()) && StrUtil.isNotBlank(addressReq.getTownshipId())) {
                AddressLevelInfo addressLevelInfo = addressLevelService.find(addressReq.getProvinceId(), addressReq.getCityId(), addressReq.getTownshipId());
                if (addressLevelInfo != null) {
                    addressInfo.setAdcode(addressLevelInfo.getAdcode());
                    addressInfo.setCitycode(addressLevelInfo.getCitycode());
                }
            }
        }
        //判断详细地址和所选的区域是否正确  高德同一地点存在跨区可能不准 （只判断到市）
        checkLon(addressReq, addressInfo);
    }

    /**
     * 判断详细地址和所选的区域是否正确  高德同一地点存在跨区可能不准 （只判断到市）
     * @param addressReq
     * @param addressInfo
     */
    private void checkLon(AddressReq addressReq, AddressInfo addressInfo) {
        GdReverseGEODto gdReverseGEODto = new GdReverseGEODto();
        gdReverseGEODto.setLocation(addressReq.getLongitude() + "," + addressReq.getLatitude());
        Result areaInfo = GdMapUtil.getAreaInfo(gdReverseGEODto, 0);
        if (areaInfo.getCode() == 0) {
            AddressInfo addressInfo1 = (AddressInfo) areaInfo.getData();
            String adcode = addressInfo1.getCitycode();
            if (StrUtil.isNotBlank(adcode) && StrUtil.isNotBlank(addressInfo.getCitycode())) {
                if (!StrUtil.equals(adcode, addressInfo.getCitycode())) {
                    throw new RestException(-1, "详细地址与区域不一致，请重新选择");
                }
            }
        }
    }


    public int addressDel(AddressReq addressReq) {
        int returnvalue= 0;
        try {
            Long addressId = addressReq.getAddressId();
            //查询用户下有几条地址
            addressReq.setAddressId(null);
            List<AddressVo> list = addressMapper.addressQuery(addressReq);
            returnvalue = addressMapper.deleteAddress(addressId);
            if (UserEnum.默认地址.getValue().equals( addressReq.getFlag() )&&list.size()>1){
                // 如果删除的是默认地址，则设置第一条数据为默认地址
                returnvalue = addressMapper.autoSetDefaultAddress(addressReq.getUserId());
            }
        } catch (Exception e) {
            ExceptionUtils.err("删除地址失败",e);
        }
        return returnvalue;
    }

    
    public List<AddressVo> addressQuery(AddressReq addressReq) {
        List<AddressVo> list = addressMapper.addressQuery(addressReq);
        return  list;
    }

    
    public void updateByUserIdSetNoDefault(String userId) {
        if(StrUtil.isNotBlank(userId)) {
            AddressInfo addressInfo = new AddressInfo();
            addressInfo.setFlag(UserEnum.非默认地址.getValue());
            Example example = new Example(AddressInfo.class);
            Example.Criteria criteria = example.createCriteria();
            criteria.andEqualTo("userId", userId);
            criteria.andEqualTo("delFlag",Constants.DEL_NOT_FLAG);
            addressMapper.updateByExampleSelective(addressInfo,example);
        }
    }


    public void updateAllById(AddressInfo addressInfo){
        addressMapper.updateByPrimaryKey(addressInfo);
    }

    /**
     * 查询所有地址
     * @return
     */
    public List<AddressInfo> find(){
        AddressInfo addressInfo=new AddressInfo();
        addressInfo.setDelFlag(Convert.toStr(Constants.DEL_NOT_FLAG));
        List<AddressInfo> select = addressMapper.select(addressInfo);
        return select;
    }

    public String updateUserAddress(AddressInfo address) {
        AddressInfo oldAddre = new AddressInfo();
        oldAddre.setAddressId(address.getAddressId());
        AddressInfo oldAddress = addressMapper.selectOne(oldAddre);
        oldAddress.setLongitude(address.getLongitude());
        oldAddress.setLatitude(address.getLatitude());
        String location = address.getLongitude()+","+address.getLatitude();
        AddressLevelInfo addressLevelInfo = findByLocation(location);
        String addressArea = "";
        if(null!=addressLevelInfo.getLevel1Id()&&!"".equals(addressLevelInfo.getLevel1Id())){
            oldAddress.setProvinceId(addressLevelInfo.getLevel1Id());
            addressArea = addressLevelInfo.getLevel1Name();
        }
        if(null!=addressLevelInfo.getLevel2Id()&&!"".equals(addressLevelInfo.getLevel2Id())){
            oldAddress.setCityId(addressLevelInfo.getLevel2Id());
            addressArea = addressArea+addressLevelInfo.getLevel2Name();
        }
        if(null!=addressLevelInfo.getLevel3Id()&&!"".equals(addressLevelInfo.getLevel3Id())){
            oldAddress.setTownshipId(addressLevelInfo.getLevel3Id());
            addressArea =addressArea+addressLevelInfo.getLevel3Name();
        }
        //addressArea = addressArea + address.getDetailAddress();
        oldAddress.setAddressArea(addressArea);
        oldAddress.setDetailAddress(address.getDetailAddress());
        oldAddress.setTagName(address.getTagName());
        oldAddress.setUnitName(address.getUnitName());
        oldAddress.setHouseNumber(address.getHouseNumber());
        oldAddress.setReceiveAddress(address.getReceiveAddress());
        addressMapper.updateByPrimaryKeySelective(oldAddress);
        if(null!=address.getOrderId()&&!"".equals(address.getOrderId())){
            OrderInfo orderInfo = new OrderInfo();
            orderInfo.setOrderId(address.getOrderId());
            orderInfo.setOrderStatus("1");
            orderMapper.updateByPrimaryKeySelective(orderInfo);
        }
        return null;
    }

    public AddressLevelInfo findByLocation(String location){
        GdReverseGEODto gdReverseGEODto = new GdReverseGEODto();
        gdReverseGEODto.setLocation(location);
        Result areaInfo = GdMapUtil.getAreaInfo(gdReverseGEODto, 0);
        if (areaInfo.getCode() == 0) {
            AddressInfo addressInfo = (AddressInfo) areaInfo.getData();
            AddressLevelInfo addressLevelInfo=new AddressLevelInfo();
            addressLevelInfo.setLevel3Name(addressInfo.getTownshipName());
            addressLevelInfo.setLevel2Name(addressInfo.getCityName());
            addressLevelInfo.setLevel1Name(addressInfo.getProvinceName());
            List<AddressLevelInfo> byAny = findByAny(addressLevelInfo);
            if(CollUtil.isNotEmpty(byAny)){
                return byAny.get(0);
            }else {
                return null;
            }
        } else {
            return null;
        }
    }

    private List<AddressLevelInfo> findByAny(AddressLevelInfo addressLevelInfo) {
        if(StrUtil.isNotBlank(addressLevelInfo.getLevel3Name())){
            addressLevelInfo.setLevel3Name(businessUtil.changeArea(addressLevelInfo.getLevel3Name()));
        }

        List<AddressLevelInfo> addressLevelInfos = addressLevelInfoMapper.select(addressLevelInfo);
        if(CollUtil.isNotEmpty(addressLevelInfos)){
            for (AddressLevelInfo levelInfo : addressLevelInfos) {
                levelInfo.setLevel3Name(businessUtil.changeArea(levelInfo.getLevel3Name()));
            }
        }
        return addressLevelInfos;
    }

    public List<AddressInfo> findAllByUserId(String userId) {
        AddressInfo addressInfo=new AddressInfo();
        addressInfo.setUserId(userId);
        addressInfo.setDelFlag(Constants.DEL_NOT_FLAG+"");
        List<AddressInfo> select = addressMapper.select(addressInfo);
        return select;
    }
    public AddressInfo findByUserId(String userId) {
        AddressInfo addressInfo=new AddressInfo();
        addressInfo.setUserId(userId);
        addressInfo.setFlag(Constants.DEL_FLAG+"");
        List<AddressInfo> select = addressMapper.select(addressInfo);
        if(CollUtil.isNotEmpty(select)) {
            List<AddressInfo> collect = select.stream().filter(x -> x.getDelFlag().equals("0")).collect(Collectors.toList());
            if (CollUtil.isNotEmpty(collect)) {
                return collect.get(0);
            } else {
                CollUtil.sort(select, new PropertyComparator<>("createTime").reversed());
                return select.get(0);
            }
        }else{
            UserInfo byId = userService.findById(userId);
            if(StrUtil.isNotBlank(byId.getLatitude())){
                AddressInfo addressInfo1 = getByLon(byId.getLongitude(),byId.getLatitude());
                if (addressInfo1 != null) return addressInfo1;
            }
        }
        return null;
    }

    public AddressInfo findById(Long id){
        return addressMapper.selectByPrimaryKey(id);
    }

    /**
     * 根据经纬度查询附近小区
     * @param longiLatiModel
     * @return
     */
    public Result<PageInfo<GdAroundResDto>> findHouseByLon(LongiLatiModel longiLatiModel) {
        GdAroundDto gdAroundDto =new GdAroundDto();
        gdAroundDto.setLocation(longiLatiModel.getLongitude()+","+longiLatiModel.getLatitude());
        gdAroundDto.setTypes(GdMapUtil.HOUSE_POI);
        gdAroundDto.setPage(longiLatiModel.getPageNo());
        gdAroundDto.setOffset(longiLatiModel.getPageSize());
        Result<PageInfo<GdAroundResDto>> aroundPOI = GdMapUtil.findAroundPOI(gdAroundDto);
        return aroundPOI;
    }
}