package com.nx.umms.controller;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.nx.umms.common.utils.ExcelUtils;
import com.nx.umms.common.utils.res.ResultVO;
import com.nx.umms.model.dto.ModelDTO;
import com.nx.umms.model.dto.ModelPropertyDTO;
import com.nx.umms.model.dto.ModelRelationDTO;
import com.nx.umms.model.dto.ModelSubscribeDTO;
import com.nx.umms.model.entity.Model;
import com.nx.umms.model.entity.ModelAudit;
import com.nx.umms.model.entity.ModelSubscribe;
import com.nx.umms.model.vo.ModelAuditVO;
import com.nx.umms.model.vo.ModelPropertyVO;
import com.nx.umms.service.*;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @Auther: wangjian
 * @Date: 2022/2/21 16:17
 * @Description:模型库管理接口
 */

@Slf4j
@RequestMapping("/model-base/v1")
@RestController
@Api(tags = "模型库管理接口")
public class ModelBaseController {

    @Autowired
    private ModelService modelService;

    @Autowired
    private ModelPropertyService modelPropertyService;

    @Autowired
    private ModelAuditService modelAuditService;

    @Autowired
    private ModelSubscribeService modelSubscribeService;

    @Autowired
    private ModelRelationService modelRelationService;

    /**
     * 模型-增加
     *
     * @return
     */
    @ApiOperation("模型-增加")
    @PostMapping("/create/model")
    public ResultVO createModel(@RequestBody ModelDTO modelDTO) {

        return ResultVO.success(modelService.createModel(modelDTO));
    }

    /**
     * 模型-查询列表
     *
     * @return
     */
    //@ApiOperation("模型-查询列表")
    @GetMapping("/get/model/list")
    public ResultVO getModelList(@ApiParam(value = "模型订阅编号") @RequestParam(value = "objId", required = false) String objId,
                                   @ApiParam(value = "模型编码") @RequestParam(value = "modelCode", required = false) String modelCode,
                                   @ApiParam(value = "归属省编码数组EQ: ddas232, 2e1ssda, 3232") @RequestParam(value = "ownerCompanyCodes", required = false) List<String> ownerCompanyCodes,
                                   @ApiParam(value = "归属分类编码数组") @RequestParam(value = "modelGroupCodes", required = false) List<String> modelGroupCodes,
                                   @ApiParam(value = "当前页") @RequestParam(value = "currentPage", required = false) Integer currentPage,
                                   @ApiParam(value = "每页数量") @RequestParam(value = "pageSize", required = false) Integer pageSize) {

        PageHelper.startPage(currentPage, pageSize);
        List<Model> modelList = modelService.getModelList(objId, modelCode, ownerCompanyCodes, modelGroupCodes);
        PageInfo<Model> pageInfo = new PageInfo<>(modelList);
        return ResultVO.success(pageInfo);
    }

    /**
     * 模型-查询列表
     *
     * @return
     */
    @ApiOperation("模型-查询列表")
    @GetMapping("/get/model/getModeBaselList")
    public ResultVO getModeBaselList(@ApiParam(value = "所属级别") @RequestParam(value = "belongLevel", required = false) String belongLevel,
                                       @ApiParam(value = "模型编码") @RequestParam(value = "modelCode", required = false) String modelCode,
                                       @ApiParam(value = "当前页") @RequestParam(value = "currentPage") Integer currentPage,
                                       @ApiParam(value = "每页数量") @RequestParam(value = "pageSize") Integer pageSize,
                                       @ApiParam(value = "模糊搜索条件") @RequestParam(value = "searchCondition",required = false) String searchCondition) {
            return modelService.getModeBaselList(belongLevel, modelCode, currentPage, pageSize, searchCondition);

    }

    /**
     * 模型-删除
     *
     * @return
     */
    @ApiOperation("模型-删除")
    @PostMapping("/delete/model")
    public ResultVO deleteModel(@ApiParam(value = "模型订阅编号") @RequestParam(value = "objId", required = false) String objId,
                                  @ApiParam(value = "模型编码") @RequestParam(value = "modelCode", required = false) String modelCode) {
        return ResultVO.success(modelService.deleteModel(objId, modelCode));
    }


    /**
     * 模型-修改
     *
     * @return
     */
    @ApiOperation("模型-修改")
    @PostMapping("/update/model")
    public ResultVO updateModel(@RequestBody ModelDTO modelDTO) {
        return ResultVO.success(modelService.updateModel(modelDTO));
    }

    /**
     * 模型-导入
     *
     * @return
     */
    @ApiOperation("模型-导入")
    @PostMapping("/import/model")
    public ResultVO importModel(@RequestParam("file") MultipartFile file) throws IOException {
        return ResultVO.success(modelService.importModel(file));
    }

    /**
     * 模型-下发/批量下发
     * TODO
     *
     * @return
     */
    @ApiOperation("模型-下发|批量下发")
    @PostMapping("/issue/model")
    public ResultVO issueModel() {
        return ResultVO.success();
    }

    /**
     * 模型注册-上传
     *
     * @return
     */
    @ApiOperation("模型注册-上传")
    @PostMapping("/register/model")
    public ResultVO registerModel() {
        return ResultVO.success();
    }

    /**
     * 模型订阅-增加
     *
     * @return
     */
    @ApiOperation("模型订阅-增加")
    @PostMapping("/create/model/subscribe")
    public ResultVO createModelSubscribe(@RequestBody ModelSubscribeDTO modelSubscribeDTO) {
        return ResultVO.success(modelSubscribeService.createModelSubscribe(modelSubscribeDTO));
    }

    /**
     * 模型属性-删除/批量删除
     *
     * @return
     */
    @ApiOperation("模型订阅-删除/批量删除")
    @PostMapping("/delete/model/subscribe")
    public ResultVO deleteModelSubscribe(@ApiParam(value = "订阅编号集合") @RequestBody List<String> ids) {
        return ResultVO.success(modelSubscribeService.deleteBatchModelSubscribe(ids));
    }

    /**
     * 模型订阅-查询
     *
     * @return
     */
    @ApiOperation("模型订阅-查询")
    @GetMapping("/get/model/subscribe")
    public ResultVO getModelSubscribe(@ApiParam(value = "模型订阅编号") @RequestParam(value = "objId", required = false) String objId,
                                        @ApiParam(value = "模型编码") @RequestParam(value = "modelCode", required = false) String modelCode,
                                        @ApiParam(value = "订阅公司编码") @RequestParam(value = "subsCompanyCode", required = false) String subsCompanyCode,
                                        @ApiParam(value = "当前页") @RequestParam(value = "currentPage", required = false) Integer currentPage,
                                        @ApiParam(value = "每页数量") @RequestParam(value = "pageSize", required = false) Integer pageSize) {

        PageHelper.startPage(currentPage, pageSize);
        List<ModelSubscribe> modelSubscribeList = modelSubscribeService.getModelSubscribeList(objId, modelCode, subsCompanyCode);
        PageInfo<ModelSubscribe> pageInfo = new PageInfo<>(modelSubscribeList);

        return ResultVO.success(pageInfo);
    }

    /**
     * 模型事记-查询
     *
     * @return
     */
    @ApiOperation("模型事记-查询")
    @GetMapping("/get/model/note")
    public ResultVO getModelNote(@RequestParam(value = "modelCode") String modelCode) {

        List<ModelAudit> modelAuditList = modelAuditService.getModelAuditList(modelCode);

        return ResultVO.success(modelAuditList);
    }

    /**
     * 模型事记-增加
     *
     * @return
     */
    @ApiOperation("模型事记-增加")
    @PostMapping("create/model/note")
    public ResultVO createModelNote() {
        return ResultVO.success();
    }

    /**
     * 模型事记-导出
     *
     * @return
     */
    @ApiOperation("模型事记-导出")
    @PostMapping("export/model/note")
    public ResultVO exportModelNote(HttpServletResponse response,
                                      @ApiParam(value = "模型编码") @RequestParam(value = "modelCode", required = false) String modelCode) throws IOException {
        // 查询要导出的数据
        List<ModelAudit> modelAuditList = modelAuditService.getModelAuditList(modelCode);

        //users集合转成export集合
        List<ModelAuditVO> exportVOList = modelAuditList.stream().map(modelNote -> {
            ModelAuditVO vo = new ModelAuditVO();
            BeanUtils.copyProperties(modelNote, vo);
            return vo;
        }).collect(Collectors.toList());

        ExcelUtils.exportExcel(response, "测试导出模型事记", "测试导出模型事记", "测试导出模型事记.xlsx", exportVOList, ModelAuditVO.class);

        return ResultVO.success();
    }

    /**
     * 模型属性-增加
     *
     * @return
     */
    @ApiOperation("模型属性-增加")
    @PostMapping("create/model/property")
    public ResultVO createModelProperty(@RequestBody ModelPropertyDTO modelPropertyDTO) {

        Integer i = modelPropertyService.createModelProperty(modelPropertyDTO);
        return ResultVO.success(i);
    }

    /**
     * 模型属性-查询列表
     *
     * @return
     */
    @ApiOperation("模型属性-查询列表")
    @GetMapping("get/model/property/list")
    public ResultVO getModelPropertyList(@ApiParam(value = "模型编码") @RequestParam(value = "modelCode", required = false) String modelCode,
                                           @ApiParam(value = "模型所属类型编码") @RequestParam(value = "modelGroupCode", required = false) String modelGroupCode,
                                           @ApiParam(value = "公司编码") @RequestParam(value = "ownerCompanyCode", required = false) String ownerCompanyCode,
                                           @ApiParam(value = "当前页") @RequestParam(value = "currentPage", required = false) Integer currentPage,
                                           @ApiParam(value = "每页数量") @RequestParam(value = "pageSize", required = false) Integer pageSize) {

        PageHelper.startPage(currentPage, pageSize);
        List<ModelPropertyVO> pageInfo = modelPropertyService.listModelPropertyVO(currentPage, pageSize, modelCode, ownerCompanyCode, modelGroupCode);
        PageInfo<ModelPropertyVO> pageInfo1 = new PageInfo<>(pageInfo);

        return ResultVO.success(pageInfo1);
    }

    /**
     * 模型属性-修改
     *
     * @return
     */
    @ApiOperation("模型属性-修改")
    @PostMapping("/update/model/property")
    public ResultVO updateModelProperty(@RequestBody ModelPropertyDTO modelPropertyDTO) {

        return ResultVO.success(modelPropertyService.updateModelProperty(modelPropertyDTO));
    }

    /**
     * 模型属性-删除/批量删除
     *
     * @return
     */
    @ApiOperation("模型属性-删除/批量删除")
    @PostMapping("/delete/model/property")
    public ResultVO deleteModelProperty(@ApiParam(value = "属性ID集合") @RequestBody List<String> ids) {
        return ResultVO.success(modelPropertyService.deleteBatchModelProperty(ids));
    }

    /**
     * 模型拓扑关系-增加
     *
     * @return
     */
    @ApiOperation("模型拓扑关系-增加")
    @PostMapping("create/model/topology")
    public ResultVO createModelTopology(@RequestBody ModelRelationDTO modelRelationDTO) {

        Integer i = modelRelationService.createModelRelation(modelRelationDTO);
        return ResultVO.success(i);
    }

    /**
     * 模型拓扑关系-查询
     *
     * @return
     */
    @ApiOperation("模型拓扑关系-查询")
    @GetMapping("/get/model/topology")
    public ResultVO getModelTopology(@ApiParam(value = "模型拓扑关系编号") @RequestParam(value = "objId", required = false) String objId,
                                       @ApiParam(value = "模型归属分类编码") @RequestParam(value = "modelGroupCode", required = false) String modelGroupCode,
                                       @ApiParam(value = "模型编码") @RequestParam(value = "modelCode", required = false) String modelCode) {
        return ResultVO.success(modelRelationService.getModelRelationList(objId, modelGroupCode, modelCode));
    }

    /**
     * 模型拓扑关系-删除
     *
     * @return
     */
    @ApiOperation("模型拓扑关系-删除")
    @PostMapping("/delete/model/topology")
    public ResultVO deleteModelTopology(@ApiParam(value = "模型拓扑关系编号") @RequestParam(value = "objId", required = false) String objId,
                                          @ApiParam(value = "模型编码") @RequestParam(value = "modelCode", required = false) String modelCode) {
        return ResultVO.success(modelRelationService.deleteModelRelation(objId, modelCode));
    }


    @ApiOperation("模型-导航树")
    @GetMapping("/delete/model/modelListNavigation")
    public ResultVO modelListNavigation(@RequestParam(required = false) String searchCondition) {
        return modelSubscribeService.modelListNavigation(searchCondition);
    }
}