package com.estate.expert.admin.controller.admin.standard;

import com.estate.expert.admin.domain.common.IDtoBase;
import com.estate.expert.admin.domain.common.request.BatchReq;
import com.estate.expert.admin.domain.common.request.PageReq;
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.MembershipMatrixRowDto;
import com.estate.expert.admin.domain.standard.expert.matrix.WeightMatrixRow;
import com.estate.expert.admin.domain.user.User;
import com.estate.expert.admin.enums.BizResultCode;
import com.estate.expert.admin.service.expert.ExpertService;
import com.estate.expert.common.domain.Session;
import com.estate.expert.common.rpc.Result;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;

import javax.validation.constraints.NotNull;
import java.util.List;

/**
 * 专家控制器
 * 包含两类专家: 打分专家和模糊专家
 * 抽象操作
 */
public abstract class ExpertController<T extends Expert, D extends IDtoBase> {

    protected abstract ExpertService<T, D> getExpertService();

    ///////     基础操作        ///////
    @ApiOperation(value = "专家列表")
    @PostMapping("/list")
    public Result list(@RequestParam(value = "keyword", required = false) String keyword,
                       @RequestParam(value = "modelId", required = false) Integer modelId,
                       @ApiParam(value = "分页参数") @Validated @RequestBody PageReq pageReq) {
        return Result.success(getExpertService().list(keyword, modelId, pageReq));
    }

    @ApiOperation(value = "添加专家")
    @PostMapping("/add")
    public Result add(Session session,
                      @Validated @RequestBody D dto) {
        getExpertService().add((User)session.getUser(), dto);
        return Result.success();
    }

    @ApiOperation(value = "编辑专家")
    @PostMapping("/edit")
    public Result edit(@Validated @RequestBody D dto) {
        getExpertService().edit(dto);
        return Result.success();
    }

    @ApiOperation(value = "删除专家")
    @PostMapping("/batch/del")
    public Result batchDel( @Validated @RequestBody BatchReq request) {
        getExpertService().deleteAllById(request.getIds());
        return Result.success();
    }

    @ApiOperation(value = "综合体系树")
    @GetMapping("/tree")
    public Result tree(@ApiParam(value = "ID") @RequestParam("id") Integer id) {
        return Result.success(getExpertService().getNullModelTree(id));
    }

//    @GetMapping("/download/template")
//    public Result downloadTemplate() {
//        return null;
//    }


    ///////     打分专家判断矩阵操作    //////
    @ApiOperation("打分专家判断矩阵获取")
    @GetMapping("/weight/children")
    public Result getChildrenWeights(@RequestParam("expertId") Integer expertId,
                                                         @RequestParam("hierarchyPath")String hierarchyPath) {
        return Result.success(getExpertService().weightMatrix(expertId, hierarchyPath));
    }

    @ApiOperation("打分专家判断矩阵修改")
    @PostMapping("/weight/edit/row")
    public Result editWeight(@RequestParam("expertId") Integer expertId,
                             @RequestBody WeightMatrixRow row) {
        getExpertService().editWeightMatrixRow(expertId, row);
        return Result.success();
    }

    @ApiOperation("打分专家判断矩阵批量修改")
    @PostMapping("/weight/edit")
    public Result editWeight(@RequestParam("expertId") Integer expertId,
                             @RequestBody List<WeightMatrixRow> rows) {
        getExpertService().editWeightMatrixRows(expertId, rows);
        return Result.success();
    }

//    @ApiOperation("打分专家判断矩阵导入")
//    @PostMapping("/scoreMatrix/import")
//    public Result importScoreMatrix(@RequestParam("expertId") Integer expertId,
//                             @RequestParam("hierarchyPath")String hierarchyPath,
//                             @RequestPart("file")MultipartFile file) {
//        // 去读取对应路径的excel文件，然后解析，然后调用
////        expertService.importMatrixFile(session.getUserId(), request);
//        return Result.success();
//    }
//
//    @ApiOperation("打分专家判断矩阵导出")
//    @PostMapping("/scoreMatrix/export")
//    public Result exportScoreMatrix(@RequestParam("expertId") Integer expertId,
//                             @RequestParam("hierarchyPath")String hierarchyPath) {
//        return Result.success();
//    }

    ///////     模糊专家判断矩阵操作    //////
    @ApiOperation("模糊专家判断矩阵获取")
    @GetMapping("/fuzzyMatrix/get")
    public Result<CompareMatrix> getFuzzyMatrix(@NotNull @RequestParam("expertId") Integer expertId,
                                                @NotNull @RequestParam("hierarchyPath")String hierarchyPath) {
        return Result.success(getExpertService().getFuzzyMatrix(expertId, hierarchyPath));
    }

    @ApiOperation("模糊专家判断矩阵修改")
    @PostMapping("/fuzzyMatrix/edit")
    public Result editFuzzyMatrix(@NotNull @RequestParam("expertId") Integer expertId,
                                  @NotNull @RequestParam("hierarchyPath")String hierarchyPath,
                                  @Validated @RequestBody CompareMatrix value) {
        getExpertService().editFuzzyMatrix(expertId, hierarchyPath, value);
        return Result.success();
    }

//    @ApiOperation("模糊专家判断矩阵导入")
//    @PostMapping("/fuzzyMatrix/import")
//    public Result importFuzzyMatrix(@RequestParam("expertId") Integer expertId,
//                                    @RequestParam("hierarchyPath")String hierarchyPath,
//                                    @RequestPart("file")MultipartFile file) {
//        // 去读取对应路径的excel文件，然后解析，然后调用
//        return Result.success();
//    }
//
//    @ApiOperation("模糊专家判断矩阵导出")
//    @PostMapping("/fuzzyMatrix/export")
//    public Result exportFuzzyMatrix(@RequestParam("expertId") Integer expertId,
//                                    @RequestParam("hierarchyPath")String hierarchyPath) {
//        return Result.success();
//    }

    @ApiOperation("隶属度矩阵导出")
    @PostMapping("/membershipMatrix/export")
    public Result exportMembershipMatrix(@ApiParam("专家ID") @RequestParam("expertId") Integer expertId) {
        return Result.success();
    }

    @ApiOperation("隶属度矩阵获取")
    @GetMapping("/membershipMatrix/get")
    public Result getMembershipMatrix(@ApiParam("专家ID") @RequestParam("expertId") Integer expertId) {
        var matrix = getExpertService().getMembershipMatrix(expertId);
        BizResultCode.MEMBERSHIP_MATRIX_LOAD_ERROR.check(matrix == null);
        return Result.success(matrix.getData());
    }

    @ApiOperation("隶属度矩阵修改(整个矩阵)")
    @PostMapping("/membershipMatrix/edit")
    public Result editMembershipMatrix(@ApiParam("专家ID") @RequestParam("expertId") Integer expertId,
                                       @Validated @RequestBody float[][][][][] data) {
        getExpertService().editMembershipMatrix(expertId, data);
        return Result.success();
    }

    @ApiOperation("隶属度矩阵修改(行)")
    @PostMapping("/membershipMatrix/row/edit")
    public Result editMembershipMatrixRow(@ApiParam("专家ID") @RequestParam("expertId") Integer expertId,
                                          @Validated @RequestBody MembershipMatrixRowDto row) {
        getExpertService().editMembershipMatrixRow(expertId, row);
        return Result.success();
    }

    @ApiOperation("隶属度矩阵修获取(行)")
    @GetMapping("/membershipMatrix/rows")
    public Result listMembershipMatrixRows(@ApiParam("专家ID") @RequestParam("expertId") Integer expertId,
                                           @ApiParam("一级隐患数量") @RequestParam(value = "p1", required = false) Integer p1,
                                           @ApiParam("二级隐患数量") @RequestParam(value = "p2", required = false) Integer p2,
                                           @ApiParam("三级隐患数量") @RequestParam(value = "p3", required = false) Integer p3,
                                           @ApiParam("四级隐患数量") @RequestParam(value = "p4", required = false) Integer p4) {
        return Result.success(getExpertService().listMembershipMatrixRows(expertId, p1, p2, p3, p4));
    }

}