package com.zt.modules.sys.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.zt.common.constant.CacheKey;
import com.zt.common.constant.Constant;
import com.zt.common.service.BaseService;
import com.zt.common.utils.CacheUtils;
import com.zt.core.db.annotation.DataFilterParser;
import com.zt.core.db.model.DataFilterField;
import com.zt.core.db.model.DataFilterMethod;
import com.zt.modules.sys.dao.SysInterfaceDao;
import com.zt.modules.sys.dao.SysInterfaceFieldDao;
import com.zt.modules.sys.dto.InterfaceDto;
import com.zt.modules.sys.mapstruct.SysInterfaceMapper;
import com.zt.modules.sys.model.SysInterface;
import com.zt.modules.sys.model.SysInterfaceField;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * SYS_INTERFACE
 *
 * @author hehz
 * @since 1.0.0 2020-06-02
 */
@Service
public class SysInterfaceService extends BaseService<SysInterfaceDao, SysInterface> {

    @Resource
    private SysInterfaceMapper sysInterfaceMapper;
    @Resource
    private DataFilterParser dataFilterParser;
    @Resource
    private SysInterfaceFieldDao sysInterfaceFieldDao;

    private List<SysInterface> getAll() {
        List<SysInterface> interfaces = (List<SysInterface>) CacheUtils.get(Constant.Cache.SYS, CacheKey.SYS_INTERFACE);
        if (interfaces == null) {
            interfaces = baseDao.selectList(new QueryWrapper<SysInterface>().eq(Constant.TableColumn.IS_DELETE,
                    Constant.Bool.NO));

            List<SysInterfaceField> fields = sysInterfaceFieldDao.selectList(new QueryWrapper<SysInterfaceField>().eq(
                    Constant.TableColumn.IS_DELETE, Constant.Bool.NO));

            for (SysInterface anInterface : interfaces) {
                anInterface.setFields(fields.stream().filter(f -> f.getInterfaceId().equals(anInterface.getId()))
                        .collect(Collectors.toList()));
            }
            CacheUtils.put(Constant.Cache.SYS, CacheKey.SYS_INTERFACE, interfaces);
        }
        return interfaces;
    }

    /**
     * 获取接口树
     *
     * @return
     */
    public List<InterfaceDto> tree() {
        List<SysInterface> all = getAll();
        List<InterfaceDto> list = new ArrayList<>();
        Map<String, InterfaceDto> group1Map = new HashMap<>();
        Map<String, InterfaceDto.Group2> group2Map = new HashMap<>();

        for (int i = 0; i < all.size(); i++) {
            SysInterface sysInterface = all.get(i);
            String group1 = sysInterface.getGroup1();
            String group2 = sysInterface.getGroup2();
            String method = sysInterface.getMethod();

            InterfaceDto interfaceDto;
            if (group1Map.containsKey(group1)) {
                interfaceDto = group1Map.get(group1);
            } else {
                interfaceDto = new InterfaceDto(100L + i, 0L, group1);
                list.add(interfaceDto);
                group1Map.put(group1, interfaceDto);
            }

            InterfaceDto.Group2 groug2Dto;
            String group2Key = group1 + ":" + group2;
            if (group2Map.containsKey(group2Key)) {
                groug2Dto = group2Map.get(group2Key);
            } else {
                groug2Dto = new InterfaceDto.Group2(1000000L + i, interfaceDto.getId(), group2);
                interfaceDto.getChildren().add(groug2Dto);
                group2Map.put(group2Key, groug2Dto);
            }

            InterfaceDto.Method methodDto = new InterfaceDto.Method(sysInterface.getId(), groug2Dto.getId(), method,
                    sysInterface.getId());
            groug2Dto.getChildren().add(methodDto);

            List<SysInterfaceField> fields = sysInterface.getFields();
            for (SysInterfaceField field : fields) {
                InterfaceDto.Field dto = new InterfaceDto.Field();
                dto.setId(field.getId());
                dto.setPid(field.getInterfaceId());
                dto.setName(field.getName());
                dto.setField(field.getField());
                dto.setOp(field.getOp());
                dto.setFieldId(field.getId());
                dto.setAccept(field.getAccept());
                dto.setDefaul(field.getDefaul());
                methodDto.getFields().add(dto);
            }

        }
        return list;
    }

    /**
     * 保存自动扫描的接口
     */
    public void saveInterfaces() throws Exception {
        List<DataFilterMethod> methods = dataFilterParser.getFilteredMethods();

        List<SysInterface> interfaces = this.getAll();
        Map<String, SysInterface> interfaceMap = new HashMap<>();
        for (SysInterface interfaceEntity : interfaces) {
            interfaceMap.put(interfaceEntity.getUrl(), interfaceEntity);
        }

        for (DataFilterMethod method : methods) {
            SysInterface interfaceDb = interfaceMap.get(method.getUrl());
            if (interfaceDb == null) {// 新加的
                // 新增接口
                SysInterface interfaceEntity = getByMethod(method);
                interfaceEntity.setDelete(false);
                baseDao.insert(interfaceEntity);
                // 新增接口字段
                for (DataFilterField field : method.getFields()) {
                    this.addInterfaceField(interfaceEntity.getId(), field);
                }
            } else {// 已有的
                interfaceMap.remove(interfaceDb.getUrl());// 从map删除
                // 判断接口名称是否需要修改
                if (!interfaceDb.getInterfaceName().equals(method.getMethodName())) {// 需要修改的
                    SysInterface entity = sysInterfaceMapper.fromMethod(method);
                    entity.setId(interfaceDb.getId());
                    entity.setDelete(false);
                    baseDao.updateById(entity);
                }
                // 判断字段是否需要修改
                Map<String, SysInterfaceField> fieldMap = interfaceDb.getFields().stream()
                        .collect(Collectors.toMap(f -> f.getField(), f -> f));
                for (DataFilterField field : method.getFields()) {
                    SysInterfaceField fieldDb = fieldMap.get(field.getField());
                    if (fieldDb == null) { // 新加的
                        this.addInterfaceField(interfaceDb.getId(), field);
                    } else {
                        fieldMap.remove(fieldDb.getField());// 从map删除
                        if (!fieldDb.getName().equals(field.getName()) || !fieldDb.getAccept().equals(field.getAccept()) || fieldDb.getOp().equals(field.getOp())) {// 需要修改
                            fieldDb.setName(field.getName());
                            fieldDb.setAccept(field.getAccept());
                            fieldDb.setOp(field.getOp());
                            sysInterfaceFieldDao.updateById(fieldDb);
                        }
                    }
                }
                for (SysInterfaceField fieldDb : fieldMap.values()) {// 剩余的设置为无效
                    fieldDb.setDelete(true);
                    sysInterfaceFieldDao.updateById(fieldDb);
                }
            }
        }
        for (SysInterface interfaceEntityDb : interfaceMap.values()) {// 剩余的设置为无效
            interfaceEntityDb.setDelete(true);
            baseDao.updateById(interfaceEntityDb);
        }

        CacheUtils.remove(Constant.Cache.SYS, CacheKey.SYS_INTERFACE);// 清除缓存
    }

    private void addInterfaceField(Long interfaceId, DataFilterField field) {
        SysInterfaceField entity = new SysInterfaceField();
        entity.setInterfaceId(interfaceId);
        entity.setField(field.getField());
        entity.setAccept(field.getAccept());
        entity.setName(field.getName());
        entity.setOp(field.getOp());
        entity.setDelete(false);
        sysInterfaceFieldDao.insert(entity);
    }

    public SysInterface getInterfaceByUrl(String url) {
        List<SysInterface> list = getAll().stream().filter(entity -> entity.getUrl().equals(url))
                .collect(Collectors.toList());
        return list.size() > 0 ? list.get(0) : null;
    }

    private SysInterface getByMethod(DataFilterMethod method) {
        SysInterface sysInterface = new SysInterface();
        sysInterface.setUrl(method.getUrl());
        sysInterface.setGroup1(method.getSwagger());
        sysInterface.setGroup2(method.getApiTags());
        sysInterface.setMethod(method.getMethod());
        sysInterface.setDelete(false);
        return sysInterface;
    }

}