package com.zteits.park.dao.impl;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;

import org.apache.commons.collections4.CollectionUtils;
import com.clouds.common.cache.park.ParkingLotCacheUtil;
import com.clouds.common.constants.ParkConstant.OptFlag;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.zteits.clouds.api.apibase.constants.DataStatusEnum;
import com.zteits.clouds.api.apibase.constants.ErrorType;
import com.zteits.clouds.api.apibase.exception.BizException;
import com.zteits.clouds.api.dto.order.parkorder.param.ParkOrderUpdateCarNumberReq;
import com.zteits.clouds.api.dto.park.dto.BerthsDTO;
import com.zteits.clouds.api.dto.park.dto.ParkOccupancyRateDTO;
import com.zteits.clouds.api.dto.park.dto.ParkingLotDTO;
import com.zteits.clouds.api.dto.park.dto.berth.BerthsStatisticDTO;
import com.zteits.clouds.api.dto.park.param.CheckUniqueForBerthNoRequest;
import com.zteits.clouds.api.dto.park.param.DeleteBerthsRequest;
import com.zteits.clouds.api.dto.park.param.QueryBerthForPageRequest;
import com.zteits.clouds.api.dto.park.param.parksource.QueryParkSourceByOrgIdsRequest;
import com.zteits.clouds.api.dto.pda.param.*;
import com.zteits.clouds.api.dto.rocketmq.datacollection.freeberths.ParkAreaFreeBerthsMsgVO;
import com.zteits.park.constant.BerthConstant;
import com.zteits.park.constant.ParkConstant;
import com.zteits.park.dao.BerthsDao;
import com.zteits.park.dao.TpPRegionAreaDao;
import com.zteits.park.domain.ParkingLot;
import com.zteits.park.domain.ParkingLotExample;
import com.zteits.park.domain.TpPBerths;
import com.zteits.park.domain.TpPBerthsDO;
import com.zteits.park.domain.TpPBerthsExample;
import com.zteits.park.domain.TpPBerthsExample.Criteria;
import com.zteits.park.domain.TpPRegionArea;
import com.zteits.park.mapper.ParkingLotMapper;
import com.zteits.park.mapper.TpPBerthsMapper;
import com.zteits.park.mapper.smapper.TpPBerthsSMapper;
import com.zteits.park.mapper.smapper.TpPEqpSMapper;
import com.zteits.park.service.berths.oper.ParkFreeBerthOperInnerService;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

@Component
public class BerthsDaoImpl implements BerthsDao {

    @Autowired
    private TpPBerthsMapper tpPBerthsMapper;
    @Autowired
    private TpPBerthsSMapper tpPBerthsSMapper;
    @Autowired
    private ParkingLotMapper parkingLotMapper;
    @Autowired
    private ParkFreeBerthOperInnerService parkFreeBerthBizService;
    @Autowired
    private TpPRegionAreaDao tpPRegionAreaDao;
    @Autowired
    private TpPEqpSMapper tpPEqpSMapper;

    @Override
    @Deprecated
    public TpPBerths updateBerthByBerthNoForFangGe(String isOccupy, Date reportTime, String recordId, String berthNo) {
        //判断车位编号是否唯一
        TpPBerthsExample example = new TpPBerthsExample();
        example.createCriteria().andBerthNoEqualTo(berthNo)
            .andDataStateEqualTo(DataStatusEnum.DATA_STATUS_VALID.value());
        List<TpPBerths> berths = tpPBerthsMapper.selectByExample(example);
        if (CollectionUtils.isEmpty(berths)) {
            throw new BizException(ErrorType.BIZ_ERROR, "根据车位编号更新车位状态失败，车位编号[" + berthNo + "]不存在");
        }
        if (berths.size() > 1) {
            throw new BizException(ErrorType.BIZ_ERROR, "根据车位编号更新车位状态失败，车位编号[" + berthNo + "]存在多条,无法判断更新某个");
        }
        //根据车位编号更新
        TpPBerths tdPBerths = berths.get(0);
        tdPBerths.setIsOccupy(isOccupy);
        if (isOccupy.equals(BerthConstant.isOccupy.HAVE_CAR)) {
            tdPBerths.setEqpInTime(reportTime);
        } else {
            tdPBerths.setEqpOutTime(reportTime);
        }
        tdPBerths.setOrderId(recordId);
        if (tdPBerths.getModifyTime() == null) {
            tdPBerths.setModifyTime(new Date());
        }
        tdPBerths.setOptFlg(ParkConstant.OptFlag.MODIFY);
        tpPBerthsMapper.updateByPrimaryKeySelective(tdPBerths);
        return tdPBerths;
    }

    @Override
    public int insertBerthInfo(TpPBerths tpPBerths) {
        int i = tpPBerthsMapper.insertSelective(tpPBerths);
        //更新停车场泊位数-空闲车位数
        this.updateParkBerthNum(tpPBerths.getPlNo());
        return i;
    }

    @Override
    public int updateBerthInfoByBerthNoAndPlNo(TpPBerths tpPBerths) {
        if (StringUtils.isBlank(tpPBerths.getPlNo()) || StringUtils.isBlank(tpPBerths.getBerthNo())) {
            return 0;
        }
        TpPBerthsExample example = new TpPBerthsExample();
        example.createCriteria().andBerthNoEqualTo(tpPBerths.getBerthNo())
            .andPlNoEqualTo(tpPBerths.getPlNo())
            .andDataStateEqualTo(DataStatusEnum.DATA_STATUS_VALID.value());
        return tpPBerthsMapper.updateByExampleSelective(tpPBerths, example);
    }

    @Override
    public Map<String, Long> queryParkBerthNum(List<String> plNos) {
        TpPBerthsExample example = new TpPBerthsExample();
        example.createCriteria().andPlNoIn(plNos)
            .andDataStateEqualTo(DataStatusEnum.DATA_STATUS_VALID.value());
        List<TpPBerths> tpPBerths = tpPBerthsMapper.selectByExample(example);
        return Optional.ofNullable(tpPBerths).orElse(new ArrayList<>()).stream().collect(
            Collectors.groupingBy(TpPBerths::getPlNo, Collectors.counting()));
    }

    @Override
    public Long queryFreeBerthNum(String plNo, String where) {
        return tpPBerthsSMapper.queryFreeBerthNum(plNo, where);
    }

    @Override
    public Boolean updateBerthInfoById(TpPBerths tpPBerths) {
        if (tpPBerths.getModifyTime() == null) {
            tpPBerths.setModifyTime(new Date());
        }
        tpPBerths.setOptFlg(ParkConstant.OptFlag.MODIFY);

        return tpPBerthsMapper.updateByPrimaryKeySelective(tpPBerths) > 0;
    }

    @Override
    public Boolean updateBerthBusiInfoStatus(DeleteBerthsRequest request) {

        TpPBerthsExample example = new TpPBerthsExample();
        example.createCriteria().andIdIn(request.getIds());

        TpPBerths record = new TpPBerths();
        record.setModifyOp(request.getOpId());
        record.setModifyTime(new Date());
        record.setOptFlg(ParkConstant.OptFlag.MODIFY);
        record.setDataState(request.getBerthBusiStatus());
        int num = tpPBerthsMapper.updateByExampleSelective(record, example);


        List<TpPBerths> berths = tpPBerthsMapper.selectByExample(example);

        List<String> plNos = berths.parallelStream().map(a->a.getPlNo()).distinct().collect(Collectors.toList());

        for(String plNo:plNos){
            this.updateParkBerthNum(plNo);
        }

        return num > 0;
    }

    @Override
    public Boolean batDeleteBerthsById(List<Long> ids, Long modifyOp, String plNo) {
        //判断要删除的泊位是否有在停车辆，是否已经关联了地磁，如果有则不允许删除
        List<TpPBerthsDO> tpPBerthsDOs = tpPBerthsSMapper.queryNotAllowDeleteBerthInfo(ids, plNo);
        if (CollectionUtils.isNotEmpty(tpPBerthsDOs)) {
            throw new BizException(ErrorType.NOT_ALLOW_DEL_BERTH);
        }
        TpPBerthsExample example = new TpPBerthsExample();
        example.createCriteria().andIdIn(ids);
        TpPBerths record = new TpPBerths();
        record.setDataState(DataStatusEnum.DATA_STATUS_NO_VALID.value());
        record.setModifyTime(new Date());
        record.setModifyOp(modifyOp);
        record.setOptFlg(ParkConstant.OptFlag.DELETE);
        tpPBerthsMapper.updateByExampleSelective(record, example);
        //更新停车场泊位数-空闲车位数
        this.updateParkBerthNum(plNo);
        return true;
    }

    @Override
    public PageInfo<TpPBerthsDO> queryBerthByBerth(QueryBerthForPageRequest request, int pageNum, int pageSize) {
        PageHelper.startPage(pageNum, pageSize);
        List<TpPBerthsDO> list = tpPBerthsSMapper.queryBerthByBerth(request);
        return new PageInfo<TpPBerthsDO>(list);
    }

    @Override
    public List<ParkOccupancyRateDTO> queryParkOccupancyRate(String plNo, String parkAreaCode) {
        return tpPBerthsSMapper.queryParkOccupancyRate(plNo, parkAreaCode);
    }

    @Override
    public Integer queryBerthCountByPlNoAndParkAreaCode(String plNo, String parkAreaCode) {
        TpPBerthsExample example = new TpPBerthsExample();
        Criteria sql = example.createCriteria();
        sql.andPlNoEqualTo(plNo);
        sql.andDataStateEqualTo(DataStatusEnum.DATA_STATUS_VALID.value());
        if (!StringUtils.isBlank(parkAreaCode)) {
            sql.andParkAreaCodeEqualTo(parkAreaCode);
        }
        return Long.valueOf(tpPBerthsMapper.countByExample(example)).intValue();
    }

    @Override
    @Deprecated
    public Integer batchUpdateBerthStateForFree(String plNo, String parkAreaCode) {
        if (StringUtils.isBlank(plNo) && StringUtils.isBlank(parkAreaCode)) {
            return 0;
        }
        TpPBerthsExample example = new TpPBerthsExample();
        Criteria sql = example.createCriteria();
        sql.andPlNoEqualTo(plNo);
        if (!StringUtils.isBlank(parkAreaCode)) {
            sql.andParkAreaCodeEqualTo(parkAreaCode);
        }
        TpPBerths record = new TpPBerths();
        record.setIsOccupy(BerthConstant.isOccupy.NO_CAR);
        record.setModifyTime(new Date());
        return tpPBerthsMapper.updateByExampleSelective(record, example);
    }

    @Override
    public List<TpPBerths> queryBerthsByPlNo(String pklNo) {
        TpPBerthsExample example = new TpPBerthsExample();
        example.createCriteria().andPlNoEqualTo(pklNo)
            .andDataStateEqualTo(DataStatusEnum.DATA_STATUS_VALID.value());
        return tpPBerthsMapper.selectByExample(example);
    }

    @Override
    public List<TpPBerthsDO> queryBerthByAreaCodes(List<String> parkAreaCodes) {
        return tpPBerthsSMapper.queryBerthByAreaCodes(parkAreaCodes);
    }

    @Override
    public List<TpPBerths> selectByExample(TpPBerthsExample example) {
        return tpPBerthsMapper.selectByExample(example);
    }

    @Override
    public int updateByExampleSelective(TpPBerths record, TpPBerthsExample example) {
        return tpPBerthsMapper.updateByExampleSelective(record, example);
    }

    /**
     * 校验泊位编码的唯一性.<br/>
     *
     * @param request
     * @return 2018年1月5日  wangfs.<br/>
     */
    @Override
    public int checkUniqueForBerthNo(CheckUniqueForBerthNoRequest request) {
        return tpPBerthsSMapper.checkUniqueForBerthNo(request);
    }

    /**
     * 批量保存泊位信息.<br/>
     *
     * @param list
     * @return 2018年1月6日  wangfs.<br/>
     */
    @Override
    public int batchSaveBerthInfo(List<TpPBerths> list) {
        int i = tpPBerthsSMapper.batchSaveBerthInfo(list);
        Set<String> plNos = list.stream().map(item -> item.getPlNo()).collect(Collectors.toSet());
        //更新停车场泊位数-空闲车位数
        for (String plNo : plNos) {
            this.updateParkBerthNum(plNo);
        }
        return i;
    }

    @Override
    @Transactional
    public void changeBerthArea(List<Long> ids, String parkAreaCode, Long opId) {
        //查询更换了那些车场
        TpPBerthsExample tpberthExample = new TpPBerthsExample();
        tpberthExample.createCriteria().andIdIn(ids);
        final List<TpPBerths> tpPBerths = tpPBerthsMapper.selectByExample(tpberthExample);
        Set<String> plNos = tpPBerths.stream().map(item -> item.getPlNo()).collect(Collectors.toSet());
        //查询将要更换到新得泊位区间车场编号
        List<String> areaCodes = Arrays.asList(parkAreaCode);
        final Map<String, TpPRegionArea> stringTpPRegionAreaMap = tpPRegionAreaDao.queryTpPRegionAreaByParkAreaCodes(
            areaCodes);
        String newPlno = stringTpPRegionAreaMap.get(parkAreaCode).getPlNo();
        plNos.add(newPlno);
        //将这些泊位对应得地磁信息更换到该区间
        tpPEqpSMapper.updateEqpAreaCode(ids, newPlno);
        //将泊位更换到该区间
        TpPBerthsExample example = new TpPBerthsExample();
        example.createCriteria().andIdIn(ids);
        TpPBerths record = new TpPBerths();
        record.setModifyOp(opId);
        record.setModifyTime(new Date());
        record.setParkAreaCode(parkAreaCode);
        record.setPlNo(newPlno);
        record.setOptFlg(OptFlag.MODIFY);
        tpPBerthsMapper.updateByExampleSelective(record, example);

        //更新停车场泊位数
        for (String plNo : plNos) {
            this.updateParkBerthNum(plNo);
        }

    }

    /**
     * 更新某个停车场的泊位数和空闲车位数
     *
     * @param plNo 2018年1月7日 zhaowg
     */
    private void updateParkBerthNum(String plNo) {
        //更新停车场泊位数
        Integer berthsCount = this.queryBerthCountByPlNoAndParkAreaCode(plNo, null);
        ParkingLotExample example = new ParkingLotExample();
        example.createCriteria().andDataStatusEqualTo(DataStatusEnum.DATA_STATUS_VALID.value())
            .andPlNoEqualTo(plNo);
        ParkingLot record = new ParkingLot();
        record.setModifyTime(new Date());
        record.setPlBerthNum(berthsCount);
        parkingLotMapper.updateByExampleSelective(record, example);
        //更新停车场缓存
        ParkingLotDTO parkingLotDTO = ParkingLotCacheUtil.getParkLotByPlNo(plNo);
        parkingLotDTO.setPlBerthNum(berthsCount);
        ParkingLotCacheUtil.setParkLotByPlNo(plNo, parkingLotDTO);
        //更新对应的空闲车位数
        parkFreeBerthBizService.updateFreeBerthNumByPlNo(plNo);
    }

    @Override
    public List<TpPBerths> getBerthNoBindGeoByPlNo(String plNo) {
        return tpPBerthsSMapper.getBerthNoBindGeoByPlNo(plNo);
    }

    @Override
    public List<BerthsDTO> queryBerthInfoByPlNoAndOther(QueryBerthByPlNoAndOrtherRequest request) {
        return tpPBerthsSMapper.queryBerthInfoByPlNoAndOther(request);
    }

    @Override
    public BerthsDTO queryBerthInfoByPlNoAndBerthNo(QueryBerthByPlNoAndBerthNoRequest request) {
        if (StringUtils.isBlank(request.getQueryType())) {
            return tpPBerthsSMapper.queryBerthInfoByPlNoAndBerthNo(request);
        } else if (request.getQueryType().equals("10")) {
            //简单查询
            TpPBerthsExample example = new TpPBerthsExample();
            example.createCriteria().andDataStateEqualTo(DataStatusEnum.DATA_STATUS_VALID.value())
                .andBerthNoEqualTo(request.getBerthNo())
                .andPlNoEqualTo(request.getPlNo());
            final List<TpPBerths> tpPBerths = tpPBerthsMapper.selectByExample(example);
            if (CollectionUtils.isEmpty(tpPBerths)) {
                return null;
            } else {
                final TpPBerths tpPBerths1 = tpPBerths.get(0);
                BerthsDTO berthsDTO = new BerthsDTO();
                BeanUtils.copyProperties(tpPBerths1, berthsDTO);
                return berthsDTO;
            }
        }
        return null;
    }

    @Override
    public List<TpPBerths> queryBerthInfoByRangeNos(QueryBerthByRangeNosRequest request) {
        return tpPBerthsSMapper.queryBerthInfoByRangeNos(request);
    }

    @Override
    public BerthsStatisticDTO queryBerthStatisticByOrgIds(QueryParkSourceByOrgIdsRequest request) {
        return tpPBerthsSMapper.queryBerthStatisticByOrgIds(request);
    }

    @Override
    public List<BerthsStatisticDTO> queryBerthStatisticForOrgId(QueryParkSourceByOrgIdsRequest request) {
        return tpPBerthsSMapper.queryBerthStatisticForOrgId(request);
    }

    @Override
    public List<String> queryBerthNoWithEqpNoByBerthRangeNo(String berthRangeNo, String plNo) {
        return tpPBerthsSMapper.queryBerthNoWithEqpNoByBerthRangeNo(berthRangeNo, plNo);
    }

    @Override
    public Long queryBerthNumByBerthRangeNo(String berthRangeNo) {
        TpPBerthsExample example = new TpPBerthsExample();
        example.createCriteria().andDataStateEqualTo(DataStatusEnum.DATA_STATUS_VALID.value()).andParkAreaCodeEqualTo(
            berthRangeNo);

        return tpPBerthsMapper.countByExample(example);
    }

    @Override
    public Boolean updateCarNumberByBerthNo(ParkOrderUpdateCarNumberReq req) {

        if (
            StringUtils.isBlank(req.getPlNo()) || StringUtils.isBlank(req.getBerthNo()) || StringUtils.isBlank(
                req.getNewCarNumber())
        ) {
            return false;
        }

        TpPBerthsExample example = new TpPBerthsExample();

        TpPBerths tpPBerths = new TpPBerths();
        tpPBerths.setCarNo(req.getNewCarNumber());

        example.createCriteria().andDataStateEqualTo(DataStatusEnum.DATA_STATUS_VALID.value())
            .andBerthNoEqualTo(req.getBerthNo())
            .andPlNoEqualTo(req.getPlNo())
            .andIsOccupyEqualTo("1");

        return tpPBerthsMapper.updateByExampleSelective(tpPBerths, example) > 0;

    }

    @Override
    public Integer updateBerthInfoForInPark(TpPBerths tpPBerths) {
        if (StringUtils.isBlank(tpPBerths.getPlNo()) || StringUtils.isBlank(tpPBerths.getBerthNo())) {
            return 0;
        }
        return tpPBerthsSMapper.updateBerthInfoForInPark(tpPBerths);
    }

    @Override
    public Integer updateBerthEqpOutTime(UpdateBerthRequest request) {

        if (StringUtils.isBlank(request.getPlNo()) || StringUtils.isBlank(request.getBerthNo())) {
            return 0;
        }
        return tpPBerthsSMapper.updateBerthEqpOutTime(request);
    }

    @Override
    public Integer updateBerthInfoByPDA(UpdateBerthByOrderIdRequest request){
        return tpPBerthsSMapper.updateBerthInfoByPDA(request);
    }

    @Override
    public List<ParkAreaFreeBerthsMsgVO> qyeryParkAreaBerthNumstatistic(String plNo) {
        return tpPBerthsSMapper.qyeryParkAreaBerthNumstatistic(plNo);
    }

    /**
     * 根据排班的停车场编号列表以及泊位号模糊查询对应的泊位信息
     *
     * @param plNos
     */
    @Override
    public List<BerthsDTO> queryBerthInfoByKeyWord(List<String> plNos, String berthNo) {
        return tpPBerthsSMapper.queryBerthInfoByKeyWord(plNos, berthNo);
    }

    /**
     * 验证泊位号
     * @param berthNo
     * @return
     */
    @Override
    public BerthsDTO queryBerthsByBerthNo(String berthNo) {
        return tpPBerthsSMapper.queryBerthsByBerthNo(berthNo);
    }

}