package com.lantone.web.cdss;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.lantone.common.api.CommonResult;
import com.lantone.entity.cdss.MappingConfig;
import com.lantone.entity.cdss.wrapper.MappingConfigWrapper;
import com.lantone.facade.cdss.MappingConfigFacade;
import com.diagbot.util.BeanUtil;
import com.lantone.vo.cdss.IdListVO;
import com.lantone.vo.cdss.IdVO;
import com.lantone.vo.cdss.MappingConfigPageVO;
import com.lantone.vo.cdss.MappingConfigVO;
import com.lantone.vo.cdss.PrecDataVO;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import springfox.documentation.annotations.ApiIgnore;

import javax.servlet.http.HttpServletResponse;
import javax.validation.Valid;
import java.util.List;

/**
 * @Description:
 * @Author:zhaops
 * @time: 2021/6/10 16:34
 */
@RestController
@RequestMapping("/tran/mappingConfig")
@Api(value = "术语关联相关API", tags = { "术语关联相关API" })
@SuppressWarnings("unchecked")
public class MappingConfigController {
    @Autowired
    private MappingConfigFacade mappingConfigFacade;


    @ApiOperation(value = "数据导入模板导出[by:zhaops]",
            notes = "type（必填）： 类型：1-化验、3-辅检、4-诊断、5-药品、6-手术和操作、7-科室、8-输血、10-量表、11-护理、12-中医诊断、13-中医证候、14-麻醉、16-给药途径 <br>")
    @PostMapping("/exportExcelModule")
    public void exportExcelModule(HttpServletResponse response, @RequestBody @Valid MappingConfigVO mappingConfigVO) {
        mappingConfigFacade.exportExcelModule(response, mappingConfigVO);
    }

    @ApiOperation(value = "预匹配导入术语校验[by:zhaops]",
            notes = "file（必填）：预匹配文件 <br>" +
                    "type（必填）： 类型：1-化验、3-辅检、4-诊断、5-药品、6-手术和操作、7-科室、8-输血、10-量表、11-护理、12-中医诊断、13-中医证候、14-麻醉、16-给药途径 <br>")
    @PostMapping(value = "/dataVerify", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
    public CommonResult<Boolean> dataVerify(@RequestParam("file") MultipartFile file,
                                       @RequestParam("type") Integer type) {
        Boolean data = mappingConfigFacade.dataVerify(file, type);
        return CommonResult.success(data);
    }

    @ApiOperation(value = "预匹配[by:zhaops]",
            notes = "file（必填）：预匹配文件 <br>" +
                    "type（必填）： 类型：1-化验、3-辅检、4-诊断、5-药品、6-手术和操作、7-科室、8-输血、10-量表、11-护理、12-中医诊断、13-中医证候、14-麻醉、16-给药途径 <br>")
    @PostMapping(value = "/precDataMatch", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
    public void precDataMatch(@RequestParam("file") MultipartFile file,
                              HttpServletResponse response,
                              @RequestParam("type") Integer type) {
        mappingConfigFacade.precDataMatch(file, type, response);
    }

    @ApiOperation(value = "预匹配_远程调用[by:zhaops]", notes = "")
    @PostMapping(value = "/precDataMatch_remote", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
    @ApiIgnore
    public CommonResult<List<MappingConfigWrapper>> precDataMatch_remote(@RequestParam("file") MultipartFile file,
                                                                    @RequestParam("type") Integer type) {
        List<MappingConfigWrapper> data = mappingConfigFacade.precDataMatch_remote(file, type);
        return CommonResult.success(data);
    }

    @ApiOperation(value = "预匹配（非文件匹配）[by:zhaops]",
            notes = "type（必填）： 类型：1-化验、3-辅检、4-诊断、5-药品、6-手术和操作、7-科室、8-输血、10-量表、11-护理、12-中医诊断、13-中医证候、14-麻醉、16-给药途径 <br>" +
                    "hisName（必填）：医院术语名称 <br>" +
                    "hisDetailName（选填）：医院术语名称-细项 <br>" +
                    "code（选填）：诊断ICD10编码、手术编码、中医疾病编码、中医证候编码 <br>" +
                    "approval（选填）：药品国药准字 <br>")
    @PostMapping(value = "/precData")
    public CommonResult<List<MappingConfigWrapper>> precData(@Valid @RequestBody PrecDataVO precDataVO) {
        List<MappingConfigWrapper> data = mappingConfigFacade.precData(precDataVO);
        return CommonResult.success(data);
    }

    @ApiOperation(value = "数据导入校验[by:zhaops]",
            notes = "file（必填）：导入文件 <br>" +
                    "hospitalId（必填）：医院id <br>" +
                    "uesrId（必填）：操作人id <br>" +
                    "type（必填）： 类型：1-化验、3-辅检、4-诊断、5-药品、6-手术和操作、7-科室、8-输血、10-量表、11-护理、12-中医诊断、13-中医证候、14-麻醉、16-给药途径 <br>")
    @PostMapping(value = "/importExcelDataVerify", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
    public CommonResult<Boolean> importExcelDataVerify(@RequestParam("file") MultipartFile file,
                                                  @RequestParam("hospitalId") Long hospitalId,
                                                  @RequestParam("type") Integer type,
                                                  @RequestParam("uesrId") String userId) {
        Boolean data = mappingConfigFacade.importExcelDataVerify(file, hospitalId, type, userId);
        return CommonResult.success(data);
    }

    @ApiOperation(value = "数据导入[by:zhaops]",
            notes = "file（必填）：导入文件 <br>" +
                    "hospitalId（必填）：医院id <br>" +
                    "uesrId（必填）：操作人id <br>" +
                    "type（必填）： 类型：1-化验、3-辅检、4-诊断、5-药品、6-手术和操作、7-科室、8-输血、10-量表、11-护理、12-中医诊断、13-中医证候、14-麻醉、16-给药途径 <br>")
    @PostMapping(value = "/importExcel", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
    @Transactional
    public void importExcel(HttpServletResponse response,
                            @RequestParam("file") MultipartFile file,
                            @RequestParam("hospitalId") Long hospitalId,
                            @RequestParam("type") Integer type,
                            @RequestParam("uesrId") String userId) {
        response.setHeader("Access-Control-Expose-Headers", "*");
        mappingConfigFacade.importExcel(response, file, hospitalId, type, userId);
    }

    @ApiOperation(value = "数据导入_远程调用[by:zhaops]",
            notes = "file（必填）：导入文件 <br>" +
                    "hospitalId（必填）：医院id <br>" +
                    "uesrId（必填）：操作人id <br>" +
                    "type（必填）： 类型：1-化验、3-辅检、4-诊断、5-药品、6-手术和操作、7-科室、8-输血、10-量表、11-护理、12-中医诊断、13-中医证候、14-麻醉、16-给药途径 <br>")
    @PostMapping(value = "/importExcel_remote", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
    @Transactional
    @ApiIgnore
    public CommonResult<List<MappingConfigWrapper>> importExcel_remote(HttpServletResponse response,
                                                                  @RequestParam("file") MultipartFile file,
                                                                  @RequestParam("hospitalId") Long hospitalId,
                                                                  @RequestParam("type") Integer type,
                                                                  @RequestParam("uesrId") String userId) {
        List<MappingConfigWrapper> data = mappingConfigFacade.importExcel_remote(response, file, hospitalId, type, userId);
        return CommonResult.success(data);
    }


    @ApiOperation(value = "数据导出[by:zhaops]",
            notes = "hospitalId（必填）：医院id <br>" +
                    "isMatch（选填，默认全部）：是否匹配（0-未匹配、1-已匹配、2-多条匹配） <br>" +
                    "type（必填）： 类型：1-化验、3-辅检、4-诊断、5-药品、6-手术和操作、7-科室、8-输血、10-量表、11-护理、12-中医诊断、13-中医证候、14-麻醉、16-给药途径 <br>")
    @PostMapping("/exportExcel")
    public void exportExcel(HttpServletResponse response, @RequestBody @Valid MappingConfigPageVO mappingConfigPageVO) {
        mappingConfigFacade.exportExcel(response, mappingConfigPageVO);
    }

    @ApiOperation(value = "数据导出_远程调用[by:zhaops]",
            notes = "")
    @PostMapping("/exportExcel_remote")
    @ApiIgnore
    public CommonResult<List<MappingConfigWrapper>> exportExcel_remote(@RequestBody @Valid MappingConfigPageVO mappingConfigPageVO) {
        List<MappingConfigWrapper> data = mappingConfigFacade.exportExcel_remote(mappingConfigPageVO);
        return CommonResult.success(data);
    }

    @ApiOperation(value = "分页查询[by:zhaops]",
            notes = "hospitalId（必填）：医院id <br>" +
                    "isMatch（选填，默认全部）：是否匹配（0-未匹配、1-已匹配、2-多条匹配） <br>" +
                    "hisName（必填）：医院术语名称 <br>" +
                    "uniqueName（选填，可为空）：标准术语名称 <br>" +
                    "type（必填）： 类型：1-化验、3-辅检、4-诊断、5-药品、6-手术和操作、7-科室、8-输血、10-量表、11-护理、12-中医诊断、13-中医证候、14-麻醉、16-给药途径 <br>")
    @PostMapping("/getPage")
    public CommonResult<IPage<MappingConfigWrapper>> getPage(@RequestBody @Valid MappingConfigPageVO mappingConfigPageVO) {
        IPage<MappingConfigWrapper> data = mappingConfigFacade.getPage(mappingConfigPageVO);
        Page<MappingConfigWrapper> page = new Page<>();
        BeanUtil.copyProperties(data, page);
        return CommonResult.success(data);
    }


    @ApiOperation(value = "获取映射关系[by:zhaops]",
            notes = "id：关联关系id")
    @PostMapping("/getRecord")
    @Transactional
    public CommonResult<MappingConfigWrapper> getRecord(@RequestBody @Valid IdVO idVO) {
        MappingConfigWrapper data = mappingConfigFacade.getRecord(idVO);
        return CommonResult.success(data);
    }

    @ApiOperation(value = "映射关系是否已存在[by:zhaops]",
            notes = "id：关联关系id <br>" +
                    "hospitalId（必填）：医院id <br>" +
                    "hisName（必填）：医院术语名称 <br>" +
                    "hisDetailName（选填，可为空）：医院术语名称-细项 <br>" +
                    "conceptId（必填）：标准术语id <br>" +
                    "formConceptId（选填，可为空）：药品剂型id，选填 <br>" +
                    "source（必填）：数据来源：1-标准词、2-同义词、3-编码、4-历史数据、5-相似词 <br>" +
                    "type（必填）： 类型：1-化验、3-辅检、4-诊断、5-药品、6-手术和操作、7-科室、8-输血、10-量表、11-护理、12-中医诊断、13-中医证候、14-麻醉、16-给药途径 <br>")
    @PostMapping("/isExistRecord")
    public CommonResult<Boolean> isExistRecord(@RequestBody @Valid MappingConfig mappingConfig) {
        Boolean data = mappingConfigFacade.isExistRecord(mappingConfig);
        return CommonResult.success(data);
    }

    @ApiOperation(value = "查询已映射关系[by:zhaops]",
            notes = "hospitalId（必填）：医院id <br>" +
                    "hisName（必填）：医院术语名称 <br>" +
                    "hisDetailName（选填，可为空）：医院术语名称-细项 <br>" +
                    "type（必填）： 类型：1-化验、3-辅检、4-诊断、5-药品、6-手术和操作、7-科室、8-输血、10-量表、11-护理、12-中医诊断、13-中医证候、14-麻醉、16-给药途径 <br>")
    @PostMapping("/getRelatedMapping")
    public CommonResult<List<MappingConfigWrapper>> getRelatedMapping(@RequestBody @Valid MappingConfigVO mappingConfigVO) {
        List<MappingConfigWrapper> data = mappingConfigFacade.getRelatedMapping(mappingConfigVO);
        return CommonResult.success(data);
    }


    @ApiOperation(value = "保存或修改映射关系[by:zhaops]",
            notes = "id：关联关系id <br>" +
                    "hospitalId（必填）：医院id <br>" +
                    "hisName（必填）：医院术语名称 <br>" +
                    "hisDetailName（选填，可为空）：医院术语名称-细项 <br>" +
                    "conceptId（必填）：标准术语id <br>" +
                    "formConceptId（选填，可为空）：药品剂型id，选填 <br>" +
                    "source：数据来源（必填）：1-标准词、2-同义词、3-编码、4-历史数据、5-相似词 <br>" +
                    "type（必填）： 类型：1-化验、3-辅检、4-诊断、5-药品、6-手术和操作、7-科室、8-输血、10-量表、11-护理、12-中医诊断、13-中医证候、14-麻醉、16-给药途径 <br>")
    @PostMapping("/saveOrUpdateRecord")
    public CommonResult<Boolean> saveOrUpdateRecord(@RequestBody @Valid MappingConfig mappingConfig) {
        Boolean data = mappingConfigFacade.saveOrUpdateRecord(mappingConfig);
        return CommonResult.success(data);
    }

    @ApiOperation(value = "删除映射关系[by:zhaops]",
            notes = "id：关联关系id")
    @PostMapping("/deleteRecord")
    @Transactional
    public CommonResult<Boolean> deleteRecord(@RequestBody @Valid IdVO idVO) {
        Boolean data = mappingConfigFacade.deleteRecord(idVO);
        return CommonResult.success(data);
    }

    @ApiOperation(value = "批量删除映射关系[by:zhaops]",
            notes = "ids：关联关系id列表")
    @PostMapping("/deleteRecords")
    @Transactional
    public CommonResult<Boolean> deleteRecords(@RequestBody @Valid IdListVO idListVO) {
        Boolean data = mappingConfigFacade.deleteRecords(idListVO);
        return CommonResult.success(data);
    }
}