package com.qianwen.smartman.modules.mdc.service.impl;

import java.time.LocalDate;
import java.time.ZoneId;
import java.time.temporal.ChronoUnit;
import java.time.temporal.TemporalAccessor;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Optional;
import java.util.stream.Stream;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.qianwen.core.cache.utils.CacheUtil;
import com.qianwen.core.log.exception.ServiceException;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.smartman.common.constant.ExtCacheConstant;
import com.qianwen.smartman.common.utils.ExtraLambdaQueryWrapper;
import com.qianwen.smartman.common.utils.Lambda;
import com.qianwen.smartman.modules.mdc.dto.WorkstationNoImmediateFeedBackDTO;
import com.qianwen.smartman.modules.mdc.entity.WorkstationFeedback;
import com.qianwen.smartman.modules.mdc.entity.WorkstationFeedbackDetail;
import com.qianwen.smartman.modules.mdc.enums.FeedbackDetailStatus;
import com.qianwen.smartman.modules.mdc.enums.FeedbackStatus;
import com.qianwen.smartman.modules.mdc.mapper.WorkstationFeedbackDetailMapper;
import com.qianwen.smartman.modules.mdc.service.IWorkstationFeedbackDetailService;
import com.qianwen.smartman.modules.mdc.service.IWorkstationFeedbackService;

@Service
public class WorkstationFeedbackDetailServiceImpl extends ServiceImpl<WorkstationFeedbackDetailMapper, WorkstationFeedbackDetail> implements IWorkstationFeedbackDetailService {
    private final IWorkstationFeedbackService workstationFeedbackService;

    public WorkstationFeedbackDetailServiceImpl(final IWorkstationFeedbackService workstationFeedbackService) {
        this.workstationFeedbackService = workstationFeedbackService;
    }

    @Override
    public List<WorkstationFeedbackDetail> cancelFeedback(final LocalDate queryDate, final Long workstationId) {
    	//在接口上，该方法已经被缓存到了redis（具体键值请查看接口方法注解），刚刚添加完数据是不会访问这个方法内部执行查询的，刚添加完返回也不会有WorkstationFeedbackDetail数据
    	return list(Lambda.eq(WorkstationFeedbackDetail::getWorkstationId, workstationId)
    	        .dayBetween(queryDate, WorkstationFeedbackDetail::getStartTime, WorkstationFeedbackDetail::getEndTime)
    	        .eq(WorkstationFeedbackDetail::getCancel, true).orderByDesc(WorkstationFeedbackDetail::getStartTime));
    	/*
        return list((Wrapper) ((ExtraLambdaQueryWrapper) Lambda.eq((v0) -> {
            return v0.getWorkstationId();
        }, workstationId).dayBetween(queryDate, (v0) -> {
            return v0.getStartTime();
        }, (v0) -> {
            return v0.getEndTime();
        }).eq((v0) -> {
            return v0.getCancel();
        }, true)).orderByDesc((v0) -> {
            return v0.getStartTime();
        }));*/
    }

    @Override
    @Transactional
    public boolean cancelWorkstationFeedbacks(final List<String> ids) {
        List<WorkstationFeedbackDetail> detailList = new ArrayList<>();
        boolean match = ids.stream().map(this::getById).peek(detailList::add).map(WorkstationFeedbackDetail::getFeedbackId).map(this.workstationFeedbackService::getById).map(WorkstationFeedback::getStatus).allMatch(FeedbackStatus.SYNCED.getValue()::equals);
        
        //final boolean match = ids.stream().map((Function<? super Object, ?>)this::getById).peek(detailList::add).map((Function<? super Object, ?>)WorkstationFeedbackDetail::getFeedbackId).map((Function<? super Object, ?>)this.workstationFeedbackService::getById).map((Function<? super Object, ?>)WorkstationFeedback::getStatus).allMatch(FeedbackStatus.SYNCED.getValue()::equals);
        if (match) {
        	
            detailList.forEach(detail -> {
            	//workstationFeedbackService.lambdaUpdate().se
            	this.workstationFeedbackService.lambdaUpdate().set(WorkstationFeedback::getStatus, FeedbackStatus.WAIT_SYNC.getValue())
            	.eq(WorkstationFeedback::getId, detail.getFeedbackId()).update();
                //this.workstationFeedbackService.lambdaUpdate().set(WorkstationFeedback::getStatus, (Object)FeedbackStatus.WAIT_SYNC.getValue())).eq((Object)WorkstationFeedback::getId, (Object)detail.getFeedbackId())).update();
                detail.setCancel(true);
                detail.setCancelTime(new Date());
                this.updateById(detail);
            });
            this.evictCancelFeedback(detailList);
            return true;
        }
        /*
        Stream<R> map = ids.stream().map((v1) -> {
            return getById(v1);
        });
        detailList.getClass();
        Stream map2 = map.peek((v1) -> {
            r1.add(v1);
        }).map((v0) -> {
            return v0.getFeedbackId();
        });
        IWorkstationFeedbackService iWorkstationFeedbackService = this.workstationFeedbackService;
        iWorkstationFeedbackService.getClass();
        Stream map3 = map2.map((v1) -> {
            return r1.getById(v1);
        }).map((v0) -> {
            return v0.getStatus();
        });
        Integer value = FeedbackStatus.SYNCED.getValue();
        value.getClass();
        boolean match = map3.allMatch((v1) -> {
            return r1.equals(v1);
        });
        if (match) {
            detailList.forEach(detail -> {
                ((LambdaUpdateChainWrapper) ((LambdaUpdateChainWrapper) this.workstationFeedbackService.lambdaUpdate().set((v0) -> {
                    return v0.getStatus();
                }, FeedbackStatus.WAIT_SYNC.getValue())).eq((v0) -> {
                    return v0.getId();
                }, detail.getFeedbackId())).update();
                detail.setCancel(true);
                detail.setCancelTime(new Date());
                updateById(detail);
            });
            evictCancelFeedback(detailList);
            return true;
        }*/
        throw new ServiceException("存在反馈未完成不允许操作");
    }

    private void evictCancelFeedback(final List<WorkstationFeedbackDetail> detailList) {
        detailList.forEach(feedback -> {
            LocalDate start = LocalDate.from((TemporalAccessor) feedback.getStartTime().toInstant().atZone(ZoneId.systemDefault()));
            LocalDate end = LocalDate.from((TemporalAccessor) feedback.getEndTime().toInstant().atZone(ZoneId.systemDefault()));
            long distance = ChronoUnit.DAYS.between(start, end);
            Stream.iterate(start, d -> {
                return d.plusDays(1L);
            }).limit(distance + 1).forEach(date -> {
                String key = String.valueOf(feedback.getWorkstationId()).concat(":").concat(Func.formatDate(date));
                CacheUtil.evict(ExtCacheConstant.WORK_FEEDBACK_DETAIL, "list:cancel:workstationId:", key, false);
            });
        });
    }

    @Override
    public long toDayHaveFeedbackCount(final Long workstationId) {
        return count(todayConditionWrapper(workstationId));
    }

    private Wrapper<WorkstationFeedbackDetail> todayConditionWrapper(final Long workstationId) {
    	return Lambda.<WorkstationFeedbackDetail>create()
    		      .dayBetween(LocalDate.now(), WorkstationFeedbackDetail::getStartTime, WorkstationFeedbackDetail::getStartTime)
    		      .eq(WorkstationFeedbackDetail::getWorkstationId, workstationId)
    		      .orderByDesc(WorkstationFeedbackDetail::getStartTime)
    		      .eq(WorkstationFeedbackDetail::getCancel, Boolean.valueOf(false))
    		      .eq(WorkstationFeedbackDetail::getStatus, Integer.valueOf(FeedbackDetailStatus.EFFECTED.getValue()));
    	/*
        return (Wrapper) ((ExtraLambdaQueryWrapper) ((ExtraLambdaQueryWrapper) ((ExtraLambdaQueryWrapper) Lambda.create().dayBetween(LocalDate.now(), (v0) -> {
            return v0.getStartTime();
        }, (v0) -> {
            return v0.getStartTime();
        }).eq((v0) -> {
            return v0.getWorkstationId();
        }, workstationId)).orderByDesc((v0) -> {
            return v0.getStartTime();
        })).eq((v0) -> {
            return v0.getCancel();
        }, false)).eq((v0) -> {
            return v0.getStatus();
        }, Integer.valueOf(FeedbackDetailStatus.EFFECTED.getValue()));*/
    }

    @Override
    public List<WorkstationFeedbackDetail> todayFeedback(final Long workstationId) {
        List<WorkstationFeedbackDetail> list = list(todayConditionWrapper(workstationId));
        return list;
    }

    @Override
    public WorkstationFeedbackDetail latestFeedbackByWorkstationId(Long workstationId) {
    	return this.baseMapper.latestFeedbackByWorkstationId(Lambda.eq(WorkstationFeedbackDetail::getWorkstationId, workstationId)
    	        .eq(WorkstationFeedbackDetail::getStatus, Integer.valueOf(FeedbackDetailStatus.EFFECTED.getValue())));
    	/*
        return ((WorkstationFeedbackDetailMapper) this.baseMapper).latestFeedbackByWorkstationId((Wrapper) Lambda.eq((v0) -> {
            return v0.getWorkstationId();
        }, workstationId).eq((v0) -> {
            return v0.getStatus();
        }, Integer.valueOf(FeedbackDetailStatus.EFFECTED.getValue())));*/
    }

    @Override
    public boolean overwriteFeedbackCheck(final WorkstationNoImmediateFeedBackDTO noImmediateFeedBackDTO) {
    	/*;
    	return noImmediateFeedBackDTO.getWorkstationIds().stream().
    			anyMatch(workstationId -> ((Boolean)Optional.<WorkstationFeedbackDetail>ofNullable(this.baseMapper.overwriteFeedbackCheck(Lambda.eq(WorkstationFeedbackDetail::getWorkstationId, workstationId).ne(WorkstationFeedbackDetail::getCancel, true)).ne(WorkstationFeedbackDetail::getStatus, Integer.valueOf(FeedbackDetailStatus.DELETE.getValue()))).nested(()))).map(()).orElse(Boolean.valueOf(false))).booleanValue());
    	*/
    	//FeedbackDetailStatus.DELETE.getValue()
        return noImmediateFeedBackDTO.getWorkstationIds().stream().anyMatch(workstationId -> {
            return Optional.ofNullable(this.baseMapper.overwriteFeedbackCheck(Lambda.<WorkstationFeedbackDetail>eq(WorkstationFeedbackDetail::getWorkstationId, workstationId)
            		.ne(WorkstationFeedbackDetail::getCancel, true)
            		.ne(WorkstationFeedbackDetail::getStatus,FeedbackDetailStatus.DELETE.getValue())
            		.nested(w -> {
            			ExtraLambdaQueryWrapper extraLambdaQueryWrapper = w.apply("{0} between start_time and end_time", new Object[]{noImmediateFeedBackDTO.getStartTime()}).or().apply("{0} between start_time and end_time", new Object[]{noImmediateFeedBackDTO.getEndTime()});
            }))).map(feedback -> {
                return feedback.getEndTime().compareTo(noImmediateFeedBackDTO.getStartTime()) != 0;
            }).orElse(false).booleanValue();
        });
    }
}