package com.mgm.mcrm.allotment.services;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.mgm.mcrm.allotment.dtos.*;
import com.mgm.mcrm.allotment.dtos.daylight.availability.*;
import com.mgm.mcrm.allotment.dtos.daylight.sync.MappingDataCache;
import com.mgm.mcrm.allotment.dtos.daylight.sync.MissMappingLog;
import com.mgm.mcrm.allotment.dtos.request.*;
import com.mgm.mcrm.basesetting.agebucket.models.SysAgebucket;
import com.mgm.mcrm.basesetting.agebucket.services.AgebucketService;
import com.mgm.mcrm.basesetting.room.models.CfgRoomsRoomTypes;
import com.mgm.mcrm.common.dtos.AjaxResult;
import com.mgm.mcrm.common.dtos.CheckCalendarDaylightRequest;
import com.mgm.mcrm.common.dtos.dataimport.appsetting.AppChannelDaylightImportRow;
import com.mgm.mcrm.allotment.mappers.CfgOtherAllotmentMapper;
import com.mgm.mcrm.allotment.mappers.CfgRoomCriteriaDaylightMapper;
import com.mgm.mcrm.allotment.models.*;
import com.mgm.mcrm.allotment.repositories.*;
import com.mgm.mcrm.appsetting.repositories.SettingDao;
import com.mgm.mcrm.basesetting.daylight.dtos.CfgDaylightViewDto;
import com.mgm.mcrm.basesetting.daylight.dtos.CfgExceptionDaylightViewDto;
import com.mgm.mcrm.basesetting.daylight.mappers.CfgDaylightMapper;
import com.mgm.mcrm.basesetting.daylight.mappers.CfgExceptionDaylightMapper;
import com.mgm.mcrm.basesetting.daylight.models.CfgBlockCodes;
import com.mgm.mcrm.basesetting.daylight.models.CfgBlocks;
import com.mgm.mcrm.basesetting.daylight.repositories.*;
import com.mgm.mcrm.basesetting.property.models.CfgProperties;
import com.mgm.mcrm.basesetting.property.repositories.PropertyDao;
import com.mgm.mcrm.basesetting.room.dtos.CfgRoomsRoomTypesDto;
import com.mgm.mcrm.basesetting.room.mappers.RoomTypeMapper;
import com.mgm.mcrm.basesetting.room.models.CfgRoomTypes;
import com.mgm.mcrm.basesetting.room.models.CfgRooms;
import com.mgm.mcrm.basesetting.room.repositories.RoomDao;
import com.mgm.mcrm.basesetting.room.repositories.RoomRoomTypeDao;
import com.mgm.mcrm.basesetting.room.repositories.RoomTypeDao;
import com.mgm.mcrm.basesetting.team.dtos.CfgOtherUserMappingDto;
import com.mgm.mcrm.basesetting.team.mappers.CfgOtherUserMapper;
import com.mgm.mcrm.basesetting.team.repositories.OtherUserMappingDao;
import com.mgm.mcrm.common.constants.SysConstants;
import com.mgm.mcrm.common.dtos.DataTableResult;
import com.mgm.mcrm.common.dtos.ServiceResult;
import com.mgm.mcrm.common.dtos.dataimport.ValidateResult;
import com.mgm.mcrm.common.dtos.excelmodel.GroupItem;
import com.mgm.mcrm.common.dtos.excelmodel.ImportDefine;
import com.mgm.mcrm.common.httpclient.HttpHeaderBuilder;
import com.mgm.mcrm.common.services.HttpService;
import com.mgm.mcrm.common.utils.DaoUtil;
import com.mgm.mcrm.common.utils.DateTimeUtil;
import com.mgm.mcrm.common.utils.ExcelUtils;
import com.mgm.mcrm.reservation.models.BookingsView;
import com.mgm.mcrm.reservation.repositories.BookingViewDao;
import jakarta.annotation.Resource;
import jakarta.persistence.criteria.Predicate;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.hc.core5.http.Header;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;

@Slf4j
@Service
public class RoomCriteriaDaylightService {

	@Resource
	private RoomCriteriaDaylightDao criteriaDaylightDao;
	@Resource
	private RoomCriteriaDaylightViewDao criteriaDaylightViewDao;
	@Resource
	private AppChannelDaylightDao appChannelDaylightDao;
	@Resource
	private SettingDao settingDao;
	@Resource
	private PropertyDao propertyDao;
	@Resource
	private RoomDao roomDao;
	@Resource
	private BlockDao blockDao;
	@Resource
	private RoomTypeDao roomTypeDao;
	@Resource
	private RoomRoomTypeDao roomRoomTypeDao;
	@Resource
	private DaylightMappingRoomTypeDao daylightMappingRoomTypeDao;
	@Resource
	private BlockCodeDao blockCodeDao;
	@Resource
	private BookingViewDao bookingViewDao;
	@Autowired
	private OtherUserMappingDao otherUserMappingDao;
	@Autowired
	private OtherAllotmentViewDao otherAllotmentDao;
	@Resource
	private DaylightViewDao daylightViewDao;
	@Resource
	private ExceptionDaylightViewDao exceptionDaylightViewDao;
	@Resource
	private DaylightRoomTypeAllotmentDao daylightRoomTypeAllotmentDao;
	@Resource
	private CfgRoomCriteriaDaylightMapper cfgRoomCriteriaDaylightMapper;
	@Resource
	private RoomTypeMapper roomTypeMapper;
	@Resource
	private CfgExceptionDaylightMapper cfgExceptionDaylightMapper;
	@Resource
	private CfgDaylightMapper cfgDaylightMapper;
	@Resource
	private CfgOtherAllotmentMapper cfgOtherAllotmentMapper;
	@Resource
	private CfgOtherUserMapper cfgOtherUserMapper;

    @Resource
    private HttpService httpService;

	@Resource
	private AgebucketService agebucketService;

	private final String[] dayNames = {
			"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
	};

	public ServiceResult createRoomCriteria(CfgRoomCriteriaDaylightRequest criteriaRequest) {
		ServiceResult processResult = new ServiceResult();
		LocalDateTime createDate = LocalDateTime.now();
		List<String> dateRange = criteriaRequest.getDateRange();
		LocalDateTime startDate = DateTimeUtil.getDateFromString(String.valueOf(dateRange.get(0)), "yyyy-MM-dd");
		LocalDateTime endDate = DateTimeUtil.getDateFromString(String.valueOf(dateRange.get(1)), "yyyy-MM-dd");
		int numDay = Integer.parseInt(DateTimeUtil.getDiffDate(startDate, endDate, "day"));
		List<String> dow = criteriaRequest.getDow();
		List<CfgAppChannelDaylight> channelList = new ArrayList<CfgAppChannelDaylight>();
        if (criteriaRequest.getBlockCodeChannels() != null && !criteriaRequest.getBlockCodeChannels().isEmpty()) {
            List<BlockCodeChannelDto> blockCodeChannels = criteriaRequest.getBlockCodeChannels();
            for (int i = 0; i < numDay + 1; i++) {
                LocalDateTime bookDate = DateTimeUtil.addDay(startDate, i);
                int bDay = bookDate.getDayOfWeek().getValue();
                if (dow != null) {
                    if (!dow.contains(String.valueOf(bDay))) {
                        continue;
                    }
                }
                CfgRoomCriteriasDaylight criteriaObj = new CfgRoomCriteriasDaylight();
                BeanUtils.copyProperties(criteriaRequest, criteriaObj);
                List<CfgRoomCriteriasDaylight> roomCriteriaList = new ArrayList<CfgRoomCriteriasDaylight>();
                criteriaObj.setId(null);
                criteriaObj.setBookDate(bookDate);
                criteriaObj.setCreatedAt(createDate);
                criteriaObj.setBookDow(bDay);
                List<CfgRoomCriteriasDaylight> existCriteria = criteriaDaylightDao.
                        findByRoomIdAndPropertyIdAndBookDate(criteriaObj.getRoomId(), criteriaObj.getPropertyId(), criteriaObj.getBookDate());
                if (!existCriteria.isEmpty()) {
                    for (CfgRoomCriteriasDaylight ec : existCriteria) {
                        BeanUtils.copyProperties(criteriaObj, ec, "id", "createdAt", "createdBy");
                        ec.setCreatedAt(createDate);
                        criteriaDaylightDao.save(ec);
                        roomCriteriaList.add(ec);
                    }
                } else {
                    CfgRoomCriteriasDaylight newRoomCriteria = criteriaDaylightDao.save(criteriaObj);
                    roomCriteriaList.add(newRoomCriteria);
                }
                for (CfgRoomCriteriasDaylight nc : roomCriteriaList) {
                    for (BlockCodeChannelDto blockCodeChannel : blockCodeChannels) {
                        if (blockCodeChannel.getChannelTotal() == null) {
                            blockCodeChannel.setChannelTotal(0);
                        }
                        CfgAppChannelDaylight channel = appChannelDaylightDao.findByCriteriaIdAndBlockCodeId(nc.getId(), blockCodeChannel.getBlockCodeId());
                        if (channel != null) {
                            channel.setChannelTotal(blockCodeChannel.getChannelTotal());
                            channel.setAvailable(blockCodeChannel.getChannelTotal() - (channel.getPickedUp() == null ? 0 : channel.getPickedUp()));
                        } else {
                            channel = new CfgAppChannelDaylight();
                            channel.setCriteriaId(nc.getId());
                            channel.setBlockCodeId(blockCodeChannel.getBlockCodeId());
                            channel.setChannelTotal(blockCodeChannel.getChannelTotal());
                            channel.setPickedUp(0);
                            channel.setAvailable(blockCodeChannel.getChannelTotal());
                            channel.setCreatedAt(LocalDateTime.now());
                        }
                        channelList.add(channel);
                    }
                }
            }
            if (!channelList.isEmpty()) {
                appChannelDaylightDao.saveAll(channelList);
            }
            processResult.setSuccess(true);
            processResult.setReturnData(criteriaRequest);
        }else{
            processResult.setErrorMessage("Empty BlockCode Channel setting");
            processResult.setSuccess(false);
        }
		return processResult;
	}

	@Transactional
	public ServiceResult updateRoomCriteria(CfgRoomCriteriaDaylightRequest criteriaRequest) {
		ServiceResult processResult = new ServiceResult();
		CfgRoomCriteriasDaylight existsType = criteriaDaylightDao.findById(criteriaRequest.getId()).orElse(null);
		if (existsType == null) {
			processResult.setErrorCode("ERR_OBJECT_NOT_FOUND");
			processResult.setErrorMessage("Can't find Criteria record by Id");
		} else {
			LocalDateTime currentTime = LocalDateTime.now();
			String[] ignoreProperties = new String[]{"id", "category", "createdAt", "createdBy", "updatedAt", "updatedBy"};
			BeanUtils.copyProperties(criteriaRequest, existsType, ignoreProperties);
			if (existsType.getBookDate() != null) {
				existsType.setBookDow(existsType.getBookDate().getDayOfWeek().getValue());
			}
			existsType.setUpdatedAt(currentTime);
			criteriaDaylightDao.save(existsType);
			if (criteriaRequest.getBlockCodeChannels() != null && !criteriaRequest.getBlockCodeChannels().isEmpty()) {
				// 只有在请求明确带了 blockCodeChannels 时，才执行"删除旧→插入新"的 channel 替换流程，
				// 否则保留原有 channel，避免修改 sharer/waitlist 等字段时 channel 被误删。
				appChannelDaylightDao.deleteByCriteriaId(existsType.getId());
                List<BlockCodeChannelDto> blockCodeChannels = criteriaRequest.getBlockCodeChannels();
				for (BlockCodeChannelDto blockCodeChannel :blockCodeChannels) {
					CfgAppChannelDaylight channel = new CfgAppChannelDaylight();
					channel.setCriteriaId(existsType.getId());
					channel.setBlockCodeId(blockCodeChannel.getBlockCodeId());
					Integer channelTotal = blockCodeChannel.getChannelTotal();
					if (channelTotal == null) {
                        channelTotal = 0;
					}
					channel.setChannelTotal(channelTotal);
					channel.setPickedUp(blockCodeChannel.getPickedUp() == null ? 0 : blockCodeChannel.getPickedUp());
					channel.setAvailable(channelTotal > 0 ? (channelTotal - channel.getPickedUp()) : 0);
					channel.setCreatedAt(currentTime);
					appChannelDaylightDao.save(channel);
				}
			}
			processResult.setReturnData(existsType);
			processResult.setSuccess(true);
		}
		return processResult;
	}

	public ServiceResult updateBatchRoomCriteria(JSONArray criterias, Integer type) {
		ServiceResult processResult = new ServiceResult();
		ArrayList<CfgRoomCriteriasDaylight> saveCriterias = new ArrayList<>();
		Calendar calendar = Calendar.getInstance();
		for (int i = 0; i < criterias.size(); i++) {
			CfgRoomCriteriasDaylight updateCriteria = new CfgRoomCriteriasDaylight();
			JSONObject criteria = criterias.getJSONObject(i);
			updateCriteria.setId(criteria.getLong("id"));
			updateCriteria.setBookDate(LocalDateTime.ofInstant(criteria.getDate("bookDate").toInstant(), ZoneId.of("GMT+8")));
			updateCriteria.setBookDow(criteria.getInteger("bookDow"));
			updateCriteria.setPropertyId(criteria.getLong("propertyId"));
			updateCriteria.setRoomId(criteria.getLong("roomId"));
			updateCriteria.setCreatedAt(LocalDateTime.ofInstant(criteria.getDate("createdAt").toInstant(), ZoneId.of("GMT+8")));
			updateCriteria.setCreatedBy(criteria.getString("createdBy"));
			updateCriteria.setSharer(criteria.getInteger("sharer"));
			updateCriteria.setIsWaitlist(criteria.getInteger("isWaitlist"));
			updateCriteria.setRate(criteria.getInteger("rate"));
			if (type == 0) {
				updateCriteria.setSharer(0);
			} else if (type == 1) {
				updateCriteria.setSharer(1);
			} else if (type == 2) {
				updateCriteria.setIsWaitlist(1);
			} else if (type == 3) {
				updateCriteria.setIsWaitlist(0);
			}
			updateCriteria.setUpdatedAt(LocalDateTime.now());
			saveCriterias.add(updateCriteria);
		}

		criteriaDaylightDao.saveAll(saveCriterias);
		processResult.setReturnData(saveCriterias);
		processResult.setSuccess(true);
		return processResult;
	}

	public ServiceResult updateBatchAppChannel(JSONArray channels, JSONObject filter) {
		ServiceResult processResult = new ServiceResult();
		ArrayList<CfgAppChannelDaylight> saveChannel = new ArrayList<CfgAppChannelDaylight>();
		List<CfgRoomCriteriasDaylightView> getCriterias = new ArrayList<>();
		Long propertyId = filter.getLong("searchPropertyId");
		JSONArray bookDate = filter.getJSONArray("searchBookDate");
		LocalDateTime startDate = LocalDateTime.now();
		LocalDateTime endDate = LocalDateTime.now();
		String category = "";
		if (filter.containsKey("searchCategory")) {
			category = filter.getString("searchCategory");
		}
		if (StringUtils.isBlank(category)) {
			category = "BOOKING";
		}
		List roomIds = (List) filter.get("searchRoomId");
		List dow = (List) filter.get("searchDow");
		List<Long> roomId = new ArrayList<>();
		for (int i = 0; i < roomIds.size(); i++) {
			roomId.add(Long.valueOf(String.valueOf(roomIds.get(i))));
		}
		if (bookDate != null) {
			startDate = DateTimeUtil.getDateFromString(String.valueOf(bookDate.get(0)), "yyyy-MM-dd");
			endDate = DateTimeUtil.getDateFromString(String.valueOf(bookDate.get(1)), "yyyy-MM-dd");
		}
		if (propertyId != null && bookDate == null && roomId.isEmpty()) {
			getCriterias = criteriaDaylightViewDao.findByPropertyId(propertyId);
		} else if (propertyId == null && bookDate != null && roomId.isEmpty()) {
			getCriterias = criteriaDaylightViewDao.findByBookDateBetween(startDate, endDate);
		} else if (propertyId == null && bookDate == null && !roomId.isEmpty()) {
			getCriterias = criteriaDaylightViewDao.findByRoomIdIn(roomId);
		} else if (propertyId != null && bookDate != null && roomId.isEmpty()) {
			getCriterias = criteriaDaylightViewDao.findByPropertyIdAndBookDateBetween(propertyId, startDate, endDate);
		} else if (propertyId == null && bookDate != null && !roomId.isEmpty()) {
			getCriterias = criteriaDaylightViewDao.findByRoomIdInAndBookDateBetween(roomId, startDate, endDate);
		} else if (propertyId != null && bookDate == null && !roomId.isEmpty()) {
			getCriterias = criteriaDaylightViewDao.findByRoomIdInAndPropertyId(roomId, propertyId);
		} else if (propertyId != null && bookDate != null && !roomId.isEmpty()) {
			getCriterias = criteriaDaylightViewDao.findByRoomIdInAndPropertyIdAndBookDateBetween(roomId, propertyId, startDate, endDate);
		}

		List<Long> categoryRoomIds;
		if ("WAIT_LIST".equalsIgnoreCase(category)) {
			categoryRoomIds = roomDao.queryWaitlistRoomIds();
		} else {
			categoryRoomIds = roomDao.queryBookingRoomIds();
		}

		if (dow != null) {
			for (int i = 0; i < dow.size(); i++) {
				int num = Integer.parseInt(String.valueOf(dow.get(i)));
				dow.set(i, num);
			}
		}
		for (int i = 0; i < getCriterias.size(); i++) {
			CfgRoomCriteriasDaylightView criteria = getCriterias.get(i);
			if (!categoryRoomIds.contains(criteria.getRoomId())) {
				continue;
			}
			if (dow != null) {
				LocalDateTime getDate = criteria.getBookDate();
				if (!dow.contains(getDate.getDayOfWeek().getValue())) {
					continue;
				}
			}
			Set<CfgAppChannelDaylight> appChannels = criteria.getChannels();
			for (int j = 0; j < channels.size(); j++) {
				JSONObject ch = (JSONObject) channels.get(j);
                CfgAppChannelDaylight appChannel = null;
				Integer channelTotal = ch.getInteger("channelTotal") != null ? ch.getInteger("channelTotal") : 0;
				for (CfgAppChannelDaylight channelItem : appChannels) {
					if (Objects.equals(channelItem.getBlockCodeId(), ch.getLong("blockCodeId"))) {
                        appChannel = channelItem;
                        appChannel.setChannelTotal(channelTotal);
						if (appChannel.getPickedUp() == null) {
                            appChannel.setPickedUp(0);
						}
                        appChannel.setAvailable(channelTotal - appChannel.getPickedUp());
                        break;
					}
				}
				if (appChannel == null) {
                    appChannel = new CfgAppChannelDaylight();
                    appChannel.setCriteriaId(criteria.getId());
                    appChannel.setBlockCodeId(ch.getLong("blockCodeId"));
                    appChannel.setChannelTotal(channelTotal);
                    appChannel.setAvailable(channelTotal);
                    appChannel.setPickedUp(0);
                    appChannel.setCreatedAt(LocalDateTime.now());
				}
				saveChannel.add(appChannel);
			}
		}

		appChannelDaylightDao.saveAll(saveChannel);
		processResult.setReturnData(saveChannel);
		processResult.setSuccess(true);
		return processResult;
	}

	public CfgRoomCriteriasDaylightDto getRoomCriteriaById(long id) {
		CfgRoomCriteriasDaylight criteria = criteriaDaylightDao.findById(id);

		return cfgRoomCriteriaDaylightMapper.toDto(criteria);
	}

	public CfgRoomCriteriasDaylightViewDto getRoomCriteriaViewById(Long id) {
		CfgRoomCriteriasDaylightView criteria = criteriaDaylightViewDao.findById(id).orElse(null);
		return cfgRoomCriteriaDaylightMapper.toViewResponse(criteria);
	}

	public CfgRoomCriteriasDaylight getRoomCriteriaById(String id) {
		return criteriaDaylightDao.getById(id);
	}

	public CfgRoomCriteriasDaylight save(CfgRoomCriteriasDaylight criteria) {
		return criteriaDaylightDao.save(criteria);
	}

	public DataTableResult<CfgRoomCriteriasDaylight> getRoomCriteriaByPage(QueryRoomCriteriaRequest queryFilter) {
		List<Long> categoryRoomIds = this.getCategoryRoomIds(queryFilter.getSearchCategory());
		Specification<CfgRoomCriteriasDaylight> listSpec = buildSpecificationByQueryFilter(queryFilter, categoryRoomIds);
		int pageSize = queryFilter.getPageSize();
		int pageStart = queryFilter.getPageNo();
		Sort sort = DaoUtil.buildSortByString(queryFilter.getSortOrder(), "bookDate-desc");
		Pageable pageable = PageRequest.of(pageStart, pageSize, sort);
		Page<CfgRoomCriteriasDaylight> resultPage = criteriaDaylightDao.findAll(listSpec, pageable);
		DataTableResult<CfgRoomCriteriasDaylight> dataResult = new DataTableResult<>();
		dataResult.setTotalRecords(resultPage.getTotalElements());
		dataResult.setPageSize(pageSize);
		List<CfgRoomCriteriasDaylight> resultList = resultPage.getContent();
		dataResult.setRowData(resultList);
		return dataResult;
	}

	public DataTableResult<CfgRoomCriteriasDaylightViewDto> getRoomCriteriaViewByPage(QueryRoomCriteriaRequest queryFilter) {
		//--先主表找分页，然后再按照分页结果找View的对象
		List<Long> categoryRoomIds = this.getCategoryRoomIds(queryFilter.getSearchCategory());
		Specification<CfgRoomCriteriasDaylight> listSpec = buildSpecificationByQueryFilter(queryFilter, categoryRoomIds);
		int pageSize = queryFilter.getPageSize();
		int pageStart = queryFilter.getPageNo();
		Sort sort = DaoUtil.buildSortByString(queryFilter.getSortOrder(), "bookDate-desc");
		Pageable pageable = PageRequest.of(pageStart, pageSize, sort);
		Page<CfgRoomCriteriasDaylight> resultPage = criteriaDaylightDao.findAll(listSpec, pageable);
		DataTableResult<CfgRoomCriteriasDaylightViewDto> dataResult = new DataTableResult<>();
		dataResult.setTotalRecords(resultPage.getTotalElements());
		dataResult.setPageSize(pageSize);
		List<CfgRoomCriteriasDaylightViewDto> resultList = new ArrayList<>();
		List<CfgRoomCriteriasDaylight> masterPageData = resultPage.getContent();
		if (!masterPageData.isEmpty()) {
			List<Long> ids = new ArrayList<Long>();
			for (CfgRoomCriteriasDaylight item : masterPageData) {
				ids.add(item.getId());
			}
			queryFilter.setPageIds(ids);
			resultList = this.listRoomCriteriasView(queryFilter);
		}
		dataResult.setRowData(resultList);
		return dataResult;
	}

	private List<Long> getCategoryRoomIds(String category) {
		List<Long> result = new ArrayList<>();
		if (StringUtils.isNotBlank(category)) {
			List<Long> cateIds = null;
			if ("WAIT_LIST".equalsIgnoreCase(category)) {
				cateIds = roomDao.queryWaitlistRoomIds();
			} else {
				cateIds = roomDao.queryBookingRoomIds();
			}
			if (cateIds != null && !cateIds.isEmpty()) {
				result = cateIds;
			} else {
				result.add(-1L);
			}
		}
		return result;
	}

	public List<CfgRoomCriteriasDaylight> listRoomCriteria(QueryRoomCriteriaRequest queryFilter) {
		List<Long> categoryRoomIds = this.getCategoryRoomIds(queryFilter.getSearchCategory());
		Specification<CfgRoomCriteriasDaylight> listSpec = buildSpecificationByQueryFilter(queryFilter, categoryRoomIds);
		Sort sort = DaoUtil.buildSortByString(queryFilter.getSortOrder(), "bookDate-desc");
		return criteriaDaylightDao.findAll(listSpec, sort);
	}

	public List<CfgRoomCriteriasDaylightViewDto> listRoomCriteriasView(QueryRoomCriteriaRequest queryFilter) {
		List<Long> categoryRoomIds = this.getCategoryRoomIds(queryFilter.getSearchCategory());
		Specification<CfgRoomCriteriasDaylightView> listSpec = buildSpecificationViewByQueryFilter(queryFilter, categoryRoomIds);
		Sort sort = DaoUtil.buildSortByString(queryFilter.getSortOrder(), "bookDate-desc");
		List<CfgRoomCriteriasDaylightView> resultList = criteriaDaylightViewDao.findAll(listSpec, sort);
		return cfgRoomCriteriaDaylightMapper.toViewDtoList(resultList);
	}

	private Specification<CfgRoomCriteriasDaylight> buildSpecificationByQueryFilter(QueryRoomCriteriaRequest queryFilter, List<Long> cateRoomIds) {
		return (root, criteriaQuery, cb) -> {
			List<Predicate> list = new ArrayList<>();
			if (cateRoomIds != null && !cateRoomIds.isEmpty()) {
				list.add(root.get("roomId").in(cateRoomIds));
			}
			if (queryFilter.getSearchPropertyId() != null) {
				list.add(cb.equal(root.get("propertyId"),
						queryFilter.getSearchPropertyId()));
			}
			if (queryFilter.getSearchBookDate() != null) {
				List<String> dates = queryFilter.getSearchBookDate();
				if (!dates.isEmpty())
					list.add(cb.greaterThanOrEqualTo(root.get("bookDate"), DateTimeUtil.getDateFromString(dates.get(0), "yyyy-MM-dd")));
				if (dates.size() > 1)
					list.add(cb.lessThanOrEqualTo(root.get("bookDate"), DateTimeUtil.getDateFromString(dates.get(1), "yyyy-MM-dd")));
			}
			if (queryFilter.getSearchRoomId() != null) {
				List<Long> roomIds = queryFilter.getSearchRoomId();
				if (!roomIds.isEmpty()) {
					list.add(root.get("roomId").in(roomIds));
				}
			}
			if (queryFilter.getSearchDow() != null) {
				List<Integer> weekDays = queryFilter.getSearchDow();
				if (!weekDays.isEmpty()) {
					list.add(root.get("bookDow").in(weekDays));
				}
			}
			Predicate[] predicates = new Predicate[list.size()];
			criteriaQuery.where(list.toArray(predicates));
			return cb.and(list.toArray(predicates));
		};
	}

	private Specification<CfgRoomCriteriasDaylightView> buildSpecificationViewByQueryFilter(QueryRoomCriteriaRequest queryFilter, List<Long> cateRoomIds) {
		return (root, criteriaQuery, cb) -> {
			List<Predicate> list = new ArrayList<>();
			if (cateRoomIds != null && !cateRoomIds.isEmpty()) {
				list.add(root.get("roomId").in(cateRoomIds));
			}
			if (queryFilter.getSearchPropertyId() != null) {
				list.add(cb.equal(root.get("propertyId"),
						queryFilter.getSearchPropertyId()));
			}
			if (queryFilter.getSearchBookDate() != null) {
				List<String> dates = queryFilter.getSearchBookDate();
				if (!dates.isEmpty())
					list.add(cb.greaterThanOrEqualTo(root.get("bookDate"), DateTimeUtil.getDateFromString(dates.get(0), "yyyy-MM-dd")));
				if (dates.size() > 1)
					list.add(cb.lessThanOrEqualTo(root.get("bookDate"), DateTimeUtil.getDateFromString(dates.get(1), "yyyy-MM-dd")));
			}
			if (queryFilter.getSearchRoomId() != null) {
				List<Long> roomIds = queryFilter.getSearchRoomId();
				if (!roomIds.isEmpty()) {
					list.add(root.get("roomId").in(roomIds));
				}
			}
			if (queryFilter.getSearchDow() != null) {
				List<Integer> weekDays = queryFilter.getSearchDow();
				if (!weekDays.isEmpty()) {
					list.add(root.get("bookDow").in(weekDays));
				}
			}
			if (queryFilter.getPageIds() != null) {
				List<Long> pageIds = queryFilter.getPageIds();
				if (!pageIds.isEmpty()) {
					list.add(root.get("id").in(pageIds));
				}
			}
			Predicate[] predicates = new Predicate[list.size()];
			criteriaQuery.where(list.toArray(predicates));
			return cb.and(list.toArray(predicates));
		};
	}

	public boolean deleteRoomCriteria(CfgRoomCriteriaDaylightRequest criteria) {
		criteriaDaylightDao.deleteById(criteria.getId());
		appChannelDaylightDao.deleteByCriteriaId(criteria.getId());
		return true;
	}

	public Map<String, JSONObject> listRoomCriteriaCalendar(CheckCalendarDaylightRequest checkCalendarRequest) throws Exception {
		Map<String, JSONObject> resultList = new HashMap<>();
		Long bookingTypeId = checkCalendarRequest.getBookingTypeId();
		Long blockCodeId = checkCalendarRequest.getBlockCodeId();
		Long segmentId = checkCalendarRequest.getSegmentId();
		long propertyId = checkCalendarRequest.getPropertyId();
		long roomId = checkCalendarRequest.getRoomId();
		String userId = checkCalendarRequest.getUserId();
		String userName = checkCalendarRequest.getUserName();
		String playerId = checkCalendarRequest.getPlayerId();
		Long teamId = checkCalendarRequest.getTeamId();
		Long bookId = checkCalendarRequest.getBookId();

		//check opera criteria or other criteria
		CfgProperties property = propertyDao.findById(propertyId).orElse(null);
		CfgRooms room = roomDao.findById(roomId);
		boolean isDaylight = false;
		boolean isWaitlist = false;
		if ("DAYLIGHT".equalsIgnoreCase(property.getCategory())) isDaylight = true;
		if (room.getForCreateWaitlist() == 1 && room.getForCreateBooking() == 0) isWaitlist = true;

		if (isDaylight || isWaitlist) {
			resultList = getDaylightCriteria(blockCodeId, teamId, bookingTypeId, propertyId, roomId, userId);
		} else {
			resultList = getOtherCriteria(segmentId, teamId, bookingTypeId, propertyId, roomId);
		}

		if (!resultList.isEmpty()) {
			resultList = checkCriteriaBooking(resultList, playerId, userId, userName, bookId);
		}

		return resultList;
	}

	public Map<String, JSONObject> getDaylightCriteria(Long blockCodeId, Long teamId, Long bookingTypeId, Long propertyId, Long roomId, String userId) throws Exception {
		Long roomTypeId = null;
		List<Long> roomIds = new ArrayList<>();
		roomIds.add(roomId);

		Map<String, JSONObject> resultList = new HashMap<>();
		LocalDateTime today = DateTimeUtil.getCurrentDateTime("yyyy-MM-dd");
		String maxDay = settingDao.getByKeys(SysConstants.MAX_ADVANCE_BOOKING_DAYS).getKeyValues();
		LocalDateTime endDate = DateTimeUtil.addDay(today, Integer.parseInt(maxDay));

		List<CfgDaylightViewDto> teamOpera = new ArrayList<>();
		List<CfgExceptionDaylightViewDto> exceptionOpera = new ArrayList<>();
		// 如果有BedTypeId根据BedTypeId拿到RoomTypeId List后随机,否则按RoomId
		List<CfgRoomsRoomTypesDto> roomTypes = new ArrayList<>();

		if (blockCodeId == null) {
			roomTypes = roomTypeMapper.toCfgRoomsRoomTypesDtoList(roomRoomTypeDao.queryByRoomId(Integer.valueOf(String.valueOf(roomId))));// 该方法可能要改成一个view的直接拿到RoomTypeId和RoomTypeCode
			if (roomTypes != null && !roomTypes.isEmpty()) {
				// 暂时先拿第一个，这里要改成随机算法。拿roomType用得少就用那个要实现平均分配
				roomTypeId = roomTypes.get(0).getRoomTypeId();
			}
			//先从exception opera mapping拿,没有再去 opera mapping拿
			List<CfgExceptionDaylightViewDto> eoperas = cfgExceptionDaylightMapper.toCfgExceptionOperaViewDtoList(exceptionDaylightViewDao.findByUserIdLikeAndPropertyIdAndBookingTypeId("%" + userId + "%", propertyId, Long.valueOf(bookingTypeId)));
			if (!eoperas.isEmpty()) {
				for (CfgExceptionDaylightViewDto o : eoperas) {
					for (CfgRoomTypes r : o.getDaylightRoomType()) {
						if (Objects.equals(r.getId(), roomTypeId)) {
							exceptionOpera.add(o);
						}
					}
				}
			}
			// 筛选出符合条件的opear mapping记录，没有Opera mapping要提示前端配置
			List<CfgDaylightViewDto> operas = cfgDaylightMapper.toCfgDaylightViewDtoList(daylightViewDao.findByPropertyIdAndBookingTypeId(propertyId, Long.valueOf(bookingTypeId)));
			for (CfgDaylightViewDto o : operas) {
				for (CfgRoomTypes r : o.getDaylightRoomType()) {
					if (Objects.equals(r.getId(), roomTypeId)) {
						teamOpera.add(o);
					}
				}
			}
			if (!exceptionOpera.isEmpty()) {
                blockCodeId = exceptionOpera.getFirst().getBlockCodeId();
			} else if (!teamOpera.isEmpty()) {
                blockCodeId = teamOpera.getFirst().getBlockCodeId();
			}
		}

		List<CfgRoomCriteriasDaylightDto> criterias = cfgRoomCriteriaDaylightMapper.toCfgRoomCriteriasDaylightDtoList(criteriaDaylightDao.findByRoomIdInAndPropertyIdAndBookDateBetween(roomIds, propertyId, today, endDate));
		for (CfgRoomCriteriasDaylightDto criteriaItem : criterias) {
			JSONObject res = new JSONObject();
			String bookDate = DateTimeUtil.getDateByFormat(criteriaItem.getBookDate(), "yyyy-MM-dd");
			res.put("bookDate", bookDate);
			res.put("isWaitlist", criteriaItem.getIsWaitlist());
			res.put("sharer", criteriaItem.getSharer());
			CfgAppChannelDaylight channel = new CfgAppChannelDaylight();
			Set<CfgAppChannelDaylight> channels = criteriaItem.getChannels();
			for (CfgAppChannelDaylight a : channels) {
				if (Objects.equals(a.getBlockCodeId(), blockCodeId)) channel = a;
			}
			res.put("available", channel.getAvailable());
			resultList.put(bookDate, res);
		}

		return resultList;
	}

	public Map<String, JSONObject> getOtherCriteria(Long segmentId, Long teamId, Long bookingTypeId, Long propertyId, Long roomId) throws Exception {
		Long roomTypeId = null;
		List<Long> roomIds = new ArrayList<>();
		roomIds.add(roomId);
		LocalDateTime today = DateTimeUtil.getCurrentDateTime("yyyy-MM-dd");
		// 如果today为null，则使用当前时间
		if (today == null) {
			today = LocalDateTime.now();
		}
		String maxDay = settingDao.getByKeys(SysConstants.MAX_ADVANCE_BOOKING_DAYS).getKeyValues();
		String minDay = settingDao.getByKeys(SysConstants.MAX_PREVIOUS_BOOKING_DAYS).getKeyValues();
		LocalDateTime endDate = DateTimeUtil.addDay(today, Integer.parseInt(maxDay));
		LocalDateTime startDate = DateTimeUtil.addDay(today, -Integer.parseInt(minDay));

		Map<String, JSONObject> resultList = new HashMap<>();


		List<CfgOtherUserMappingDto> userMappingList;

		if (segmentId == null) {
			// 筛选出符合条件的 mapping记录
			userMappingList = cfgOtherUserMapper.toCfgOtherUserMappingDtoList(otherUserMappingDao.findByPropertyIdAndBookingTypeId(propertyId, Long.valueOf(bookingTypeId)));

			if (!userMappingList.isEmpty()) {
				segmentId = userMappingList.getFirst().getSegmentId();
			}
		}

		List<CfgOtherAllotmentViewDto> criterias = cfgOtherAllotmentMapper.toCfgOtherAllotmentViewDtos(otherAllotmentDao.findByRoomIdInAndPropertyIdAndBookDateBetween(roomIds, propertyId, startDate, endDate));
		for (CfgOtherAllotmentViewDto c : criterias) {
			JSONObject res = new JSONObject();
			String bookDate = DateTimeUtil.getDateByFormat(c.getBookDate(), "yyyy-MM-dd");
			res.put("bookDate", bookDate);
			res.put("isWaitlist", c.getIsWaitlist());
			res.put("sharer", c.getSharer());
			CfgOtherAppChannelDto channel = new CfgOtherAppChannelDto();
			Set<CfgOtherAppChannelDto> channels = c.getChannels();
			for (CfgOtherAppChannelDto a : channels) {
				if (a.getSegmentId() != null && segmentId != null) {
					if (a.getSegmentId().longValue() == segmentId.longValue()) channel = a;
				}
			}
			res.put("available", channel.getAvailable());
			resultList.put(bookDate, res);
		}

		return resultList;
	}

	private Map<String, JSONObject> checkCriteriaBooking(Map<String, JSONObject> resultList, String playerId, String userId, String userName, Long bookId) throws Exception {
		LocalDateTime today = DateTimeUtil.getCurrentDateTime("yyyy-MM-dd");
		// 如果today为null，则使用当前时间
		if (today == null) {
			today = LocalDateTime.now();
		}
		String maxDay = settingDao.getByKeys(SysConstants.MAX_ADVANCE_BOOKING_DAYS).getKeyValues();
		boolean enableProtection = "1".equals(settingDao.getByKeys(SysConstants.PROTECT_PERIOD_ENABLE).getKeyValues());
		String checkinProtection = settingDao.getByKeys(SysConstants.PROTECTION_PERIOD_CHECKIN).getKeyValues();
		String checkoutProtection = settingDao.getByKeys(SysConstants.PROTECTION_PERIOD_CHECKOUT).getKeyValues();
		LocalDateTime endDate = DateTimeUtil.addDay(today, Integer.parseInt(maxDay));

		List<BookingsView> bookingList = bookingViewDao.getCalendarBooking(endDate, playerId);

		Set<LocalDateTime> protectionPeriod = new HashSet<>();
		Set<LocalDateTime> crPeriod = new HashSet<>();
		for (BookingsView book : bookingList) {
			if (StringUtils.isEmpty(book.getLastOperaStatus()) ||
                    "DUE_IN".equals(book.getLastOperaStatus()) ||
                    "RESERVED".equals(book.getLastOperaStatus()) ||
                    "CHECKED_IN".equals(book.getLastOperaStatus())) {
				// no coded
				boolean differentUser = true;
				if (!StringUtils.isEmpty(book.getCreatedBy())) {
					differentUser = !book.getCreatedBy().equals(userId);
				} else if (!StringUtils.isEmpty(book.getCreatedByName())) {
					differentUser = !book.getCreatedByName().equals(userName);
				}
				boolean isCR = "CCREL".equals(book.getMarketCode());
				if (enableProtection && differentUser) {
					if (Integer.parseInt(checkinProtection) >= 0) {
						for (int q = 0; q <= Integer.parseInt(checkinProtection); q++) {
							LocalDateTime protectCheckin = DateTimeUtil.addDay(book.getCheckinDate(), q);
							protectionPeriod.add(protectCheckin);
							if (isCR) crPeriod.add(protectCheckin);
						}
					} else {
						for (int q = 0; q >= Integer.parseInt(checkinProtection); q--) {
							LocalDateTime protectCheckin = DateTimeUtil.addDay(book.getCheckinDate(), q);
							protectionPeriod.add(protectCheckin);
							if (isCR) crPeriod.add(protectCheckin);
						}
					}
					//change check out date to check in
					if (Integer.parseInt(checkoutProtection) >= 0) {
						for (int q = 0; q <= Integer.parseInt(checkoutProtection); q++) {
							LocalDateTime protectCheckout = DateTimeUtil.addDay(book.getCheckinDate(), Integer.valueOf(q));
							protectionPeriod.add(protectCheckout);
							if (isCR) crPeriod.add(protectCheckout);
						}
					} else {
						for (int q = 0; q >= Integer.parseInt(checkoutProtection); q--) {
							LocalDateTime protectCheckout = DateTimeUtil.addDay(book.getCheckinDate(), Integer.valueOf(q));
							protectionPeriod.add(protectCheckout);
							if (isCR) crPeriod.add(protectCheckout);
						}
					}
				}
				//edit booking 不计算当前booking数
				if (bookId != null && bookId.longValue() == book.getId().longValue()) continue;

				LocalDateTime checkInDate = book.getCheckinDate();
				LocalDateTime checkOutDate = book.getCheckoutDate();

				while (checkInDate.isBefore(checkOutDate)) {
					String getDate = DateTimeUtil.getDateByFormat(checkInDate, "yyyy-MM-dd");
					if (resultList.containsKey(getDate)) {
						JSONObject res = resultList.get(getDate);
						if (StringUtils.isEmpty(book.getLastOperaStatus()) ||
                                "DUE_IN".equals(book.getLastOperaStatus()) ||
                                "RESERVED".equals(book.getLastOperaStatus())) {
							res.put("reserved", 1);
						} else if ("CHECKED_IN".equals(book.getLastOperaStatus())) {
							res.put("staying", 1);
						}
						if ("Mass".equals(book.getBookingTypeName()) && book.getRevisionOf() == null) {
							if ("Standard Room".equals(book.getRoomCategory())) {
								if (res.containsKey("massStandard")) {
									int standareNum = res.getInteger("massStandard") + 1;
									res.put("massStandard", standareNum);
								} else {
									res.put("massStandard", 1);
								}
							}
							if ("Suite".equals(book.getRoomCategory())) {
								if (res.containsKey("massSuite")) {
									int suiteNum = res.getInteger("massSuite") + 1;
									res.put("massSuite", suiteNum);
								} else {
									res.put("massSuite", 1);
								}
							}
						} else if ("IM".equals(book.getBookingTypeName()) && book.getRevisionOf() == null) {
							if (res.containsKey("im")) {
								int suiteNum = res.getInteger("im") + 1;
								res.put("im", suiteNum);
							} else {
								res.put("im", 1);
							}
						}

						resultList.put(getDate, res);
					}
					checkInDate = DateTimeUtil.addDay(checkInDate, 1);
				}
			}

		}
		for (LocalDateTime period : protectionPeriod) {
			String date = DateTimeUtil.getDateByFormat(period, "yyyy-MM-dd");
			if (resultList.containsKey(date)) {
				JSONObject res = resultList.get(date);
				res.put("protection", 1);

				resultList.put(date, res);
			}
		}
		for (LocalDateTime period : crPeriod) {
			String date = DateTimeUtil.getDateByFormat(period, "yyyy-MM-dd");
			if (resultList.containsKey(date)) {
				JSONObject res = resultList.get(date);
				res.put("cr", true);
				resultList.put(date, res);
			}
		}

		return resultList;
	}

	public HashSet<String> listRoomCriteriaAvailableRoom(Map<String, Object> queryParas) {
		HashSet<String> resultList = new HashSet<>();
		List<String> selectDate = (List<String>) queryParas.get("selectDate");
		LocalDateTime checkinDate = DateTimeUtil.getDateFromString(String.valueOf(selectDate.get(0)), "yyyy-MM-dd");
		LocalDateTime checkoutDate = DateTimeUtil.getDateFromString(String.valueOf(selectDate.get(1)), "yyyy-MM-dd");
		Long blockId = Long.valueOf(String.valueOf(queryParas.get("blockId")));
		Long propertyId = Long.valueOf(String.valueOf(queryParas.get("propertyId")));
		Long roomId = Long.valueOf(String.valueOf(queryParas.get("roomId")));
		List<Long> roomIds = new ArrayList<>();
		roomIds.add(roomId);
		String category = queryParas.get("category") != null ? queryParas.get("category").toString() : "";
		if (StringUtils.isBlank(category)) {
			category = "BOOKING";
		}
		List<CfgRoomCriteriasDaylightView> criterias = criteriaDaylightViewDao.findByRoomIdNotInAndPropertyIdAndBookDateBetween(roomIds, propertyId, checkinDate, checkoutDate);
		for (CfgRoomCriteriasDaylightView c : criterias) {
			if (c.getIsWaitlist() == 0) {
				CfgAppChannelDaylight channel = new CfgAppChannelDaylight();
				Set<CfgAppChannelDaylight> channels = c.getChannels();
				for (CfgAppChannelDaylight a : channels) {
					if (a.getBlockCodeId().intValue() == blockId.intValue()) channel = a;
				}
				if (channel.getAvailable() > 0) {
					resultList.add(c.getRoom().getName());
				}

			}

		}
		return resultList;
	}

	private int getMatchPropertyId(List<CfgProperties> properties, String name) {
		int matchId = 0;
		for (CfgProperties item : properties) {
			if (name.equalsIgnoreCase(item.getName())) {
				matchId = item.getId().intValue();
				break;
			}
		}
		return matchId;
	}

	private long getMatchRoomId(List<CfgRooms> roomCates, String name, Long propertyId) {
		long matchId = 0;
		for (CfgRooms item : roomCates) {
			int pId = 0;
			if (propertyId != null) {
				pId = Integer.valueOf(String.valueOf(propertyId));
			}
			if (name.equalsIgnoreCase(item.getName()) && pId == item.getPropertyId().intValue()) {
				matchId = item.getId().intValue();
				break;
			}
		}
		return matchId;
	}

	private long getMatchBlockCodeId(List<CfgBlockCodes> blockCodes, String name) {
		long matchId = 0;
		for (CfgBlockCodes item : blockCodes) {
			if (name.equalsIgnoreCase(item.getCode())) {
				matchId = item.getId();
				break;
			}
		}
		return matchId;
	}


	private ValidateResult validateImportData(List<RoomCriteriaDaylightImportRow> roomCriteriaList, String category) {
		ValidateResult result = new ValidateResult();
		int totalRows = 0;
		int failedRows = 0;
		int successRows = 0;
		Map<String, String> uniqueKeys = new HashMap<String, String>();
		if (!roomCriteriaList.isEmpty()) {
			List<Long> categoryRoomIds = new ArrayList<Long>();
			if (category.equalsIgnoreCase("WAIT_LIST")) {
				categoryRoomIds = roomDao.queryWaitlistRoomIds();
			} else {
				categoryRoomIds = roomDao.queryBookingRoomIds();
			}
			SimpleDateFormat dtFormat = new SimpleDateFormat("yyyy-MM-dd");
			totalRows = roomCriteriaList.size();
			List<CfgProperties> propertyList = propertyDao.findAll();
			List<CfgRooms> roomList = roomDao.findAll();
			List<CfgBlockCodes> blockCodeList = blockCodeDao.findAll();
			if (!propertyList.isEmpty()) {
				for (int i = 0; i < propertyList.size(); i++) {
					CfgProperties pItem = propertyList.get(i);
					if (!"DAYLIGHT".equalsIgnoreCase(pItem.getCategory())) {
						propertyList.remove(i);
						i--;
					}
				}
			}
			for (int i = 0; i < roomCriteriaList.size(); i++) {
				String errMsg = "";
				boolean isPassed = true;
				RoomCriteriaDaylightImportRow pItem = roomCriteriaList.get(i);
				if (StringUtils.isBlank(pItem.getPropertyName())) {
					errMsg += "Property Name is blank;";
					isPassed = false;
				} else {
					int propertyId = this.getMatchPropertyId(propertyList, pItem.getPropertyName());
					if (propertyId > 0) {
						pItem.setPropertyId((long) propertyId);
					} else {
						errMsg += "No match Property of [" + pItem.getPropertyName() + "];";
						isPassed = false;
					}
				}
				if (StringUtils.isBlank(pItem.getBookDateText())) {
					errMsg += "Date is blank;";
					isPassed = false;
				} else {
					LocalDateTime bookDate = null;
					try {
						if (DateTimeUtil.isValidDate(pItem.getBookDateText())) {
							bookDate = DateTimeUtil.getDateFromString(pItem.getBookDateText(), "yyyy-MM-dd");
						}
					} catch (Exception ignored) {

					}
					if (bookDate != null) {
						pItem.setBookDate(bookDate);
					} else {
						errMsg += "Date value should be yyyy-mm-dd format;";
						isPassed = false;
					}
				}
				if (StringUtils.isBlank(pItem.getRoomCategory())) {
					errMsg += "Room Group is blank;";
					isPassed = false;
				} else {
					long roomId = this.getMatchRoomId(roomList, pItem.getRoomCategory(), pItem.getPropertyId());
					if (roomId > 0) {
						pItem.setRoomId(roomId);
						if (!categoryRoomIds.contains(pItem.getRoomId())) {
							errMsg += ("Room Group [" + pItem.getRoomCategory() + "] is not for create " +
									("WAIT_LIST".equalsIgnoreCase(category) ? "wait list" : "booking") + ";");
							isPassed = false;
						}
					} else {
						errMsg += "No match Room Group of [" + pItem.getRoomCategory() + "];";
						isPassed = false;
					}
				}
				if (isPassed) {
					String bizKey = pItem.getPropertyId() + "-" + pItem.getBookDateText() + "-" + pItem.getRoomCategory();
					if (uniqueKeys.containsKey(bizKey)) {
						errMsg += "Duplicate records [" + pItem.getPropertyName() + "--" + pItem.getBookDateText() + "--" + pItem.getRoomCategory() + "] in list";
						isPassed = false;
					} else {
						uniqueKeys.put(bizKey, bizKey);
					}
				}
				if (isPassed) {
					if ("BOOKING".equalsIgnoreCase(category)) {
						if (StringUtils.isBlank(pItem.getSharerValue())) {
							errMsg += "Sharer Flag is blank;";
							isPassed = false;
						} else {
							if ("YES".equalsIgnoreCase(pItem.getSharerValue())) {
								pItem.setSharerFlag(1);
							} else if ("NO".equalsIgnoreCase(pItem.getSharerValue())) {
								pItem.setSharerFlag(0);
							} else {
								errMsg += "Sharer should be value of [Yes/No];";
								isPassed = false;
							}
						}
					}
					if (StringUtils.isBlank(pItem.getWaitListValue())) {
						errMsg += "Waitlist Flag is blank;";
						isPassed = false;
					} else {
						if ("YES".equalsIgnoreCase(pItem.getWaitListValue())) {
							pItem.setWaitlistFlag(1);
						} else if ("NO".equalsIgnoreCase(pItem.getWaitListValue())) {
							pItem.setWaitlistFlag(0);
						} else {
							errMsg += "Waitlist should be value of [Yes/No];";
							isPassed = false;
						}
					}
					int rate = 0;
					try {
						rate = Integer.parseInt(pItem.getRateValue());
					} catch (Exception err) {

					}
					pItem.setRate(rate);
				}
				if (isPassed && "BOOKING".equalsIgnoreCase(category)) {
					List<AppChannelDaylightImportRow> appChannelRows = pItem.getChannelList();
					if (appChannelRows != null && !appChannelRows.isEmpty()) {
						for (AppChannelDaylightImportRow channelRow : appChannelRows) {
							if (StringUtils.isBlank(channelRow.getBlockCodeName())) {
								errMsg += "Empty Block Code;";
								isPassed = false;
							} else {
								long blockCodeId = this.getMatchBlockCodeId(blockCodeList, channelRow.getBlockCodeName());
								if (blockCodeId > 0) {
									channelRow.setBlockCodeId(blockCodeId);
								} else {
									errMsg += "No Match Block name [" + channelRow.getBlockCodeName() + "];";
									isPassed = false;
								}
								if (StringUtils.isBlank(channelRow.getChannelTotalVal())) {
									channelRow.setChannelTotal(0);
								} else {
									try {
										channelRow.setChannelTotal(Integer.parseInt(channelRow.getChannelTotalVal()));
									} catch (Exception err) {
										errMsg += "Invalid number of app channel for block code [" + channelRow.getBlockCodeName() + "];";
										isPassed = false;
									}
								}
							}
						}
					} else {
						errMsg += "No any app channel is set;";
						isPassed = false;
					}
				}
				if (isPassed) {
					if (criteriaDaylightDao.countByKeys(pItem.getPropertyId(), pItem.getBookDate(), pItem.getRoomId()) > 0) {
						errMsg += "Record exists";
						isPassed = false;
					}
				}
				pItem.setValidatePassed(isPassed);
				pItem.setErrorMessage(errMsg);
				if (isPassed)
					successRows++;
				else
					failedRows++;
			}
			//--
		}
		result.setResultCount(totalRows);
		result.setPassedCount(successRows);
		result.setFailedCount(failedRows);
		result.setResultRows(roomCriteriaList);
		return result;
	}


	public ServiceResult parseImportExcel(String importFilePath, String category) {
		ServiceResult result = new ServiceResult();
		String importName = "WAIT_LIST".equalsIgnoreCase(category) ? "IMPORT_WAITLIST_CRITERIA" : "IMPORT_ROOM_CRITERIA";
		ImportDefine importDef = ExcelUtils.getImportDefineByName(importName);
		if (importDef != null) {
			List<CfgBlocks> blocks = blockDao.findAll();
			List<GroupItem> blockItems = new ArrayList<GroupItem>();
			for (CfgBlocks block : blocks) {
				GroupItem groupItem = new GroupItem();
				groupItem.setItemText(block.getName());
				groupItem.setItemKey(block.getId().toString());
				groupItem.setHeaderIndex(1);
				blockItems.add(groupItem);
			}
			Map<String, List<GroupItem>> groupInfos = new HashMap<>();
			groupInfos.put("CHANNEL_GROUP", blockItems);
			ServiceResult importResult = ExcelUtils.importDataBlock(importDef, importFilePath, groupInfos);
			if (!importResult.isSuccess()) {
				result.setSuccess(false);
				result.setErrorMessage(importResult.getErrorMessage());
			} else {
				if (importResult.getReturnData() != null) {
					List<Object> dataList = (List<Object>) importResult.getReturnData();
					if (!dataList.isEmpty()) {
						List<RoomCriteriaDaylightImportRow> roomCriteriaList = (List<RoomCriteriaDaylightImportRow>) dataList.getFirst();
						ValidateResult validateRes = validateImportData(roomCriteriaList, category);
						if (validateRes.getResultCount() > 0) {
							result.setSuccess(true);
							validateRes.setGroupItems(groupInfos.get("CHANNEL_GROUP"));
							result.setReturnData(validateRes);
						} else {
							result.setSuccess(false);
							result.setErrorMessage("No import data detected");
						}
					} else {
						result.setSuccess(false);
						result.setErrorMessage("No import data detected");
					}
				} else {
					result.setSuccess(false);
					result.setErrorMessage("Empty import data");
				}
			}
		} else {
			result.setSuccess(false);
			result.setErrorMessage("Import [" + importName + "] not defined");
		}
		return result;
	}

	public ServiceResult importBatch(List<RoomCriteriaDaylightImportRow> importRows, String category) {
		ServiceResult result = new ServiceResult();
		if (importRows != null && !importRows.isEmpty()) {
			ValidateResult validateRes = validateImportData(importRows, category);
			if (validateRes.getResultCount() > 0 && validateRes.getFailedCount() <= 0) {
				LocalDateTime currentTime = LocalDateTime.now();
				List<CfgAppChannelDaylight> newAppChannelList = new ArrayList<CfgAppChannelDaylight>();
                for (RoomCriteriaDaylightImportRow pItem : importRows) {
                    CfgRoomCriteriasDaylight newRoomCriteria = new CfgRoomCriteriasDaylight();
                    newRoomCriteria.setPropertyId(pItem.getPropertyId());
                    newRoomCriteria.setBookDate(pItem.getBookDate());
                    newRoomCriteria.setRoomId(pItem.getRoomId());
                    newRoomCriteria.setRate(pItem.getRate());
                    newRoomCriteria.setIsWaitlist(pItem.getWaitlistFlag());
                    newRoomCriteria.setSharer(pItem.getSharerFlag());
                    newRoomCriteria.setCreatedAt(currentTime);
                    newRoomCriteria.setUpdatedAt(currentTime);
                    newRoomCriteria.setBookDow(newRoomCriteria.getBookDate().getDayOfWeek().getValue());
                    criteriaDaylightDao.save(newRoomCriteria);
                    if ("BOOKING".equalsIgnoreCase(category)) {
                        List<AppChannelDaylightImportRow> channelRows = pItem.getChannelList();
                        for (AppChannelDaylightImportRow channelRow : channelRows) {
                            CfgAppChannelDaylight appChannel = new CfgAppChannelDaylight();
                            appChannel.setCriteriaId(newRoomCriteria.getId());
                            appChannel.setBlockCodeId(channelRow.getBlockCodeId());
                            appChannel.setChannelTotal(channelRow.getChannelTotal());
                            appChannel.setPickedUp(0);
                            appChannel.setAvailable(appChannel.getChannelTotal());
                            newAppChannelList.add(appChannel);
                        }
                    }
                }
				if (!newAppChannelList.isEmpty()) {
					appChannelDaylightDao.saveAll(newAppChannelList);
				}
				result.setSuccess(true);
			} else {
				result.setSuccess(false);
				result.setErrorMessage("Import data validate failed");
				result.setReturnData(validateRes);
			}
		} else {
			result.setSuccess(false);
			result.setErrorMessage("Empty import data");
		}
		return result;
	}

	public List<CfgRoomCriteriasDaylightViewDto> listRoomCriteriasViewToExport(QueryRoomCriteriaRequest queryFilter) {
		DateTimeFormatter dtFormat = DateTimeFormatter.ofPattern("yyyy-MM-dd");
		List<CfgRoomCriteriasDaylightViewDto> listRoomCriteriaView = this.listRoomCriteriasView(queryFilter);
		for (CfgRoomCriteriasDaylightViewDto exportItem : listRoomCriteriaView) {
			//--Set special content for export
			if (exportItem.getProperty() != null) {
				exportItem.setPropertyName(exportItem.getProperty().getName());
			}
			if (exportItem.getBookDate() != null) {
				exportItem.setBookDateText(dtFormat.format(exportItem.getBookDate()));
			}
			if (exportItem.getBookDow() != null) {
				try {
					int dayIndex = exportItem.getBookDow();
					if (dayIndex >= 1 && dayIndex <= 7) {
						exportItem.setBookWeekDay(this.dayNames[dayIndex - 1]);
					}
				} catch (Exception ignored) {

				}
			}
			if (exportItem.getRoom() != null) {
				exportItem.setRoomCategory(exportItem.getRoom().getName());
				List<CfgRoomTypes> roomTypes = exportItem.getRoom().getRoomRoomType();
				if (roomTypes != null) {
					StringBuilder roomTypeNames = new StringBuilder();
					for (CfgRoomTypes roomType : roomTypes) {
						if (!roomTypeNames.toString().isEmpty()) {
							roomTypeNames.append(",");
						}
						roomTypeNames.append(roomType.getCode());
					}
					exportItem.setRoomTypeNames(roomTypeNames.toString());
				}
			}
			Set<CfgAppChannelDaylight> appChannels = exportItem.getChannels();
			List<CfgAppChannelDaylight> appChannelList = new ArrayList<CfgAppChannelDaylight>();
			if (appChannels != null && !appChannels.isEmpty()) {
				appChannelList.addAll(appChannels);
			}
			exportItem.setChannelList(appChannelList);
			exportItem.setRateValue(String.valueOf(exportItem.getRate()));
			exportItem.setSharerValue(exportItem.getSharer() != null && exportItem.getSharer() > 0 ? "Yes" : "No");
			exportItem.setWaitListValue(exportItem.getIsWaitlist() != null && exportItem.getIsWaitlist() > 0 ? "Yes" : "No");
		}
		return listRoomCriteriaView;
	}

    //-- Catch mapping data to reduce
    private Map<String,Long> cacheDlRoomTypeMapping(){
        Map<String,Long> cacheData = new HashMap<String,Long>();
        List<CfgRoomTypes> dlRoomTypes = roomTypeDao.findAllByDlRoomTypeIdIsNotNull();
        for(CfgRoomTypes roomType: dlRoomTypes){
            cacheData.put(roomType.getDlRoomTypeId(),roomType.getId());
        }
        return cacheData;
    }

    private Map<Long, Long> cachePropertyRoomCategory(Long propertyId){
        Map<Long, Long> cacheData = new HashMap<Long,Long>();
        List<CfgRoomsRoomTypes> propertyRoomMappings = roomRoomTypeDao.queryPropertyRoomMapping(propertyId);
        for(CfgRoomsRoomTypes roomRoomType: propertyRoomMappings){
            cacheData.put(roomRoomType.getRoomTypeId(),roomRoomType.getRoomId());
        }
        return cacheData;
    }

    private Map<String,Long> cacheDlBlockCodeMapping(Long propertyId){
        Map<String,Long> cacheData = new HashMap<String,Long>();
        List<CfgBlockCodes> dlBlockCodes = blockCodeDao.findAllByPropertyIdAndDlBlockIdIsNotNull(propertyId);
        for(CfgBlockCodes blockCode: dlBlockCodes){
            cacheData.put(blockCode.getDlBlockId(),blockCode.getId());
        }
        return cacheData;
    }

    public void calculateDaylightAllotment(DlAllotmentUpdateRequest syncRequest) {
        if(syncRequest!=null){
            CfgRoomCriteriasDaylight roomAllotment = null;
            List<CfgRoomCriteriasDaylight> roomCriterias = criteriaDaylightDao.findByRoomIdAndPropertyIdAndBookDate(
                    syncRequest.getRoomId(),
                    syncRequest.getPropertyId(),
                    syncRequest.getCalendarDate().atStartOfDay()
            );
            if(!roomCriterias.isEmpty()){
                roomAllotment = roomCriterias.getFirst();
                if(roomCriterias.size()>1){
                    //-- Remove duplicated records if has
                    for(int i=1;i<roomCriterias.size();i++){
                        criteriaDaylightDao.delete(roomCriterias.get(i));
                    }
                }
            }
            LocalDateTime currentTime = LocalDateTime.now();
            if(roomAllotment==null){
                roomAllotment = new CfgRoomCriteriasDaylight();
                roomAllotment.setPropertyId(syncRequest.getPropertyId());
                roomAllotment.setBookDate(syncRequest.getCalendarDate().atStartOfDay());
                roomAllotment.setRoomId(syncRequest.getRoomId());
                roomAllotment.setRate(0);
                roomAllotment.setIsWaitlist(0);
                roomAllotment.setSharer(1);
                roomAllotment.setCreatedAt(currentTime);
                roomAllotment.setUpdatedAt(currentTime);
                roomAllotment.setBookDow(roomAllotment.getBookDate().getDayOfWeek().getValue());
                criteriaDaylightDao.save(roomAllotment);
            }
            Long allotmentId = roomAllotment.getId();
            //--
            DaylightRoomTypeAllotmentDao.DaylightBlockCodeAllotmentSum roomAllotmentSum = daylightRoomTypeAllotmentDao.countRoomTypeAllotmentByBlockCode(
                    syncRequest.getCalendarDate().format(DateTimeFormatter.ofPattern("yyyy-MM-dd")),
                    syncRequest.getPropertyId(),
                    syncRequest.getRoomId(),
                    syncRequest.getBlockCodeId()
            );
            CfgAppChannelDaylight appChannel=null;
            List<CfgAppChannelDaylight> existAppChannels = appChannelDaylightDao.findAllByCriteriaIdAndBlockCodeId(allotmentId,syncRequest.getBlockCodeId());
            if(!existAppChannels.isEmpty()){
                appChannel = existAppChannels.getFirst();
                for(int i=1;i<existAppChannels.size();i++){
                    appChannelDaylightDao.delete(existAppChannels.get(i));
                }
            }
            if(appChannel==null){
                appChannel = new CfgAppChannelDaylight();
                appChannel.setCriteriaId(allotmentId);
                appChannel.setBlockCodeId(syncRequest.getBlockCodeId());
                appChannel.setCreatedAt(LocalDateTime.now());
                appChannel.setCreatedSource(syncRequest.getUpdateSource());
            }
            appChannel.setChannelTotal(roomAllotmentSum.getChannelTotal());
            appChannel.setPickedUp(roomAllotmentSum.getPickedUp());
            appChannel.setAvailable(roomAllotmentSum.getAvailable());
            appChannelDaylightDao.save(appChannel);
        }
    }

    public AjaxResult syncCalendarAllotment(SyncDaylightAllotmentRequest syncRequest) {
        AjaxResult result = new AjaxResult();
        try {
            CfgProperties cfgProperty = propertyDao.findByDlPropertyId(syncRequest.getDlPropertyId());
            if (cfgProperty == null) {
                result.setSuccess(false);
                result.setMessage("No property config match with this dlPropertyId ["+syncRequest.getDlPropertyId()+"]");
                return result;
            }
            if (syncRequest.getDlBlockCodeIds()==null || syncRequest.getDlBlockCodeIds().isEmpty()) {
                result.setSuccess(false);
                result.setMessage("Daylight Block Code ID list can not be null or empty");
                return result;
            }

			SysAgebucket sysAgebucket = agebucketService.getSysAgebucket(syncRequest.getDlPropertyId());
			syncRequest.setAgeBucketId(sysAgebucket.getDlAgeBucketId());

			Long propertyId = cfgProperty.getId();
            MappingDataCache cacheMapping = new MappingDataCache();
            cacheMapping.setCacheRoomTypeIds(this.cacheDlRoomTypeMapping());
            cacheMapping.setCachePropertyRoomCate(this.cachePropertyRoomCategory(propertyId));
            cacheMapping.setCacheBlockCodes(this.cacheDlBlockCodeMapping(propertyId));

            String url = "/api-gateway/data-api/v1/blocks/availability";
            Header[] headers = HttpHeaderBuilder.create()
                    .contentType("application/json")
                    .ac_property_id(syncRequest.getDlPropertyId())
                    .build();

            Map<String, Object> queryParams = new HashMap<>();
            queryParams.put("blockIds", String.join(",", cacheMapping.getCacheBlockCodes().keySet()));
            queryParams.put("startDate", syncRequest.getFromDate());
            queryParams.put("endDate", syncRequest.getToDate());

            String responseContent = httpService.sslGet(url, headers, queryParams);
            DlBlockAvailabilityResponse responseData = JSONObject.parseObject(responseContent, DlBlockAvailabilityResponse.class);

            if(responseData == null || responseData.getResults() == null){
                result.setSuccess(false);
                result.setMessage(responseContent);
                return result;
            }

            List<DlAllotmentUpdateRequest> calculateRequests = new ArrayList<>();
            MissMappingLog missMappingLog = new MissMappingLog();

            for (BlockAvailabilityResult blockResult : responseData.getResults()) {
                List<DlAllotmentUpdateRequest> changeItems = this.processBlockAvailabilityResult(
                        syncRequest.getDlPropertyId(),
                        propertyId,
                        blockResult,
                        cacheMapping,
                        missMappingLog);
                calculateRequests.addAll(changeItems);
            }

            if (!missMappingLog.getMissDlRoomTypeIds().isEmpty()) {
                for(String missDlRoomTypeId:missMappingLog.getMissDlRoomTypeIds()){
                    log.warn("[SYNC_CALENDAR]No Room Type config match with daylight ID[{}]",missDlRoomTypeId);
                }
            }
            if (!missMappingLog.getMissRoomCateIds().isEmpty()) {
                for(Long missRoomCateId:missMappingLog.getMissRoomCateIds()){
                    log.warn("[SYNC_CALENDAR]No Room Category(RoomId) config match with room type ID[{}]",missRoomCateId);
                }
            }
            if (!missMappingLog.getMissBlockCodeIds().isEmpty()) {
                for(String missDlBlockCodeId:missMappingLog.getMissBlockCodeIds()){
                    log.warn("[SYNC_CALENDAR]No Block code config match with daylight ID[{}]",missDlBlockCodeId);
                }
            }
            if(!calculateRequests.isEmpty()){
                for(DlAllotmentUpdateRequest calculateRequest:calculateRequests){
                    this.calculateDaylightAllotment(calculateRequest);
                }
                result.setMessage("["+calculateRequests.size()+"] Allotment Calendar Entries is(are) updated");
            }else{
                result.setMessage("No Allotment Calendar Entry is updated");
            }
            result.setSuccess(true);
        } catch (Exception err) {
            result.setSuccess(false);
            result.setMessage("Failed to Sync DayLight Allotment:"+err.getMessage());
            log.error("Failed to Sync DayLight Allotment :{}", err.getMessage());
        }
        return result;
    }

    private List<DlAllotmentUpdateRequest> processBlockAvailabilityResult(String dlPropertyId,
                                                                         Long propertyId,
                                                                         BlockAvailabilityResult blockResult,
                                                                         MappingDataCache cacheMapping,
                                                                         MissMappingLog missMappingLog) {
        List<DlAllotmentUpdateRequest> calculateRequests = new ArrayList<>();
        String dlBlockCodeId = blockResult.getId();
        String allotmentDateVal = blockResult.getDate();
        if (blockResult.getRoomTypeAvailabilities() == null) return calculateRequests;

        Map<String, Long> cacheRoomTypeIds = cacheMapping.getCacheRoomTypeIds();
        Map<String, Long> cacheBlockCodes = cacheMapping.getCacheBlockCodes();
        Map<Long, Long> cacheRoomCate = cacheMapping.getCachePropertyRoomCate();
        Set<String> calculateKeys = new HashSet<>();

        List<CfgDlRoomTypeAllotment> allExistingAllotments = daylightRoomTypeAllotmentDao.queryAllotmentByPropertyAndBlockCodeAndDate(dlPropertyId, dlBlockCodeId, allotmentDateVal);
        Map<String, List<CfgDlRoomTypeAllotment>> existingAllotmentMap = allExistingAllotments.stream()
                .collect(Collectors.groupingBy(CfgDlRoomTypeAllotment::getDaylightRoomTypeId));

        List<CfgDlRoomTypeAllotment> toSaveList = new ArrayList<>();
        List<CfgDlRoomTypeAllotment> toDeleteList = new ArrayList<>();

        for (RoomTypeAvailability rtAvail : blockResult.getRoomTypeAvailabilities()) {
            String dlRoomTypeId = rtAvail.getRoomTypeId();
            AllocationVariants variants = rtAvail.getAllocationVariants();
            if (variants == null) continue;

            int available = variants.getAvailable() != null ? Math.max(variants.getAvailable(), 0) : 0;
            int deducted = variants.getCreatesDeduct() != null ? Math.max(variants.getCreatesDeduct(), 0) : 0;

            Long roomTypeId = null;
            Long blockCodeId = null;
            Long roomId = null;

            if (StringUtils.isNotBlank(dlRoomTypeId)) {
                roomTypeId = cacheRoomTypeIds.get(dlRoomTypeId);
                if (roomTypeId != null) {
                    roomId = cacheRoomCate.get(roomTypeId);
                    if (roomId == null && !missMappingLog.getMissRoomCateIds().contains(roomTypeId)) {
                        missMappingLog.getMissRoomCateIds().add(roomTypeId);
                    }
                } else {
                    if (!missMappingLog.getMissDlRoomTypeIds().contains(dlRoomTypeId)) {
                        missMappingLog.getMissDlRoomTypeIds().add(dlRoomTypeId);
                    }
                }
            }

            if (StringUtils.isNotBlank(dlBlockCodeId)) {
                blockCodeId = cacheBlockCodes.get(dlBlockCodeId);
                if (blockCodeId == null && !missMappingLog.getMissBlockCodeIds().contains(dlBlockCodeId)) {
                    missMappingLog.getMissBlockCodeIds().add(dlBlockCodeId);
                }
            }

            CfgDlRoomTypeAllotment matchAllotment = null;
            List<CfgDlRoomTypeAllotment> roomAllotments = existingAllotmentMap.getOrDefault(dlRoomTypeId, new ArrayList<>());
            if (!roomAllotments.isEmpty()) {
                matchAllotment = roomAllotments.getFirst();
                for (int i = 1; i < roomAllotments.size(); i++) {
                    toDeleteList.add(roomAllotments.get(i));
                }
            }
            if (matchAllotment == null) {
                matchAllotment = new CfgDlRoomTypeAllotment();
                matchAllotment.setAllotmentDate(allotmentDateVal);
                matchAllotment.setDaylightPropertyId(dlPropertyId);
                matchAllotment.setDaylightRoomTypeId(dlRoomTypeId);
                matchAllotment.setDaylightBlockCodeId(dlBlockCodeId);
                matchAllotment.setPropertyId(propertyId);
                matchAllotment.setRoomTypeId(roomTypeId);
                matchAllotment.setBlockCodeId(blockCodeId);
                matchAllotment.setCreatedAt(LocalDateTime.now());
            }

            matchAllotment.setAllNonDeduct(available);
            matchAllotment.setAllDeduct(deducted - available);
            matchAllotment.setTotalRooms(deducted);
            matchAllotment.setUpdatedAt(LocalDateTime.now());
            matchAllotment.setUpdateSource("SYNC_CALENDAR");
            toSaveList.add(matchAllotment);

            if (roomId != null && propertyId != null && blockCodeId != null) {
                String allotmentKey = allotmentDateVal + "-" + propertyId + "-" + roomId + "-" + blockCodeId;
                if (!calculateKeys.contains(allotmentKey)) {
                    DlAllotmentUpdateRequest syncUpdateReq = new DlAllotmentUpdateRequest();
                    syncUpdateReq.setPropertyId(propertyId);
                    syncUpdateReq.setBlockCodeId(blockCodeId);
                    syncUpdateReq.setRoomId(roomId);
                    syncUpdateReq.setCalendarDate(LocalDate.parse(allotmentDateVal, DateTimeFormatter.ofPattern("yyyy-MM-dd")));
                    syncUpdateReq.setUpdateSource("SYNC_CALENDAR");
                    calculateRequests.add(syncUpdateReq);
                    calculateKeys.add(allotmentKey);
                }
            }
        }

        if (!toSaveList.isEmpty()) {
            daylightRoomTypeAllotmentDao.saveAll(toSaveList);
        }
        if (!toDeleteList.isEmpty()) {
            daylightRoomTypeAllotmentDao.deleteAllInBatch(toDeleteList);
        }

        return calculateRequests;
    }

}