package com.moral.service.impl;

import com.alibaba.fastjson.JSON;
import com.moral.common.util.WebTokenUtils;
import com.moral.controller.ScreenController;
import com.moral.entity.*;
import com.moral.mapper.*;
import com.moral.service.DictionaryDataService;
import com.moral.service.MapPathService;
import com.moral.service.MonitorPointService;
import com.moral.service.OrganizationService;
import org.apache.log4j.Logger;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;

import javax.annotation.Resource;
import java.util.*;

@Service
public class MapPathServiceImpl implements MapPathService {
    public static Logger log = Logger.getLogger(MapPathServiceImpl.class);
    @Resource
    MapPathMapper mapPathMapper;
    @Resource
    OrganizationService organizationService;
    @Resource
    DictionaryDataService dictionaryDataService;
    @Resource
    MonitorPointService monitorPointService;
    @Resource
    ProvinceMapper provinceMapper;
    @Resource
    CityMapper cityMapper;
    @Resource
    AreaMapper areaMapper;
    @Resource
    MonitorPointMapper monitorPointMapper;
    @Resource
    RedisTemplate redisTemplate;


    /**
     * @Description: 根据用户token获取用户地图权限
     * @Param: [token]
     * @return: java.util.List<com.moral.entity.WebProvince>
     * @Author: 下雨听风
     * @Date: 2020/11/26
     */
    @Override
    public List<WebProvince> getMapPath(String token) {
        Integer id = Integer.parseInt(WebTokenUtils.getIdBytoken(token));
        Organization organization = organizationService.getOrganizationByAccountId(id);
        List<MonitorPoint> monitorPoints;
        //判断是否属于超级组织，如果属于超级组织则返回所有存在设备的省市区，否则根据org下的站点进行查询。
        if (dictionaryDataService.querySupperOrgId().equals(organization.getId())) {
            monitorPoints = monitorPointMapper.selectAll();
        } else {
            Integer parentOrgId = organization.getId();
            Set<Integer> childOrgIds = organizationService.getChildOrganizationIds(parentOrgId);
            childOrgIds.add(parentOrgId);
            monitorPoints = monitorPointService.getMonitorPointsByOrganizationIds(childOrgIds);
        }

        Set<Integer> provinceCodesSet = new HashSet<>();
        Set<Integer> cityCodesSet = new HashSet<>();
        Set<Integer> areaCodesSet = new HashSet<>();
        for (MonitorPoint monitorPoint : monitorPoints) {
            provinceCodesSet.add(monitorPoint.getProvinceCode());
            cityCodesSet.add(monitorPoint.getCityCode());
            areaCodesSet.add(monitorPoint.getAreaCode());
        }

        //Set转为List用于排序
        List<Integer> provinceCodes = new ArrayList<>(provinceCodesSet);
        List<Integer> cityCodes = new ArrayList<>(cityCodesSet);
        List<Integer> areaCodes = new ArrayList<>(areaCodesSet);
        provinceCodes.removeAll(Collections.singleton(null));
        cityCodes.removeAll(Collections.singleton(null));
        areaCodes.removeAll(Collections.singleton(null));
        Comparator<Integer> comparator = new ComparatorUtil();
        Collections.sort(provinceCodes, comparator);
        Collections.sort(cityCodes, comparator);
        Collections.sort(areaCodes, comparator);

        List<WebProvince> mapPath = new ArrayList<>();
        for (Integer provinceCode : provinceCodes) {
            String provinceCodeStr = String.valueOf(provinceCode);
            String provinceJSON = (String) redisTemplate.opsForHash().get("province_Map", String.valueOf(provinceCode));
            Province province = JSON.parseObject(provinceJSON).toJavaObject(Province.class);
            WebProvince webProvince = new WebProvince(province.getProvinceCode(), province.getProvinceName(), new ArrayList<>());
            for (Integer cityCode : cityCodes) {
                String cityCodeStr = String.valueOf(cityCode);
                //判断该市是否属于该省
                if (cityCodeStr.substring(0, 2).equals(provinceCodeStr.substring(0, 2))) {
                    String cityJSON = (String) redisTemplate.opsForHash().get("city_Map", String.valueOf(cityCode));
                    City city = JSON.parseObject(cityJSON).toJavaObject(City.class);
                    WebCity WebCity = new WebCity(city.getCityCode(), city.getCityName(), provinceCode, new ArrayList<>());
                    for (Integer areaCode : areaCodes) {
                        String areaCodeStr = String.valueOf(areaCode);
                        if (cityCodeStr.substring(0, 4).equals(areaCodeStr.substring(0, 4))) {
                            String areaJSON = (String) redisTemplate.opsForHash().get("area_Map", String.valueOf(areaCode));
                            Area area = JSON.parseObject(areaJSON).toJavaObject(Area.class);
                            WebCity.getAreas().add(area);
                        }
                    }
                    webProvince.getCities().add(WebCity);
                }
            }
            mapPath.add(webProvince);
        }
        return mapPath;
    }


    /**
     * @Description: 根据组织id，获取该组织地区的定位和类型。
     * @Param: [organization]
     * @return: java.util.Map<java.lang.String                               ,                               java.lang.Object>
     * @Author: 下雨听风
     * @Date: 2020/11/30
     */
    private Map<String, Object> getRegionCodeAndTypeByOrg(Organization organization) {
        Map<String, Object> result = new HashMap<>();
        String regionCode = "";
        String regionType = "";
        Long villageCode = organization.getVillageCode();
        Long townCode = organization.getTownCode();
        Integer areaCode = organization.getAreaCode();
        Integer cityCode = organization.getCityCode();
        Integer provinceCode = organization.getProvinceCode();

        if (!ObjectUtils.isEmpty(areaCode)) {
            regionCode = String.valueOf(areaCode);
            regionType = "areaCode";
        } else if (!ObjectUtils.isEmpty(cityCode)) {
            regionCode = String.valueOf(cityCode);
            regionType = "cityCode";
        } else if (!ObjectUtils.isEmpty(provinceCode)) {
            regionCode = String.valueOf(provinceCode);
            regionType = "provinceCode";
        } else {
            return null;
        }
        result.put("regionCode", regionCode);
        result.put("regionType", regionType);
        return result;
    }

    class ComparatorUtil implements Comparator<Integer> {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o1 - o2;
        }
    }
}