package com.estate.expert.admin.service.impl;

import com.estate.expert.admin.domain.business.device.DeviceType;
import com.estate.expert.admin.domain.common.request.PageReq;
import com.estate.expert.admin.domain.common.response.PageResp;
import com.estate.expert.admin.domain.standard.hierachy.HierarchyData;
import com.estate.expert.admin.domain.standard.hierachy.HierarchyIds;
import com.estate.expert.admin.domain.standard.model.Model;
import com.estate.expert.admin.domain.standard.model.device.DeviceModel;
import com.estate.expert.admin.domain.standard.model.device.DeviceModelDto;
import com.estate.expert.admin.domain.standard.model.device.DeviceModelRepository;
import com.estate.expert.admin.domain.standard.problem.Problem;
import com.estate.expert.admin.domain.user.User;
import com.estate.expert.admin.enums.BizResultCode;
import com.estate.expert.admin.service.HierarchyService;
import com.estate.expert.admin.service.ProblemService;
import com.estate.expert.admin.service.UserService;
import com.estate.expert.admin.service.common.CrudServiceBaseImpl;
import com.estate.expert.admin.service.model.DeviceModelService;
import com.estate.expert.admin.utils.tree.TreeRoot;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.List;
import java.util.UUID;

/**
 * 设备模型服务实现
 */
@Service
public class DeviceModelServiceImpl extends CrudServiceBaseImpl<DeviceModel, DeviceModelDto> implements DeviceModelService {

    @Resource
    private DeviceModelRepository repository;

    @Resource
    private HierarchyService hierarchyService;

    @Resource
    private ProblemService problemService;

    @Resource
    private UserService userService;

    @Override
    public PageResp<DeviceModelDto> list(String keyword, PageReq pageReq) {
        var page = repository.findAllByKeyword(keyword, pageReq.toPageRequest());
        return PageResp.of(page, toDto(page.getContent()));
    }

    @Transactional
    @Override
    public DeviceModel add(User creator, DeviceModel entity) {
        var hierarchy = hierarchyService.clone(HierarchyIds.DEVICE);

        // 对于设备模型而言，需要克隆所有的问题
        problemService.cloneProblems(HierarchyIds.DEVICE, hierarchy.getId());
        // 初始化模型
        entity.setHierarchy(hierarchy);
        entity.setEnable(true);
        entity.setPublished(false);
        if(entity.getVersion() == null)
            entity.setVersion(0);
        return super.add(creator, entity);
    }

    @Override
    public DeviceModel copy(User user, Integer id) {
        var model = get(id);
        BizResultCode.ENTITY_NOT_FOUND.check(model == null);

        // 复制模型
        var clone = new DeviceModel();
        BeanUtils.copyProperties(model, clone);

        clone.setVersion(0);

        var newName = String.format("%s##%s##", model.getName(), UUID.randomUUID().toString().substring(0, 8));
        // 克隆的模型名称为随机字符串，不需要存在名字
        clone.setName(newName);
        return add(user, clone);
    }

    @Override
    public DeviceModel edit(DeviceModel entity) {
        BizResultCode.MODEL_PUBLISHED_CANNOT_MODIFY.check(entity.isPublished());
        return super.edit(entity);
    }

    @Override
    public void publish(User user, Integer id) {
        var model = get(id);
        BizResultCode.ENTITY_NOT_FOUND.check(model == null);

        // 发布模型
        model.setPublished(true);
        save(model);
    }

    @Override
    public void setEnable(User user, Integer modelId, boolean enable) {
        var model = get(modelId);
        BizResultCode.ENTITY_NOT_FOUND.check(model == null);
        model.setEnable(enable);
        save(model);
    }

    @Override
    public List<DeviceModel> findActiveModels() {
        return repository.findActiveModels();
    }

    @Override
    public DeviceModel getDefaultModel() {
        return repository.findByName("默认设备模型");
    }

    @Override
    public void createDefaultModel() {
        var model = getDefaultModel();
        if(model != null){
            return;
        }

        // 初始化默认模型
        var modelDto = DeviceModelDto.builder()
                .name("默认设备模型")
                .description("默认设备模型")
                .enable(true)
                .published(true)
                .build();
        model = add(userService.getSystemUser(), modelDto);
        publish(userService.getSystemUser(), model.getId());
    }

    @Override
    public TreeRoot<HierarchyData> getHierarchyTree(Model model) {
        return hierarchyService.get(model.getHierarchy().getId()).getContent();
    }

    @Override
    public List<Integer> getProblemIds(Model model, DeviceType deviceType) {
        return problemService.listIds(model.getHierarchy().getId(), List.of(deviceType.hierarchyPath()));
    }

    @Override
    public List<Problem> listProblems(Model model, String hierarchyPath) {
        BizResultCode.HIERARCHY_NODE_NOT_FOUND.check(hierarchyPath == null);
        var allPaths = hierarchyService.findAllPaths(model.getHierarchy().getId(), List.of(hierarchyPath));
        if(allPaths.isEmpty()){
            return List.of();
        }

        return problemService.findProblems(model.getHierarchy().getId(), allPaths, null);
    }

    @Override
    public void notifyHierarchyChange(Integer hierarchyId) {
        var model = repository.findByHierarchyId(hierarchyId);
        if(model == null){
            return;
        }

        // 更新模型版本
        model.setVersion(model.getVersion() + 1);
        save(model);
    }
}