package platform.modules.carrier.service;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import platform.common.Constant;
import platform.common.base.service.DictionaryItemService;
import platform.common.util.ShiroUtils;
import platform.modules.build.service.FloorService;
import platform.modules.carrier.dto.CarrierLibraryResult;
import platform.modules.carrier.dto.SearchCondition;
import platform.modules.carrier.entity.*;
import platform.modules.government.entity.User;
import platform.modules.government.service.StreetService;

import java.math.BigDecimal;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author kevin
 * @since 2019/4/23 4:05 PM
 */
@Service
@Transactional
public class CarrierStatisticService {

    @Autowired
    private StreetService streetService;

    @Autowired
    private ParkService parkService;

    @Autowired
    private BuildingService buildingService;

    @Autowired
    private DictionaryItemService dictionaryItemService;

    @Autowired
    private FloorService floorService;

    @Autowired
    private InvestmentInfoService investmentInfoService;

    @Autowired
    private ContractFloorService contractFloorService;


    /**
     * 载体库街道列表
     *
     * @param pageNum
     * @param pageSize
     * @return
     */
    @Transactional(readOnly = true)
    public PageInfo getStreetStatistic(Integer pageNum, Integer pageSize) {
        SearchCondition condition = new SearchCondition();
        userTypeConditon(condition);

        PageHelper.startPage(pageNum, pageSize);
        List<CarrierLibraryResult> libraryResults = streetService.getStreetStatistic(condition);
        for (CarrierLibraryResult result : libraryResults) {
            Double sumRentArea = streetService.getStreetRentAreaStatistic(result.getId());
            result.setSumRentArea(sumRentArea);
            //楼栋建筑面积为空，按楼层建筑面积和算，楼层建筑面积为空按，楼层已租、代租只和算
            Double sumBuildArea = getSumStreetBuildingArea(result.getId());
            result.setSumBuildArea(sumBuildArea);
        }
        return new PageInfo<>(libraryResults);
    }

    /**
     * 载体库街道列表
     *
     * @param pageNum
     * @param pageSize
     * @return
     */
    @Transactional(readOnly = true)
    public Map<String, Object> getWechatStreetStatistic(Integer pageNum, Integer pageSize) {
        SearchCondition condition = new SearchCondition();
        userTypeConditon(condition);

        PageHelper.startPage(pageNum, pageSize);
        List<CarrierLibraryResult> libraryResults = streetService.getStreetStatistic(condition);
        //总的租住面积
        Double totalRentArea = 0d;
        Double totalRestArea = 0d;
        for (CarrierLibraryResult result : libraryResults) {
            Double sumRentArea = streetService.getStreetRentAreaStatistic(result.getId());
            result.setSumRentArea(sumRentArea);
            totalRentArea += sumRentArea;
            //楼栋建筑面积为空，按楼层建筑面积和算，楼层建筑面积为空按，楼层已租、代租只和算
            Double sumBuildArea = getSumStreetBuildingArea(result.getId());
            result.setSumBuildArea(sumBuildArea);
            totalRestArea += result.getSumRestArea();
        }

        Map<String, Object> map = new HashMap<>();
        map.put("pageInfo", new PageInfo<>(libraryResults));
        map.put("totalRentArea", toScale2(totalRentArea));
        map.put("totalRestArea", toScale2(totalRestArea));
        return map;
    }

    /**
     * 获取街道建筑面积
     *
     * @param id
     * @return
     */
    public Double getSumStreetBuildingArea(Integer id) {
        Double sumBuildArea = buildingService.findStreetTotalArea(id);
//        List<Building> buildings = buildingService.findBySteetId(id);
//        for (Building building : buildings) {
//            if (building.getArea() != null){
//                sumBuildArea += building.getArea();
//            }
//            else {
//                //楼栋没有建筑面积获取楼层建筑面积
//                double totalFloorArea = floorService.getSumFloorArea(building.getId());
//                sumBuildArea += totalFloorArea;
//            }
//        }
        return new BigDecimal(sumBuildArea).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    /**
     * 获取园区建筑面积
     *
     * @param id
     * @return
     */
    public Double getSumParkBuildingArea(Integer id) {
        Double sumBuildArea = buildingService.findParkTotalArea(id);
//        List<Building> buildings = buildingService.findByParkId(id);
//        for (Building building : buildings) {
//            if (building.getArea() != null){
//                sumBuildArea += building.getArea();
//            }
//            else {
//                //楼栋没有建筑面积获取楼层建筑面积
//                double totalFloorArea = floorService.getSumFloorArea(building.getId());
//                sumBuildArea += totalFloorArea;
//            }
//        }
        return new BigDecimal(sumBuildArea).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    /**
     * 获取用户角色条件
     *
     * @param condition
     */
    private void userTypeConditon(SearchCondition condition) {
        User user = ShiroUtils.getUserEntity();
        if (user.getUser_type() != null && user.getUser_type().equals(Constant.UserType.STREET)){
            condition.setStreetId(user.getStreet_id());
        }
        if (user.getUser_type() != null && user.getUser_type().equals(Constant.UserType.BUILD)){
            condition.setParkId(user.getBuild_id());
        }
    }

    /**
     * 载体库园区列表
     *
     * @param pageNum
     * @param pageSize
     * @param street_id
     * @return
     */
    @Transactional(readOnly = true)
    public PageInfo<CarrierLibraryResult> getParkStatistic(Integer pageNum, Integer pageSize, Integer street_id) {
        PageHelper.startPage(pageNum, pageSize);
        List<CarrierLibraryResult> libraryResults = parkService.getParkStatistic(street_id);
        for (CarrierLibraryResult result : libraryResults) {
            double sumBuildingArea = getSumParkBuildingArea(result.getId());
            result.setSumBuildArea(sumBuildingArea);
            Double sumRentArea = parkService.getParkRentAreaStatistic(result.getId());
            result.setSumRentArea(sumRentArea);
            //获取载体数
//            result.setBuildingNum(buildingService.getBuildingCount(result.getId()));
        }
        return new PageInfo<>(libraryResults);
    }

    /**
     * 载体库园区列表
     *
     * @param pageNum
     * @param pageSize
     * @param street_id
     * @return
     */
    @Transactional(readOnly = true)
    public Map<String, Object> getWechatParkStatistic(Integer pageNum, Integer pageSize, Integer street_id) {
        PageHelper.startPage(pageNum, pageSize);
        List<CarrierLibraryResult> libraryResults = parkService.getParkStatistic(street_id);
        Double totalRentArea = 0d;
        Double totalRestArea = 0d;
        for (CarrierLibraryResult result : libraryResults) {
            double sumBuildingArea = getSumParkBuildingArea(result.getId());
            result.setSumBuildArea(sumBuildingArea);
            Double sumRentArea = parkService.getParkRentAreaStatistic(result.getId());
            result.setSumRentArea(sumRentArea);

            totalRentArea += sumRentArea;
            totalRestArea += result.getSumRestArea();
        }
        Map<String, Object> map = new HashMap<>();
        map.put("pageInfo", new PageInfo<>(libraryResults));
        map.put("totalRentArea", totalRentArea);
        map.put("totalRestArea", totalRestArea);
        return map;
    }

    /**
     * 载体库载体列表
     *
     * @param pageNum
     * @param pageSize
     * @param condition
     * @return
     */
    @Transactional(readOnly = true)
    public PageInfo<Building> getBuildingStatistic(Integer pageNum, Integer pageSize, SearchCondition condition) {
        PageHelper.startPage(pageNum, pageSize);
        List<Building> buildingList = buildingService.getBuildingStatistic(condition);
        for (Building building : buildingList) {
            building.setBuild_use_desc(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.BUILDING_USES, building.getBuild_use() + ""));
            building.setCarrier_attriute_desc(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.FACTORY_TYPE, building.getCarrier_attriute() + ""));
            if (building.getArea() != null){
                building.setSumBuildArea(building.getArea());
            }
            else {
                //楼栋没有建筑面积获取楼层建筑面积
//                double totalFloorArea = floorService.getSumFloorArea(building.getId());
//                building.setSumBuildArea(totalFloorArea);
                building.setSumBuildArea(buildingService.findBuildingTotalArea(building.getId()));
            }
            CarrierLibraryResult areaStatistic = buildingService.getBuildAreaStatistic(building.getId());
            if (areaStatistic != null){
                building.setSumRestArea(areaStatistic.getSumRestArea());
            }
//            Double sumRentArea = parkService.getParkRentAreaStatistic(building.getPark_id());
            building.setSumRentArea(buildingService.getBuildRentAreaStatistic(building.getId()));
        }
        return new PageInfo<>(buildingList);
    }

    /**
     * 载体库载体列表
     *
     * @param pageNum
     * @param pageSize
     * @param condition
     * @return
     */
    @Transactional(readOnly = true)
    public Map<String, Object> getWechatBuildingStatistic(Integer pageNum, Integer pageSize, SearchCondition condition) {
        PageHelper.startPage(pageNum, pageSize);
        List<Building> buildingList = buildingService.getBuildingStatistic(condition);
        Double totalRentArea = 0d;
        Double totalRestArea = 0d;
        for (Building building : buildingList) {
            building.setBuild_use_desc(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.BUILDING_USES, building.getBuild_use() + ""));
            building.setCarrier_attriute_desc(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.FACTORY_TYPE, building.getCarrier_attriute() + ""));
            if (building.getArea() != null){
                building.setSumBuildArea(building.getArea());
            }
            else {
                //楼栋没有建筑面积获取楼层建筑面积
                building.setSumBuildArea(buildingService.findBuildingTotalArea(building.getId()));
            }
            CarrierLibraryResult areaStatistic = buildingService.getBuildAreaStatistic(building.getId());
            if (areaStatistic != null){
                building.setSumRestArea(areaStatistic.getSumRestArea());
                totalRestArea += areaStatistic.getSumRestArea();
            }
            building.setSumRentArea(buildingService.getBuildRentAreaStatistic(building.getId()));
            totalRentArea += buildingService.getBuildRentAreaStatistic(building.getId());
        }
        Map<String, Object> map = new HashMap<>();
        map.put("pageInfo", new PageInfo<>(buildingList));
        map.put("totalRentArea", totalRentArea);
        map.put("totalRestArea", totalRestArea);
        return map;
    }

    /**
     * 载体库街道列表统计
     *
     * @return
     */
    public Map<String, Double> findTotalStreetStatistic() {
        Double totalBuildArea = 0d;
        Double totalRestArea = 0d;
        Double totalRentArea = 0d;
        Double totalParks = 0d;
        SearchCondition conditon = new SearchCondition();
        List<CarrierLibraryResult> libraryResults = streetService.getStreetStatistic(conditon);
        for (CarrierLibraryResult result : libraryResults) {
            Double sumBuildArea = getSumStreetBuildingArea(result.getId());
            totalBuildArea += sumBuildArea;

            totalRestArea += result.getSumRestArea();
            Double sumRentArea = streetService.getStreetRentAreaStatistic(result.getId());
            if (sumRentArea != null){
                totalRentArea += sumRentArea;
            }
            totalParks = totalParks + result.getParkNum();
        }
        Map<String, Double> map = new HashMap<>();
        map.put("totalBuildArea", new BigDecimal(totalBuildArea).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        map.put("totalRentArea", new BigDecimal(totalRentArea).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        map.put("totalRestArea", new BigDecimal(totalRestArea).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        map.put("totalParks", new BigDecimal(totalParks).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        return map;
    }


    /**
     * 载体库园区列表
     *
     * @param id
     * @return
     */
    @Transactional(readOnly = true)
    public Map<String, Double> findTotalParkStatistic(Integer id) {
        Double totalBuildArea = 0d;
        Double totalRestArea = 0d;
        Double totalRentArea =0d;
        Integer totalBuildingNum =0;
        List<CarrierLibraryResult> libraryResults = parkService.getParkStatistic(id);
        for (CarrierLibraryResult result : libraryResults) {
            Double sumBuildArea = getSumParkBuildingArea(result.getId());
            totalBuildArea += sumBuildArea;
            totalRestArea += result.getSumRestArea();
            Double sumRentArea = parkService.getParkRentAreaStatistic(result.getId());
            if (sumRentArea != null){
                totalRentArea += sumRentArea;
            }
            totalBuildingNum += result.getBuildingNum();
        }
        Map<String, Double> map = new HashMap<>();
        map.put("totalBuildArea", new BigDecimal(totalBuildArea).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        map.put("totalRentArea", new BigDecimal(totalRentArea).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        map.put("totalRestArea", new BigDecimal(totalRestArea).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        map.put("totalBuildingNum", new BigDecimal(totalBuildingNum).setScale(0, BigDecimal.ROUND_HALF_UP).doubleValue());
        return map;
    }

    /**
     * 统计
     *
     * @param startTime
     * @param endTime
     * @return
     */
    public CarrierStatistic getCarrierStatistic(String startTime, String endTime) {
        CarrierStatistic statistic = new CarrierStatistic();
        Double carrierEntryArea = buildingService.findCarrierEntryArea(startTime, endTime);
        statistic.setBuildingEntryArea(carrierEntryArea);
        Double investmentArea = investmentInfoService.findInvestmentArea(startTime, endTime);
        statistic.setInvestmentArea(investmentArea);
        Integer volume = contractFloorService.findCarrierVolume(startTime, endTime);
        statistic.setVolume(volume);
        //载体空置与招商发布
        List<InvestmentDistribution> distributions = investmentInfoService.findEachParkInvestmentArea(startTime, endTime);
        statistic.setInvestmentDistributions(distributions);
        //成交量
        List<CarrierVolume> eachParkVolume = contractFloorService.findEachParkVolume(startTime, endTime);
        statistic.setCarrierVolumes(eachParkVolume);
        return statistic;
    }

    /**
     * 载体分布
     *
     * @param condition
     */
    public CarrierStatistic getStreetBuildingDistribution(SearchCondition condition) {
        CarrierStatistic statistic = new CarrierStatistic();
        List<CarrierDistribution> distributions = buildingService.getStreetBuildingDistribution(condition);
        statistic.setDistributions(distributions);
        double distributionArea = 0d;
        int buildingCount = 0;
        for (CarrierDistribution distribution : distributions) {
            distributionArea += distribution.getBuildingArea();
            buildingCount += distribution.getBuildingCount();
        }
        statistic.setBuildingCount(buildingCount);
        statistic.setDistributionArea(toScale2(distributionArea));
        return statistic;
    }

    /**
     * double去两位小数
     *
     * @param data
     * @return
     */
    public Double toScale2(Double data){
        return new BigDecimal(data).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
    }
}