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

import com.estate.expert.admin.domain.common.IDtoBase;
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.expert.Expert;
import com.estate.expert.admin.domain.standard.expert.matrix.CompareMatrix;
import com.estate.expert.admin.domain.standard.expert.matrix.MembershipMatrix;
import com.estate.expert.admin.domain.standard.expert.matrix.MembershipMatrixRowDto;
import com.estate.expert.admin.domain.standard.expert.matrix.WeightMatrixRow;
import com.estate.expert.admin.domain.standard.hierachy.HierarchyData;
import com.estate.expert.admin.domain.standard.model.Model;
import com.estate.expert.admin.service.common.CrudServiceBase;
import com.estate.expert.admin.utils.Tuple;
import com.estate.expert.admin.utils.tree.TreeNode;
import com.estate.expert.admin.utils.tree.TreeRoot;

import javax.lang.model.type.NullType;
import java.io.InputStream;
import java.util.List;
import java.util.Map;

/**
 * 专家服务
 * 
 * 包含了专家的基本操作
 * 避免重复编写基础的专家代码以及不必要的测试
*/
public interface ExpertService<T extends Expert, D extends IDtoBase> extends CrudServiceBase<T, D> {

    //////      初始化专家      //////
    T getDefaultExpert();

    /**
     * 创建默认专家
     */
    void createDefaultExpert();

    /**
     * 列表
     * 
     * @param keyword 关键词
     * @param modelId 模型ID
     * @param pageReq 分页请求
     * @return 列表
     */
    PageResp<D> list(String keyword, Integer modelId, PageReq pageReq);

    /**
     * 获取打分专家列表
     * 
     * @param modelId 模型ID
     * @return 打分专家列表
     */
    List<T> listScoreExperts(Integer modelId);

    /**
     * 获取模糊专家列表
     * 
     * @param modelId 模型ID
     * @return 模糊专家列表
     */
    List<T> listFuzzyExperts(Integer modelId);

    ///////    打分专家判断矩阵操作    //////
    /**
     * 编辑打分专家权重映射
     * 
     * @param expertId 专家ID
     * @param hierarchyPath 层级路径
     * @param weight 权重
     */
    void editWeightMap(Integer expertId, String hierarchyPath, Float weight);

    /**
     * 获取打分专家权重映射
     * 
     * @param expertId 专家ID
     * @param hierarchyPath 层级路径
     * @return 权重映射
     */
    Map<String, Tuple<String, Float>> weightMap(Integer expertId, String hierarchyPath);

    /**
     * 获取打分专家权重矩阵
     * 
     * @param expertId 专家ID
     * @param hierarchyPath 层级路径
     * @return 权重矩阵
     */
    List<WeightMatrixRow> weightMatrix(Integer expertId, String hierarchyPath);

    /**
     * 编辑打分专家权重矩阵行
     * 
     * @param expertId 专家ID
     * @param row 权重矩阵行
     */
    void editWeightMatrixRow(Integer expertId, WeightMatrixRow row);

    /**
     * 编辑打分专家权重矩阵行
     * 
     * @param expertId 专家ID
     * @param row 权重矩阵行
     */
    void editWeightMatrixRows(Integer expertId, List<WeightMatrixRow> row);


    //////  隶属度矩阵操作  //////
    /**
     * 获取隶属度矩阵
     * 
     * @param expertId 专家ID
     * @return 隶属度矩阵
     */
    MembershipMatrix getMembershipMatrix(Integer expertId);

    /**
     * 编辑隶属度矩阵
     * 
     * @param expertId 专家ID
     * @param data 隶属度矩阵
     */
    void editMembershipMatrix(Integer expertId, float[][][][][] data);

    /**
     * 编辑隶属度矩阵行
     * 
     * @param expertId 专家ID
     * @param row 隶属度矩阵行
     */
    void editMembershipMatrixRow(Integer expertId, MembershipMatrixRowDto row);

    /**
     * 获取隶属度矩阵行列表
     * 
     * @param expertId 专家ID
     * @param p1 层级1
     * @param p2 层级2
     * @param p3 层级3
     * @param p4 层级4
     * @return 隶属度矩阵行列表
     */
    List<MembershipMatrixRowDto> listMembershipMatrixRows(Integer expertId, Integer p1, Integer p2, Integer p3, Integer p4);

    /**
     * 导入隶属度矩阵
     * 
     * @param expertId 专家ID
     * @param inputStream 输入流
     */
    void importMembershipMatrix(Integer expertId, InputStream inputStream);

    ///////     模糊专家判断矩阵操作    //////
    /**
     * 获取模糊专家判断矩阵
     * 
     * @param expertId 专家ID
     * @param hierarchyPath 层级路径
     * @return 模糊专家判断矩阵
     */
    CompareMatrix getFuzzyMatrix(Integer expertId, String hierarchyPath);

    /**
     * 获取模糊专家判断矩阵
     * 
     * @param expertId 专家ID
     * @param hierarchyPath 层级路径
     * @param indexCols 索引列
     * @return 模糊专家判断矩阵
     */
    CompareMatrix getFuzzyMatrix(Integer expertId, String hierarchyPath, String [] indexCols);

    /**
     * 编辑模糊专家判断矩阵
     * 
     * @param expertId 专家ID
     * @param hierarchyPath 层级路径
     * @param matrix 模糊专家判断矩阵
     */
    void editFuzzyMatrix(Integer expertId, String hierarchyPath, CompareMatrix matrix);


    ///////    获取打分用的权重树    //////

    /**
     * 获取模型树
     * 
     * @param model 模型
     * @return 模型树
     */
    TreeRoot<HierarchyData> getModelTree(Model model);

    /**
     * 获取空模型树
     * 
     * @param expertId 专家ID
     * @return 空模型树
     */
    TreeNode<NullType> getNullModelTree(Integer expertId);

    /**
     * 获取层级树
     * 
     * @param expertId 专家ID
     * @return 层级树
     */
    TreeRoot<HierarchyData> getHierarchyTree(Integer expertId);
}