package platform.modules.carrier.service;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.apache.commons.lang3.StringUtils;
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.model.DictionaryItem;
import platform.common.base.service.BaseService;
import platform.common.base.service.DictionaryItemService;
import platform.modules.api.dto.SkyImageCount;
import platform.modules.build.entity.BuildFloor;
import platform.modules.build.service.FloorService;
import platform.modules.carrier.dao.BuildingDao;
import platform.modules.carrier.dto.*;
import platform.modules.carrier.entity.*;
import platform.modules.government.entity.Street;
import platform.modules.government.service.StreetService;
import tk.mybatis.mapper.entity.Example;

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.List;

/**
 * @author kevin
 * @since 2019/3/31 2:48 PM
 */
@Service
@Transactional
public class BuildingService extends BaseService<Building> {

    @Autowired
    private BuildingDao buildingDao;

    @Autowired
    private FloorService floorService;

    @Autowired
    private ParkService parkService;

    @Autowired
    private IcContractService icContractService;

    @Autowired
    private DictionaryItemService dictionaryItemService;

    @Autowired
    private StreetService streetService;

    @Autowired
    private BuildingService buildingService;

    /**
     * 获取园区所有载体
     *
     * @param pageNum
     * @param pageSize
     * @param condition
     * @return
     */
    public PageInfo<Building> getParkBuildings(Integer pageNum, Integer pageSize, SearchCondition condition) {
        PageHelper.startPage(pageNum, pageSize);
        List<Building> buildingList = buildingDao.getParkBuildings(condition);
        for (Building building : buildingList) {
            building.setCarrier_attriute_desc(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.FACTORY_TYPE, building.getCarrier_attriute() + ""));
            building.setBuild_use_desc(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.BUILDING_USES, building.getBuild_use() + ""));
            building.setCarrier_structure_desc(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.CARRIER_STRUCTURE, building.getCarrier_structure() + ""));
            building.setRemain_area(floorService.getReaminAreaByBuildId(building.getId()));

            if (building.getArea() != null){
                building.setSumBuildArea(building.getArea());
            }
            else {
                //楼栋没有建筑面积获取楼层建筑面积
                double totalFloorArea = floorService.getSumFloorArea(building.getId());
                building.setSumBuildArea(totalFloorArea);
            }
            CarrierLibraryResult areaStatistic = buildingService.getBuildAreaStatistic(building.getId());
            if (areaStatistic != null){
                building.setSumRestArea(areaStatistic.getSumRestArea());
            }
            building.setSumRentArea(buildingService.getBuildRentAreaStatistic(building.getId()));
        }
        return new PageInfo<>(buildingList);
    }

    /**
     * 获取园区所有载体
     *
     * @param condition
     * @return
     */
    public List<Building> getBuildings(SearchCondition condition) {
        List<Building> buildingList = buildingDao.getParkBuildings(condition);
        for (Building building : buildingList) {
            DictionaryItem attItem = dictionaryItemService.
                    findByTypeAndValue(Constant.DictionaryType.FACTORY_TYPE, building.getCarrier_attriute());
            DictionaryItem natureItem = dictionaryItemService.
                    findByTypeAndValue(Constant.DictionaryType.FACTORY_NATURE, building.getCarrier_nature().toString());
            building.setCarrier_attriute_desc(attItem.getName());
            building.setCarrier_nature_desc(natureItem.getName());

        }
        return buildingList;
    }

    /**
     * 新增载体
     *
     * @param building
     */
    public void addCarrier(Building building) {
        if (building.getFloorList() != null && building.getFloorList().size() > 0) {
            building.setFloor_count(building.getFloorList().size());
        }
        if (building.getPark_id() != null){
            building.setNo(createBuildingNo(building.getPark_id()));
        }
        int buildId = this.insertAndGetId(building);
        if (building.getFloorList() != null && building.getFloorList().size() > 0) {
            int floorIndex = 0;
            for (BuildFloor floor : building.getFloorList()) {
                floor.setBuild_number(building.getBuild_name());
                floor.setBuild_id(building.getPark_id());
                floor.setBuilding_id(buildId);
                floor.setRemain_area(floor.getArea());
                floor.setNo(createFloorNo(buildId, floorIndex));
                floorService.insertAndGetId(floor);
                floorIndex ++;
            }
        }
    }

    /**
     * 生成楼栋楼层编号
     *
     * @param buildId
     */
    private String createFloorNo(int buildId, Integer floorIndex) {
        String buildNo = findById(buildId).getNo();
        String floorNo;
        if (floorIndex < 10){
            floorNo = buildNo + "F0" + floorIndex;
        }
        else {
            floorNo = buildNo + "F" +floorIndex;
        }
        return floorNo;
    }

    /**
     * 生成园区楼栋编号
     *
     * @param park_id
     */
    private String createBuildingNo(Integer park_id) {
        String parkNo = parkService.findById(park_id).getNo();
        //获取园区载体数
        int buildNum = buildingDao.findBuildingNumByParkId(park_id) + 1;
        String buildNo;
        if (buildNum < 10) {
            buildNo = parkNo + "FB0" + buildNum;
        }
        else {
            buildNo = parkNo + "FB" + buildNum;
        }
        return buildNo;
    }

    /**
     * 载体详情
     *
     * @param id
     * @return
     */
    public Building findBuildingById(Integer id) {
        Building building = this.findById(id);
        if (building != null) {

            if (building.getArea() == null){
                building.setSumBuildArea(building.getArea());
                //楼栋没有建筑面积获取楼层建筑面积
                double totalFloorArea = floorService.getSumFloorArea(building.getId());
                building.setArea(totalFloorArea);
            }
            building.setRemain_area(floorService.getReaminAreaByBuildId(building.getId()));
            building.setRent_area(buildingService.getBuildRentAreaStatistic(building.getId()));

            Park park = parkService.findById(building.getPark_id());
            if (park != null) {
                building.setPark_name(park.getName());
            }
            //获取楼层
            building.setFloorList(floorList(building.getId()));
            building.setCarrier_attriute_desc(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.FACTORY_TYPE, building.getCarrier_attriute() + ""));
            building.setBuild_use_desc(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.BUILDING_USES, building.getBuild_use() + ""));
            building.setCarrier_structure_desc(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.CARRIER_STRUCTURE, building.getCarrier_structure() + ""));
            building.setDriving_type_desc(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.DRIVING_TYPE, building.getDriving_type() + ""));
            building.setDriving_load_desc(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.DRIVING_LOAD, building.getDriving_load() + ""));
            building.setDriving_spqn_desc(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.DRIVING_SPQN, building.getDriving_spqn() + ""));
            building.setFire_rating_desc(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.FIRE_RATING, building.getFire_rating() + ""));
//            building.setBase_setting_desc(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.BASE_SETTING, building.getBase_setting() + ""));
            building.setSpqn_desc(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.SPQN, building.getSpqn() + ""));
        }
        return building;
    }

    /**
     * 编辑载体
     *
     * @param building
     */
    public void editCarrier(Building building) {
        if (building.getFloorList() != null && building.getFloorList().size() > 0) {
            building.setFloor_count(building.getFloorList().size());
        }
        this.updateSelective(building);
        if (building.getFloorList() != null && building.getFloorList().size() > 0) {
            //已有的楼层
            List<BuildFloor> floors = floorList(building.getId());
            List<Integer> oldList = new ArrayList<>();
            for (BuildFloor oldf : floors) {
                oldList.add(oldf.getId());
            }
            List<Integer> diffList = new ArrayList<>(oldList);
            List<Integer> newList = new ArrayList<>();


            List<BuildFloor> floorList = floorService.findFloorsByBuildingId(building.getId());
            int floorIndex = floorList.size() + 1;

            for (BuildFloor newf : building.getFloorList()) {
                if (newf.getId() != null){

                    newList.add(newf.getId());

                    BuildFloor floor = floorService.findById(newf.getId());
                    floor.setArea(newf.getArea());
                    floor.setFloor(newf.getFloor());
                    floor.setCapacity(newf.getCapacity());
                    floor.setFloor_height(newf.getFloor_height());
                    floor.setReason(newf.getReason());
                    floor.setIs_use(newf.getIs_use());
                    floorService.updateFloor(floor);
                }else {
                    newf.setBuilding_id(building.getId());
                    newf.setNo(createFloorNo(building.getId(), floorIndex));
                    newf.setBuild_number(building.getBuild_name());
                    newf.setBuild_id(building.getPark_id());
                    newf.setRemain_area(newf.getArea());
                    floorService.insertAndGetId(newf);
                }
            }

            //差集删除
            diffList.removeAll(newList);
            for (Integer id : diffList) {
                BuildFloor floor = new BuildFloor();
                floor.setDel_flag(true);
                floor.setId(id);
                floorService.updateSelective(floor);
            }
        }
    }

    /**
     * 获取楼层最大下标
     *
     * @param id
     */
    private void getFloorLastIndex(Integer id) {
    }

    /**
     * 获取载体所有楼层
     *
     * @param id
     * @return
     */
    public List<BuildFloor> floorList(Integer id) {
        BuildFloor floor = new BuildFloor();
        floor.setBuilding_id(id);
        floor.setDel_flag(false);
        return floorService.findListByWhere(floor);
    }

    /**
     * 载体查询
     *
     * @param query
     * @return
     */
    public PageInfo<Building> getBuildingsByQuery(CarrierQueryDto query) {
        if (StringUtils.isNotEmpty(query.getDemandTime())){
            LocalDate localDate = LocalDate.now().plusMonths(Integer.parseInt(query.getDemandTime()));
            query.setDemandDate(localDate.toString());
        }
        PageHelper.startPage(query.getPageNum(), query.getPageSize());
        List<Building> buildingList = buildingDao.getBuildingsByQuery(query);
        PageInfo<Building> pageInfo = new PageInfo<>(buildingList);
        if (buildingList != null && buildingList.size() > 0) {
            //符合条件的载体集合
            List<Building> conformList = getComformData(query, buildingList);
            //返回符合条件的结果
            PageInfo comform = new PageInfo<>(conformList);
            comform.setPageNum(query.getPageNum());
            comform.setTotal(pageInfo.getTotal());
            return comform;
        }
        return pageInfo;
    }

    /**
     * 获取符合条件的集合（代码层面）
     *
     * @param query
     * @param buildingList
     */
    public List<Building> getComformData(CarrierQueryDto query, List<Building> buildingList) {

        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        //符合条件的载体集合
        List<Building> conformList = new ArrayList<>();
        String demandTime = query.getDemandTime();
        //入住时长
        int checkinTIme = 0;
        if (query.getCheckinTime() != null){
            checkinTIme = query.getCheckinTime() * 12;
        }
        //最大入住时长
        LocalDate maxCheckin = LocalDate.now();
        if (demandTime != null && !demandTime.equals("")) {
            maxCheckin = LocalDate.now().plusMonths(Integer.parseInt(demandTime));
        }
        //获取已签订但是还没有入住的合同
        for (Building building : buildingList) {

            building.setCarrier_attriute_desc(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.FACTORY_TYPE, building.getCarrier_attriute() + ""));
            building.setBuild_use_desc(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.BUILDING_USES, building.getBuild_use() + ""));
            building.setCarrier_structure_desc(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.CARRIER_STRUCTURE, building.getCarrier_structure() + ""));

            //楼栋符合标记
            Boolean is_conform = true;
            long monthDiff = 0;
            LocalDate earliestCheckinTime = LocalDate.now();
            String maxCheckinTime = "";

            building.setEarliest_checkin_date(earliestCheckinTime.toString());
            //获取楼栋剩余面积
            query.setBuilding_id(building.getId());
            Double remianArea = buildingDao.findBuildingRemainArea(query);
            building.setRemain_area(remianArea);

            //单层
            if (query.getCount() != null && query.getCount() == 1) {
                //楼层信息
                List<BuildFloor> floorList = floorService.findByQuery(building.getId(),query);
                if (floorList != null && floorList.size() > 0) {
                    for (BuildFloor floor : floorList) {
                        Double calArea = 0d;
                        Double reaminArea = floor.getRemain_area();
                        //最小面积
                        if (query.getMinArea() != null && query.getMinArea() > 0) {

                            if (floor.getRemain_area() < query.getMinArea()) {
                                //获取最早入住时间
                                if (StringUtils.isNotEmpty(query.getDemandTime())){
                                    List<ContractFloor> endContractList = icContractService.findEndContractList(query.getDemandDate(), building.getId());
                                    if (endContractList != null && endContractList.size() > 0) {
                                        for (ContractFloor contract : endContractList) {
                                            calArea = reaminArea + contract.getFloor_area();
                                            if (calArea >= query.getMinArea()) {
                                                earliestCheckinTime = LocalDate.parse(contract.getContract_end(), formatter);
                                                break;
                                            }
                                        }
                                    }
                                }
                                //满足面积要求，获取已签订但是还没有入住的合同
                                List<ContractFloor> contractList =
                                        icContractService.findNotStayYet(floor.getId(), building.getId(), query.getDemandDate(), null);
                                if (contractList != null && contractList.size() > 0) {
                                    LocalDate lastCheckoutTime = LocalDate.now();
                                    for (ContractFloor contract : contractList) {
                                        calArea = 0d;
                                        //每次获取合同面积的获取当前时间到期的面积
                                        List<ContractFloor> freedList = icContractService.findEndContractList(contract.getContract_start(), building.getId());
                                        if (freedList != null && freedList.size() > 0){
                                            for (ContractFloor contractFloor : freedList) {
                                                calArea += contractFloor.getFloor_area();
                                            }
                                        }
                                        calArea = calArea - contract.getArea();
                                        //不满足最低需求面积条件
                                        if (calArea <= query.getMinArea()) {
                                            //最晚搬离日期
                                            LocalDate checkoutTime =
                                                    LocalDate.parse(contract.getContract_start(), formatter);
                                            if (lastCheckoutTime.isBefore(checkoutTime)) {
                                                lastCheckoutTime = checkoutTime;
                                            }
                                            maxCheckinTime = lastCheckoutTime.toString();
                                            long monthsDiff = ChronoUnit.MONTHS.between(checkoutTime, maxCheckin);
                                            //获取最大的月数差
                                            if (monthDiff < ChronoUnit.MONTHS.between(maxCheckin, checkoutTime)) {
                                                monthDiff = ChronoUnit.MONTHS.between(maxCheckin, checkoutTime);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    if ((int) monthDiff < checkinTIme) {
                        is_conform = false;
                    }
                }
                else {
                    is_conform = false;
                }
            } else {//多层
                    List<ContractFloor> contractList =
                        icContractService.findNotStayYet(null, building.getId(), query.getDemandDate(), null);
                if (contractList != null && contractList.size() > 0) {
                    Double calArea = 0d;
                    Double reaminArea = buildingDao.findBuildingRemainArea(query);
                    LocalDate lastCheckoutTime = LocalDate.now();
                    for (ContractFloor contract : contractList) {
                        //每次获取合同面积的获取当前时间到期的面积
                        List<ContractFloor> freedList = icContractService.findEndContractList(contract.getContract_start(), building.getId());
                        if (freedList != null && freedList.size() > 0){
                            for (ContractFloor contractFloor : freedList) {
                                calArea += contractFloor.getFloor_area();
                            }
                        }
                        calArea = calArea - contract.getArea();
                        //不满足最低需求面积条件
                        if (query.getMinArea() != null && calArea < query.getMinArea()) {
                            //最晚搬离日期
                            LocalDate checkoutTime = LocalDate.parse(contract.getContract_start(), formatter);
                            if (lastCheckoutTime.isBefore(checkoutTime)) {
                                lastCheckoutTime = checkoutTime;
                            }
                            maxCheckinTime = lastCheckoutTime.toString();
                            long monthsDiff = ChronoUnit.MONTHS.between(checkoutTime, maxCheckin);
                            System.out.println(monthsDiff);
                            //获取最晚搬离日和最晚入住日最大的月数差
                            if (monthDiff < ChronoUnit.MONTHS.between(maxCheckin, checkoutTime)) {
                                monthDiff = ChronoUnit.MONTHS.between(maxCheckin, checkoutTime);
                            }
                        }
                    }
                    //获取最早入住时间
                    if (StringUtils.isNotEmpty(query.getDemandTime())){
                        List<ContractFloor> endContractList = icContractService.findEndContractList(query.getDemandDate(), building.getId());
                        if (endContractList != null && endContractList.size() > 0) {
                            calArea = 0d;
                            for (ContractFloor contract : endContractList) {
                                calArea = reaminArea + contract.getFloor_area();
                                if (calArea >= query.getMinArea()) {
                                    earliestCheckinTime = LocalDate.parse(contract.getContract_end(), formatter);
                                    break;
                                }
                            }
                        }
                    }
                    if ((int) monthDiff < checkinTIme) {
                        is_conform = false;
                    }
                }
            }

            if (is_conform) {
                //最多入住时长
                if (!"".equals(maxCheckinTime)) {
                    building.setMax_checkin_date(dateTimeDiff(earliestCheckinTime.toString(), maxCheckinTime));
                    building.setLatest_departure_date(maxCheckinTime);
                }
                building.setEarliest_checkin_date(earliestCheckinTime.toString());
                conformList.add(building);
            }
        }

        return conformList;
    }

    private void getBuildingsByMoreFloors(
            Building building, CarrierQueryDto query, long monthDiff, String maxCheckinTime,
            LocalDate maxCheckin, Double calArea, LocalDate earliestCheckinTime) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        List<ContractFloor> contractList =
                icContractService.findNotStayYet(null, building.getId(), query.getDemandDate(), null);
        if (contractList != null && contractList.size() > 0) {
            Double reaminArea = building.getRemain_area();
            LocalDate lastCheckoutTime = LocalDate.now();
            for (ContractFloor contract : contractList) {
                reaminArea = reaminArea - contract.getFloor_area();
                //不满足最低需求面积条件
                if (reaminArea <= query.getMinArea()) {
                    //最晚搬离日期
                    LocalDate checkoutTime =
                            LocalDate.parse(contract.getContract_start(), DateTimeFormatter.ofPattern("yyyy-MM-dd"));
                    if (lastCheckoutTime.isBefore(checkoutTime)) {
                        lastCheckoutTime = checkoutTime;
                    }
                    maxCheckinTime = lastCheckoutTime.toString();
                    //获取最大的月数差
                    monthDiff = ChronoUnit.MONTHS.between(checkoutTime, maxCheckin);
                }
            }
            for (ContractFloor contract : contractList) {
                calArea = reaminArea + contract.getFloor_area();
                if (calArea >= query.getMinArea()) {
                    earliestCheckinTime = LocalDate.parse(contract.getContract_end(), formatter);
                    break;
                }
            }
        }

    }
    /**
     * 获取去时间差
     *
     * @param startDate
     * @param endDate
     * @return
     */
    private String dateTimeDiff(String startDate, String endDate) {
//        LocalDate now = LocalDate.now();
        LocalDate start = LocalDate.parse(startDate, DateTimeFormatter.ofPattern("yyyy-MM-dd"));
        LocalDate end = LocalDate.parse(endDate, DateTimeFormatter.ofPattern("yyyy-MM-dd"));
        long monthDiff = ChronoUnit.MONTHS.between(start, end);
        LocalDate pulsTime = LocalDate.now().plusMonths(monthDiff);
//        long dayDiff = ChronoUnit.DAYS.between(start, pulsTime);
        return monthDiff + "月";
    }

    /**
     * 根据园区id 载体名称查询载体
     */
    public PageInfo<BuildingFloorVo> getBuildingsPage(Integer pageNum, Integer pageSize, CustomSearchCondition condition) {
        PageHelper.startPage(pageNum, pageSize);
        List<BuildingFloorVo> buildingList = buildingDao.findBuildingList(condition);
        return new PageInfo<>(buildingList);
    }

    /**
     * 获取方案详情
     *
     * @param id
     * @return
     */
    public Building findCheckinDetail(Integer id, CarrierQueryDto query) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        LocalDate earliestCheckinTime = LocalDate.now();
        String maxCheckinTime = null;
        String demandTime = query.getDemandTime();
        Building building = this.findById(id);
        if (building != null) {
            building.setCarrier_attriute_desc(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.FACTORY_TYPE, building.getCarrier_attriute() + ""));
            building.setBuild_use_desc(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.BUILDING_USES, building.getBuild_use() + ""));
            building.setCarrier_structure_desc(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.CARRIER_STRUCTURE, building.getCarrier_structure() + ""));
            building.setDriving_type_desc(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.DRIVING_TYPE, building.getDriving_type() + ""));
            building.setDriving_load_desc(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.DRIVING_LOAD, building.getDriving_load() + ""));
            building.setDriving_spqn_desc(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.DRIVING_SPQN, building.getDriving_spqn() + ""));
            building.setFire_rating_desc(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.FIRE_RATING, building.getFire_rating() + ""));
//            building.setBase_setting_desc(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.BASE_SETTING, building.getBase_setting() + ""));
            building.setSpqn_desc(dictionaryItemService.findNameByTypeAndValue(Constant.DictionaryType.SPQN, building.getSpqn() + ""));
            //获取楼层
            BuildFloor buildFloor = new BuildFloor();
            buildFloor.setBuilding_id(id);
            buildFloor.setIs_use(true);
            List<BuildFloor> floorList = floorService.findListByWhere(buildFloor);
            if (query.getMinArea() != null || query.getMaxArea() != null) {
                Double calArea;
                if (query.getCount() == 1) {
                    for (BuildFloor floor : floorList) {
                        Double reaminArea = floor.getRemain_area();
                        //最早入住日期
                        List<ContractFloor> endContractList = icContractService.findEndContractList(demandTime, building.getId());
                        if (endContractList != null && endContractList.size() > 0) {
                            for (ContractFloor contract : endContractList) {
                                calArea = reaminArea + contract.getFloor_area();
                                if (calArea >= query.getMinArea()) {
                                    earliestCheckinTime = LocalDate.parse(contract.getContract_end(), formatter);
                                    break;
                                }
                            }
                        }
                        floor.setEarliest_checkin_date(earliestCheckinTime.toString());
                        //最晚搬离日期
                        List<ContractFloor> contractList =
                                icContractService.findNotStayYet(floor.getId(), building.getId(), query.getDemandDate(), null);
                        if (contractList != null && contractList.size() > 0) {
                            for (ContractFloor contract : contractList) {
                                reaminArea = reaminArea - contract.getFloor_area();
                                //不满足最低需求面积条件
                                if (reaminArea <= query.getMinArea()) {
                                    //最晚搬离日期
                                    LocalDate checkoutTime =
                                            LocalDate.parse(contract.getContract_start(), formatter);
                                    maxCheckinTime = checkoutTime.toString();
                                }
                            }
                        }
                        floor.setLatest_departure_date(maxCheckinTime);
                    }
                } else {
                    List<ContractFloor> contractList =
                            icContractService.findNotStayYet(null, building.getId(), query.getDemandDate(), null);
                    if (contractList != null && contractList.size() > 0) {
                        Double reaminArea = building.getRemain_area();
                        LocalDate lastCheckoutTime = LocalDate.now();
                        for (ContractFloor contract : contractList) {
                            reaminArea = reaminArea - contract.getFloor_area();
                            //不满足最低需求面积条件
                            if (reaminArea <= query.getMinArea()) {
                                //最晚搬离日期
                                LocalDate checkoutTime =
                                        LocalDate.parse(contract.getContract_start(), DateTimeFormatter.ofPattern("yyyy-MM-dd"));
                                if (lastCheckoutTime.isBefore(checkoutTime)) {
                                    lastCheckoutTime = checkoutTime;
                                }
                                maxCheckinTime = lastCheckoutTime.toString();
                            }
                        }
                        for (ContractFloor contract : contractList) {
                            calArea = reaminArea + contract.getFloor_area();
                            if (calArea >= query.getMinArea()) {
                                earliestCheckinTime = LocalDate.parse(contract.getContract_end(), formatter);
                                break;
                            }
                        }
                    }
                }
            }
            for (BuildFloor floor : floorList) {
                floor.setLatest_departure_date(maxCheckinTime);
                floor.setEarliest_checkin_date(earliestCheckinTime.toString());
            }
            building.setFloorList(floorList);
            //获取园区基本信息
            Park park = parkService.findById(building.getPark_id());
            Street street = streetService.findById(park.getStreet_id());
            park.setStreetName(street.getName());
            building.setPark(park);
            //合同到期企业
            List<ContractFloor> contractList = icContractService.findEndContractList(demandTime, id);
            building.setContractList(contractList);
        }

        return building;
    }

    public static void main(String[] args) {
        LocalDate maxCheckin = LocalDate.now().plusMonths(24);
        LocalDate now = LocalDate.now();
        System.out.printf(maxCheckin.toString());
        System.out.printf(String.valueOf(ChronoUnit.MONTHS.between(now, maxCheckin)));
    }

    /**
     * 批量修改
     *
     * @param buildingBatchDto
     */
    public Boolean batchUpdate(BuildingBatchDto buildingBatchDto) {
        List<String> ids = buildingBatchDto.getIds();
        if (ids != null && ids.size() > 0) {
            for (String id : ids) {
                //是否有合同
                List<ContractFloor> contracts = icContractService.findByBuildingId(Integer.parseInt(id));
                if (contracts.size() > 0){
                    return false;
                }
                Building building = new Building();
                building.setId(Integer.parseInt(id));
                building.setIs_use(buildingBatchDto.getIsUse());
                building.setReason(buildingBatchDto.getReason());
                updateSelective(building);
            }
        }
        return true;
    }

    /**
     * 批量删除
     *
     * @param ids
     */
    public Boolean batchDelete(List<Integer> ids) {
        if (ids != null && ids.size() > 0) {
            for (Integer id : ids) {
                List<ContractFloor> contracts = icContractService.findByBuildingId(id);
                if (contracts.size() > 0){
                    return false;
                }
                Building building = new Building();
                building.setId(id);
                building.setDel_flag(true);
                updateSelective(building);
            }
        }
        return true;
    }

    /**
     * 根据条件查询载体
     *
     * @param condition
     * @return
     */
    public List<Building> findBuildingByCondition(SearchCondition condition) {
        return buildingDao.findBuildingByCondition(condition);
    }

    /**
     * 地图预警
     *
     * @return
     */
    public List<WarningDto> findUnuseBuilding() {
        Building where = new Building();
//        where.setIs_use(false);
        List<Building> buildingList = findListByWhere(where);
        List<WarningDto> warningDtos = new ArrayList<>();
        if (buildingList.size() > 0) {
            for (Building building : buildingList) {
                WarningDto warning = new WarningDto();
                warning.setId(building.getId());
                warning.setName(building.getBuild_name());
                if (building.getIs_use()) {
                    warning.setState("used");
                } else {
                    warning.setState("unused");
                }
                warningDtos.add(warning);
            }
        }
        return warningDtos;
    }

    @Transactional(readOnly = true)
    public List<Building> findList() {
        Example example = new Example(Building.class);
        Example.Criteria criteria = example.createCriteria();
        criteria.andEqualTo("del_flag", 0);
        //倒序
        //example.orderBy("create_time").desc();
        example.setOrderByClause("id");
        List<Building> buildings = this.selectByExample(example);
        return buildings;
    }

    public int updateNoBatch(List<Building> buildings) {
        return buildingDao.updateNoBatch(buildings);
    }

    /**
     * 载体库楼栋列表
     *
     * @param condition
     * @return
     */
    public List<Building> getBuildingStatistic(SearchCondition condition) {
       return buildingDao.getBuildingStatistic(condition);
    }

    public CarrierLibraryResult getBuildAreaStatistic(Integer id) {
        return buildingDao.getBuildAreaStatistic(id);
    }

    public Integer getBuildingCount(Integer id) {
        return buildingDao.getBuildingCount(id);
    }

    public Double getBuildRentAreaStatistic(Integer id) {
        return buildingDao.getBuildRentAreaStatistic(id);
    }

    /**
     * 根据园区和楼栋名称获取楼栋
     *
     * @param id
     * @param build_number
     * @return
     */
    public Building findByParkIdAndName(Integer id, String build_number) {
        Example example = new Example(Building.class);
        Example.Criteria criteria = example.createCriteria();
        criteria.andEqualTo("del_flag", 0);
        criteria.andEqualTo("build_name", build_number);
        criteria.andEqualTo("park_id", id);
        List<Building> buildings = this.selectByExample(example);
        if (buildings.size() > 0){
            return buildings.get(0);
        }
        return null;
    }

    /**
     * 获取街道所有楼栋
     *
     * @param id
     * @return
     */
    public List<Building> findBySteetId(Integer id) {
        return buildingDao.findBySteetId(id);
    }

    /**
     * 获取街道建筑面积
     *
     * @param id
     * @return
     */
    public Double findStreetTotalArea(Integer id) {
        return buildingDao.findStreetTotalArea(id);
    }

    /**
     * 获取街道建筑面积
     *
     * @param id
     * @return
     */
    public Double findParkTotalArea(Integer id) {
        return buildingDao.findParkTotalArea(id);
    }

    /**
     * 获取载体建筑面积
     *
     * @param id
     * @return
     */
    public Double findBuildingTotalArea(Integer id) {
        return buildingDao.findBuildingTotalArea(id);
    }

    /**
     * 获取园区所有楼栋
     *
     * @param id
     * @return
     */

    public List<Building> findByParkId(Integer id) {
        Building building = new Building();
        building.setIs_use(true);
        building.setPark_id(id);
        return this.findListByWhere(building);
    }

    /**
     * 载体录入面积
     *
     * @param startTime
     * @param endTime
     * @return
     */
    public Double findCarrierEntryArea(String startTime, String endTime) {
        return buildingDao.findCarrierEntryArea(startTime, endTime);
    }

    /**
     * 载体分布（按街道）
     *
     * @param condition
     */
    public List<CarrierDistribution> getStreetBuildingDistribution(SearchCondition condition) {
        return buildingDao.getStreetBuildingDistribution(condition);
    }


    /**
     * 获取厂房面积统计
     *
     * @return
     */
    public List<SkyImageCount> factoryBuildingCount() {
        List<SkyImageCount> list =  buildingDao.factoryBuildingCount();
        for (SkyImageCount skyImageCount : list) {
            if (skyImageCount.getBuildingArea() <= 0){
                //按楼层建筑面积和算
            }
        }
        return list;
    }

    /**
     * 相应时间内合同到期的企业
     *
     * @param startTime
     * @param endTime
     * @return
     */
    public List<SkyImageCount> findEndContractByTime(String startTime, String endTime) {
        return buildingDao.findEndContractByTime(startTime, endTime);
    }

    public Building findByNo(String no) {
        return buildingDao.findByNo(no);
    }
}