package com.fdkankan.fusion.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.fdkankan.fusion.common.PageInfo;
import com.fdkankan.fusion.common.enums.BuildType;
import com.fdkankan.fusion.common.util.CameraUtil;
import com.fdkankan.fusion.entity.*;
import com.fdkankan.fusion.entity.jsonEntity.Transform;
import com.fdkankan.fusion.httpClient.client.LaserClient;
import com.fdkankan.fusion.mapper.ICaseFusionMapper;
import com.fdkankan.fusion.request.CaseOverviewParam;
import com.fdkankan.fusion.response.FusionNumVo;
import com.fdkankan.fusion.response.SceneVo;
import com.fdkankan.fusion.service.*;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.util.StringUtil;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.stream.Collectors;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author 
 * @since 2022-08-04
 */
@Service
public class CaseFusionServiceImpl extends ServiceImpl<ICaseFusionMapper, CaseFusion> implements ICaseFusionService {

    @Autowired
    IFusionNumService fusionNumService;
    @Autowired
    IModelService modelService;
    @Autowired
    IScenePlusService scenePlusService;
    @Autowired
    IScenePlusExtService scenePlusExtService;
    @Autowired
    ISceneService sceneService;
    @Autowired
    LaserClient laserClient;
    @Autowired
    ISceneFileBuildService sceneFileBuildService;
    @Autowired
    ICaseSettingsService settingsService;


    @Override
    public List<CaseFusion> getListByCaseId(Integer caseId) {
        LambdaQueryWrapper<CaseFusion> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(CaseFusion::getCaseId,caseId);
        return this.list(wrapper);
    }

    @Override
    public PageInfo pageList(CaseOverviewParam param) {
        LambdaQueryWrapper<CaseFusion> wrapper = new LambdaQueryWrapper<>();
        if(StringUtils.isNotBlank(param.getFusionTitle())){
            wrapper.like(CaseFusion::getFusionTitle,param.getFusionTitle());
        }
        wrapper.orderByDesc(CaseFusion::getFusionId);
        Page<CaseFusion> page = this.page(new Page<>(param.getPageNum(), param.getPageSize()), wrapper);
        List<Integer> fusionIds = page.getRecords().stream().map(CaseFusion::getFusionId).collect(Collectors.toList());
        HashMap<Integer,CaseSettings> map = settingsService.getByFusionIds(fusionIds);
        for (CaseFusion record : page.getRecords()) {
            CaseSettings caseSettings = map.get(record.getFusionId());
            if(caseSettings !=null){
                record.setCover(caseSettings.getCover());
            }
        }
        return PageInfo.PageInfo(page);
    }


    @Override
    public List<FusionNumVo> getSceneListVo(Integer fusionId) {
        List<FusionNumVo> sceneVos = new ArrayList<>();
        List<FusionNum> fusionNumList = fusionNumService.getByFusionId(fusionId);

        List<Integer> modelIds = fusionNumList.stream().map(FusionNum::getModelId).collect(Collectors.toList());
        List<Model> listByModelIds = modelService.getListByModelIds(modelIds);
        HashMap<Integer,Model> modelMap = new HashMap<>();
        listByModelIds.stream().forEach(e -> modelMap.put(e.getModelId(),e));

        List<String> numList = listByModelIds.stream().filter(e -> e.getNum() != null).map(Model::getNum).collect(Collectors.toList());
        List<ScenePlus> scenePlusList = scenePlusService.getByNumList(numList);
        HashMap<String,ScenePlus> map = new HashMap<>();
        scenePlusList.stream().forEach(e -> map.put(e.getNum(),e));

        List<Long> plusIds = scenePlusList.stream().map(ScenePlus::getId).collect(Collectors.toList());
        List<ScenePlusExt> extList = scenePlusExtService.getByPlusIds(plusIds);
        HashMap<Long,ScenePlusExt> mapext = new HashMap<>();
        extList.stream().forEach(e -> mapext.put(e.getPlusId(),e));

        HashMap<String,String> mappingMap = sceneService.getMappingMap(numList);

        for (FusionNum fusionNum : fusionNumList) {
            Transform transform = JSONObject.parseObject(fusionNum.getTransform(),Transform.class);
            FusionNumVo vo = new FusionNumVo();
            vo.setTransform(transform);
            BeanUtils.copyProperties(fusionNum,vo);
            SceneVo sceneVo = new SceneVo();
            Model model = modelMap.get(fusionNum.getModelId());
            if(model != null){
                BeanUtils.copyProperties(model,sceneVo);
                if(model.getNum() != null ){
                    ScenePlus scenePlus = map.get(model.getNum());
                    if(scenePlus != null){
                        BeanUtils.copyProperties(scenePlus,sceneVo);
                        sceneVo.setStatus(scenePlus.getSceneStatus() == 1 ? 2:scenePlus.getSceneStatus());
                        sceneVo.setName(scenePlus.getTitle());
                        sceneVo.setSceneName(scenePlus.getTitle());
                        sceneVo.setCreateTime(scenePlus.getCreateTime());
                        ScenePlusExt scenePlusExt = mapext.get(scenePlus.getId());
                        if(scenePlusExt != null){
                            sceneVo.setRtkLocation(scenePlusExt.getRtkLocation());
                            sceneVo.setOrientation(scenePlusExt.getOrientation());
                        }
                        sceneVo.setMapping( mappingMap.get(scenePlus.getNum()));

                        sceneVo.setSourceName(CameraUtil.getSourceName(model.getType()));
                        vo.setSceneData(sceneVo);
                        sceneVos.add(vo);

                    }
                }
            }
        }

        return sceneVos;
    }

    @Override
    public void updateOfflineStatus(Integer fusionId, Integer status, String zipPath) {
        LambdaUpdateWrapper<CaseFusion> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(CaseFusion::getFusionId,fusionId);
        wrapper.set(CaseFusion::getOfflineStatus,status);
        wrapper.set(CaseFusion::getOfflinePath,zipPath);
        if (status == 2) {
            wrapper.set(CaseFusion::getOfflineEndTime,new Date());
        }
        if (status == 1) {
            wrapper.set(CaseFusion::getOfflineStartTime,new Date());
        }
        this.update(wrapper);
        if(status == 1){ //开始
            sceneFileBuildService.updateTimeAndStatus(fusionId.toString(),2, new Date(), null, BuildType.BUILD_FUSION_OFFLINE,zipPath);
        }
        if(status == 2){ //成功
            laserClient.addNotifications(2);
            sceneFileBuildService.updateTimeAndStatus(fusionId.toString(),4,null,  new Date(),  BuildType.BUILD_FUSION_OFFLINE,zipPath);
        }else if(status != 1){ //失败
            laserClient.addNotifications(3);
        }

    }
}