package com.izouma.nineth.service;

import com.izouma.nineth.config.Constants;
import com.izouma.nineth.domain.MetaAtomTask;
import com.izouma.nineth.domain.MetaProp;
import com.izouma.nineth.domain.MetaTaskNew;
import com.izouma.nineth.domain.MetaTaskToUserNew;
import com.izouma.nineth.dto.MetaRestResult;
import com.izouma.nineth.dto.PageQuery;
import com.izouma.nineth.enums.MetaAwardTypeEnum;
import com.izouma.nineth.enums.MetaTaskStatus;
import com.izouma.nineth.enums.MetaTaskType;
import com.izouma.nineth.exception.BusinessException;
import com.izouma.nineth.repo.*;
import com.izouma.nineth.utils.JpaUtils;
import com.izouma.nineth.utils.SecurityUtils;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.data.domain.Page;
import org.springframework.stereotype.Service;

import javax.transaction.Transactional;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.atomic.AtomicBoolean;

@Service
@AllArgsConstructor
@Slf4j
public class MetaTaskToUserNewService {

    private MetaTaskToUserNewRepo metaTaskToUserNewRepo;

    private MetaAtomTaskRepo metaAtomTaskRepo;

    private MetaTaskNewRepo metaTaskNewRepo;

    private MetaPropRepo metaPropRepo;

    private MetaTaskBindRepo metaTaskBindRepo;


    public Page<MetaTaskToUserNew> all(PageQuery pageQuery) {
        return metaTaskToUserNewRepo.findAll(JpaUtils.toSpecification(pageQuery, MetaTaskToUserNew.class), JpaUtils.toPageRequest(pageQuery));
    }

    @Transactional
    public MetaRestResult<Void> autoReceiveTask() {
        Long userId = SecurityUtils.getAuthenticatedUser().getId();
        List<MetaTaskNew> metaTaskNews = metaTaskNewRepo.findAllByDel(false);
        AtomicBoolean exist = new AtomicBoolean(false);
        metaTaskNews.forEach(metaTaskNew -> {
            MetaTaskToUserNew metaTaskToUserNew = metaTaskToUserNewRepo.findByUserIdAndTaskIdAndDel(userId, metaTaskNew.getId(), false);
            if (Objects.isNull(metaTaskToUserNew)) {
                exist.set(true);
                metaTaskToUserNew = new MetaTaskToUserNew();
                metaTaskToUserNew.setUserId(userId);
                metaTaskToUserNew.setTaskId(metaTaskNew.getId());
                // 设置主动领取第一个索引的基础任务
                if (MetaTaskType.MAIN_LINE.equals(metaTaskNew.getType())) {
                    Long atomTaskId = metaTaskBindRepo.findAtomTaskId(metaTaskNew.getId(), MetaTaskType.NODE);
                    if (Objects.nonNull(atomTaskId)) {
                        metaTaskToUserNew.setAtomTaskId(atomTaskId);
                    }
                }
                if (MetaTaskType.BRANCH_LINE.equals(metaTaskNew.getType())) {
                    Long atomTaskId = metaTaskBindRepo.findAtomTaskId(metaTaskNew.getId(), MetaTaskType.BRANCH_LINE);
                    if (Objects.nonNull(atomTaskId)) {
                        metaTaskToUserNew.setAtomTaskId(atomTaskId);
                    }
                }
                if (MetaTaskType.DAILY.equals(metaTaskNew.getType())) {
                    Long atomTaskId = metaTaskBindRepo.findAtomTaskId(metaTaskNew.getId(), MetaTaskType.DAILY);
                    if (Objects.nonNull(atomTaskId)) {
                        metaTaskToUserNew.setAtomTaskId(atomTaskId);
                    }
                }
                MetaRestResult<MetaTaskToUserNew> result = receiveTask(metaTaskToUserNew);
                if (Constants.MetaRestCode.success != result.getCode()) {
                    throw new BusinessException(result.getMessage());
                }
            }
        });
        if (exist.get()) {
            return MetaRestResult.returnSuccess("主动任务领取成功");
        }
        return MetaRestResult.returnSuccess("玩家主动领取任务已经全部领取");
    }


    @Transactional
    public MetaRestResult<MetaTaskToUserNew> receiveTask(MetaTaskToUserNew metaTaskToUserNew) {
        if (Objects.isNull(metaTaskToUserNew.getUserId())) {
            return MetaRestResult.returnError("Illegal parameter : userId can not be null");
        }
        if (Objects.isNull(metaTaskToUserNew.getTaskId())) {
            return MetaRestResult.returnError("Illegal parameter : taskId can not be null");
        }
        if (Objects.isNull(metaTaskToUserNew.getAtomTaskId())) {
            return MetaRestResult.returnError("Illegal parameter : atomTaskId can not be null");
        }
        MetaTaskNew metaTaskNew = metaTaskNewRepo.findByIdAndDel(metaTaskToUserNew.getTaskId(), false);
        if (Objects.isNull(metaTaskNew)) {
            return MetaRestResult.returnError("任务不存在");
        }
        if (!metaTaskNew.isPublish()) {
            return MetaRestResult.returnError("status error : task has not been published");
        }
        if (metaTaskNew.isFinish()) {
            return MetaRestResult.returnError("status error : task has been finished");
        }
        if (StringUtils.isBlank(metaTaskNew.getName())) {
            return MetaRestResult.returnError(String.format("任务[%S]缺少任务名称", metaTaskToUserNew.getTaskId()));
        }
        if (Objects.isNull(metaTaskNew.getDetail())) {
            return MetaRestResult.returnError(String.format("任务[%S]缺少任务详情", metaTaskToUserNew.getTaskId()));
        }
        if (Objects.isNull(metaTaskNew.getType())) {
            return MetaRestResult.returnError(String.format("任务[%S]缺少任务类型", metaTaskToUserNew.getTaskId()));
        }
        MetaAtomTask metaAtomTask = metaAtomTaskRepo.findByIdAndDel(metaTaskToUserNew.getAtomTaskId(), false);
        if (Objects.isNull(metaAtomTask)) {
            return MetaRestResult.returnError("基础任务不存在");
        }
        if (StringUtils.isBlank(metaAtomTask.getName())) {
            return MetaRestResult.returnError(String.format("基础任务[%S]缺少任务名称", metaTaskToUserNew.getAtomTaskId()));
        }
        if (Objects.isNull(metaAtomTask.getDetail())) {
            return MetaRestResult.returnError(String.format("基础任务[%S]缺少任务详情", metaTaskToUserNew.getAtomTaskId()));
        }
        if (Objects.isNull(metaAtomTask.getTargetType())) {
            return MetaRestResult.returnError(String.format("基础任务[%S]缺少目标", metaTaskToUserNew.getAtomTaskId()));
        }
        if (StringUtils.isBlank(metaAtomTask.getTargetConfig())) {
            return MetaRestResult.returnError(String.format("基础任务[%S]缺少目标配置", metaTaskToUserNew.getAtomTaskId()));
        }
        if (Objects.isNull(metaAtomTask.getAwardType())) {
            return MetaRestResult.returnError(String.format("基础任务[%S]缺少奖励类型", metaTaskToUserNew.getAtomTaskId()));
        }
        if (StringUtils.isBlank(metaAtomTask.getAwardConfig())) {
            return MetaRestResult.returnError(String.format("基础任务[%S]缺少奖励配置", metaTaskToUserNew.getAtomTaskId()));
        }

        // 判断当前玩家是否领取过任务
        MetaTaskToUserNew dbMetaTaskToUserNew = metaTaskToUserNewRepo.findByUserIdAndTaskIdAndAtomTaskIdAndDel(metaTaskToUserNew.getUserId(), metaTaskToUserNew.getTaskId(), metaTaskToUserNew.getAtomTaskId(), false);
        if (Objects.nonNull(dbMetaTaskToUserNew)) {
            return MetaRestResult.returnError(String.format("当前用户已在[%S]领取过该任务", dbMetaTaskToUserNew.getGetTime()));
        }
        metaTaskToUserNew.setGetTime(LocalDateTime.now());
        metaTaskToUserNew.setStatus(MetaTaskStatus.PROGRESS);
        metaTaskToUserNew.setChannelId(metaTaskNew.getChannelId());
        if (MetaAwardTypeEnum.META_PROP.equals(metaAtomTask.getAwardType())) {
            MetaProp metaProp = metaPropRepo.findByIdAndDel(Long.parseLong(metaAtomTask.getAwardConfig()), false);
            if (Objects.isNull(metaProp)) {
                return MetaRestResult.returnError(String.format("基础任务[%S]奖励配置的道具不存在", metaTaskToUserNew.getAtomTaskId()));
            }
            metaTaskToUserNew.setMetaProp(metaProp);
        }

        metaTaskToUserNew.setMetaTaskNew(metaTaskNew);
        metaTaskToUserNew.setMetaAtomTask(metaAtomTask);
        MetaTaskToUserNew save = metaTaskToUserNewRepo.save(metaTaskToUserNew);
        setProgress(save);
        return MetaRestResult.returnSuccess(save);
    }

    private void setProgress(MetaTaskToUserNew metaTaskToUserNew) {
        // TODO
    }
}