package com.hivekion.baseData.controller;

import com.hivekion.baseData.domain.TblEntity;
import com.hivekion.baseData.entity.Fightpowerhierarchy;
import com.hivekion.baseData.service.FightpowerhierarchyService;
import com.hivekion.baseData.service.ITblEntityService;
import com.hivekion.common.entity.ResponseData;
import com.hivekion.common.entity.TreeEntity;
import com.hivekion.common.entity.TreeNode;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import javax.annotation.Resource;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/tree")
@Api(value = "", tags = {"树数据-系统中各类树接口"})
public class TreeController {

  @Resource
  private ITblEntityService tblEntityService;
  @Resource
  private FightpowerhierarchyService fightpowerhierarchyService;

  @GetMapping("/armament")
  @ApiOperation(value = "装备树", notes = "")
  public ResponseData<List<TreeNode>> armamentTree(
      @ApiParam(value = "父节点ID，指定从哪个节点开始返回装备树") Integer id) {
    List<TreeNode> nodeList = new ArrayList<>();
    List<TblEntity> list = tblEntityService.list();
    //排序
    list.sort((a, b) -> {
      if (a.getDisplayIndex() == null) {
        a.setDisplayIndex("999");
      }
      if (b.getDisplayIndex() == null) {
        b.setDisplayIndex("999");
      }
      return Integer.compare(Integer.parseInt(a.getDisplayIndex()),
          Integer.parseInt(b.getDisplayIndex()));
    });
    addTreeNodeToList(nodeList, id, list);
    return ResponseData.success(nodeList);
  }

  @GetMapping("/organization")
  @ApiOperation(value = "组织机构树", notes = "")
  public ResponseData<List<TreeNode>> organizedTree(Integer id) {
    List<TreeNode> nodeList = new ArrayList<>();
    List<Fightpowerhierarchy> organizationList = fightpowerhierarchyService.list();
    //排序
    organizationList.sort(Comparator.comparingInt(Fightpowerhierarchy::getId));
    addTreeNodeToList(nodeList, id, organizationList);
    return ResponseData.success(nodeList);
  }

  /**
   * 增加树节点到list
   */
  private <T extends TreeEntity> void addTreeNodeToList(List<TreeNode> nodeList, Integer id, List<T> list) {
    Map<Integer, T> entityMap = idMap(list);
    Map<Integer, List<T>> parentMap = parentIdMap(list);
    if (id != null) {
      T entity = entityMap.get(id);
      if (entity != null) {
        buildOneEntity(nodeList, entity, parentMap);
      }
    } else {
      parentMap.forEach((key, value) -> {
        if (key == null || key <= 0) {
          value.forEach(t -> buildOneEntity(nodeList, t, parentMap));
        }
      });
    }
  }

  /**
   * 建立一个节点的树形数据
   */
  private <T extends TreeEntity> void buildOneEntity(List<TreeNode> nodeList, T entity,
      Map<Integer, List<T>> parentMap) {
    TreeNode node = new TreeNode(String.valueOf(entity.getId()), entity.getTitleName(),
        String.valueOf(entity.getId()));
    nodeList.add(node);
    node.setData(entity);
    buildRecursionArmamentTree(node, parentMap);
  }

  private <T extends TreeEntity> void buildRecursionArmamentTree(TreeNode info, Map<Integer, List<T>> parentMap) {
    Integer key = Integer.parseInt(info.getKey());
    if (parentMap.containsKey(key)) {
      List<TreeNode> children = new ArrayList<>();
      info.setChildren(children);
      parentMap.get(key).forEach(a -> {
        TreeNode innerNode = new TreeNode(String.valueOf(a.getId()), a.getTitleName(),
            String.valueOf(a.getId()));
        children.add(innerNode);
        buildRecursionArmamentTree(innerNode, parentMap);
      });
    }
  }

  private <T extends TreeEntity> Map<Integer, T> idMap(List<T> list) {
    return list.stream().collect(Collectors.toMap(TreeEntity::getId, a -> a));
  }

  private <T extends TreeEntity> Map<Integer, List<T>> parentIdMap(List<T> list) {
    return list.stream().collect(Collectors.groupingBy(a -> {
      if (a.getParentId() == null) {
        a.setParentId(0);
      }
      return a.getParentId();
    }, LinkedHashMap::new, Collectors.toList()));
  }
}