package platform.modules.carrier.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import platform.modules.build.entity.BuildFloor;
import platform.modules.build.service.FloorService;
import platform.modules.carrier.entity.Building;
import platform.modules.carrier.entity.Park;
import platform.modules.government.entity.Street;
import platform.modules.government.service.StreetService;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

/**
 * @ClassName IndustralCarrierService
 * @Description TODO
 * @Author huZhiHao
 * @Date 2019/4/19 17:14
 * @Version 1.0
 **/
@Service
@Transactional
public class IndustralCarrierService {

    @Autowired
    private StreetService streetService;

    @Autowired
    private ParkService parkService;

    @Autowired
    private BuildingService buildingService;

    @Autowired
    private FloorService floorService;

    private static String PARK_PREFIX = "IP";

    private static String BUILDING_PREFIX = "FB";

    private static String FLOOR_PREFIX = "F";

    private static String ZERO = "0";

    public void refreshCarrierNumber() {

        List<Street> streets = null;
        List<Park> parks = null;
        List<Building> buildings = null;
        List<BuildFloor> floors = null;
        try {
            streets = streetService.findList();
            parks = parkService.findList();
            buildings = buildingService.findList();
            floors = floorService.findListOrderById();
        } catch (Exception e) {
            e.printStackTrace();
        }

        List<Park> parksNoList = new ArrayList<>();
        List<Building> buildingsNoList = new ArrayList<>();
        List<BuildFloor> floorsNoList = new ArrayList<>();

        if (!CollectionUtils.isEmpty(streets)) {
            //循环街道
            for (Street street : streets) {
                String streetNo = street.getNo();

                if (!CollectionUtils.isEmpty(parks)) {
                    //循环园区
                    int parkCount = 1;
                    for (Park park : parks) {
                        if (Objects.equals(street.getId(), park.getStreet_id())) {
                            String parkNo = streetNo + PARK_PREFIX;
                            if (parkCount <= 9) {
                                parkNo += ZERO + parkCount;
                            } else {
                                parkNo += parkCount;
                            }
                            parkCount++;
                            Park parkEntity = new Park();
                            parkEntity.setId(park.getId());
                            parkEntity.setNo(parkNo);
                            parksNoList.add(parkEntity);

                            if (!CollectionUtils.isEmpty(parks)) {
                                //循环楼栋
                                int buildingCount = 1;
                                for (Building building : buildings) {
                                    if (Objects.equals(park.getId(), building.getPark_id())) {
                                        String buildingNo = parkNo + BUILDING_PREFIX;
                                        if (buildingCount <= 9) {
                                            buildingNo += ZERO + buildingCount;
                                        } else {
                                            buildingNo += buildingCount;
                                        }
                                        buildingCount++;
                                        Building buildingEntity = new Building();
                                        buildingEntity.setId(building.getId());
                                        buildingEntity.setNo(buildingNo);
                                        buildingsNoList.add(buildingEntity);

                                        if (!CollectionUtils.isEmpty(floors)) {
                                            //循环楼层
                                            int floorCount = 1;
                                            for (BuildFloor floor : floors) {
                                                if (Objects.equals(building.getId(), floor.getBuilding_id())) {
                                                    String floorNo = buildingNo + FLOOR_PREFIX;
                                                    if (floorCount <= 9) {
                                                        floorNo += ZERO + floorCount;
                                                    } else {
                                                        floorNo += floorCount;
                                                    }
                                                    floorCount++;
                                                    BuildFloor buildFloor = new BuildFloor();
                                                    buildFloor.setId(floor.getId());
                                                    buildFloor.setNo(floorNo);
                                                    floorsNoList.add(buildFloor);
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            if (!CollectionUtils.isEmpty(parksNoList)) {
                parkService.updateNoBatch(parksNoList);
            }
            if (!CollectionUtils.isEmpty(buildingsNoList)) {
                buildingService.updateNoBatch(buildingsNoList);
            }
            if (!CollectionUtils.isEmpty(floorsNoList)) {
                floorService.updateNoBatch(floorsNoList);
            }
        }
    }
}