package cn.besteam.modules.system.controller;

import cn.besteam.common.api.vo.Result;
import cn.besteam.common.aspect.annotation.AutoLog;
import cn.besteam.common.aspect.annotation.LogApi;
import cn.besteam.common.dto.IdDTO;
import cn.besteam.modules.system.biz.SysDictBiz;
import cn.besteam.modules.system.vo.SysDictVO;
import cn.besteam.modules.system.dto.SysDictSaveDTO;
import cn.besteam.modules.system.entity.SysDict;
import cn.besteam.modules.system.entity.SysDictItem;
import cn.besteam.modules.system.service.ISysDictItemService;
import cn.besteam.modules.system.service.ISysDictService;
import cn.besteam.modules.system.vo.BatchReqVO;
import cn.besteam.modules.system.vo.SysDictItemVO;
import cn.besteam.modules.system.vo.SysDictSelectVO;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.google.common.collect.Lists;
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.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * @Title: Controller
 * @Description: 字典定义
 * @author： besteam
 * @date： 2020-04-17
 * @version： V1.0
 */
@RestController
@RequestMapping("/system/sysDict")
@Slf4j
@Api(description = "字典定义")
public class SysDictController {

    @Autowired
    private SysDictBiz sysDictBiz;

    @Autowired
    private ISysDictService sysDictService;

    @Autowired
    private ISysDictItemService sysDictItemService;

    /**
     * 获取字典定义数据列表
     *
     * @return
     */
    @GetMapping(value = "/list")
    @ApiOperation(value = "获取字典定义数据列表", notes = "获取字典定义数据列表", produces = "application/json")
    public Result<List<SysDictVO>> list(@RequestParam(name = "keyword", required = false) String keyword) {

        return Result.ok(sysDictBiz.queryList(keyword));
    }

    /**
     * 新增
     *
     * @param dto
     * @return
     */
    @PostMapping(value = "/add")
    @AutoLog(value = "新增字典定义")
    @ApiOperation(value = "新增字典定义", notes = "新增字典定义", produces = "application/json")
    public Result<?> add(@Validated @RequestBody SysDictSaveDTO dto) {

        sysDictBiz.add(dto);
        return Result.ok("新增成功！");
    }

    /**
     * 编辑
     *
     * @param dto
     * @return
     */
    @PostMapping(value = "/edit")
    @AutoLog(value = "编辑字典定义")
    @ApiOperation(value = "编辑字典定义", notes = "编辑字典定义", produces = "application/json")
    public Result<?> edit(@Validated @RequestBody SysDictSaveDTO dto) {

        sysDictBiz.edit(dto);
        return Result.ok("编辑成功！");
    }

    /**
     * 通过id查询
     *
     * @param id
     * @return
     */
    @GetMapping(value = "/detailsById")
    @ApiOperation(value = "通过id查询字典详情", notes = "通过id查询字典详情", produces = "application/json")
    public Result<?> detailsById(@RequestParam(name = "id", required = true) Integer id) {

        return Result.ok(sysDictBiz.detailsById(id));
    }

    private static Map<Integer, List<String>> wasteTypeListMap = new LinkedHashMap<>();
    static {
        wasteTypeListMap.put(1, Lists.newArrayList("感染性", "损伤性", "药物性", "病理性", "化学性"));
        wasteTypeListMap.put(2, Lists.newArrayList("可回收输液瓶", "可回收输液袋"));
        wasteTypeListMap.put(3, Lists.newArrayList("病理性废液", "其他危险废物"));
    }
    /**
     * 获取医废类型列表
     *
     * @return
     */
    @GetMapping("/getWasteTypeList")
    @ApiOperation(value = "获取医废类型列表")
    @LogApi(value = "获取医废类型列表")
    public Result<List<SysDictItemVO>> getMedicalWasteTypeList(@ApiParam(name = "type",value = "医废类型分组 1：医疗废物，2：可回收输液瓶袋，3：危险废物") @RequestParam(name = "type", required = false) Integer type) {
        SysDict sysDict = sysDictService.getOne(new QueryWrapper<SysDict>().lambda().eq(SysDict::getDictCode, "MEDICAL_WASTE_TYPE"));
        if (sysDict == null) {
            return Result.ok(new ArrayList<SysDictItemVO>());
        }
        System.err.println(wasteTypeListMap.get(1));
        List<SysDictItem> sysDictItemList = sysDictItemService.list(new QueryWrapper<SysDictItem>().lambda()
                .eq(SysDictItem::getDictId, sysDict.getId())
                .eq(SysDictItem::getStatus, 1)
                .in(Objects.nonNull(type), SysDictItem::getItemText, wasteTypeListMap.getOrDefault(type, Collections.emptyList()))
                .orderByAsc(SysDictItem::getSortOrder));
        List<SysDictItemVO> resultList = sysDictItemList.stream().map(sysDictItem -> {
            SysDictItemVO vo = new SysDictItemVO();
            BeanUtils.copyProperties(sysDictItem, vo);
            return vo;
        }).collect(Collectors.toList());
        return Result.ok(resultList);
    }

    /**
     * 获取单位分级列表
     *
     * @return
     */
    @GetMapping(value = "/getDepartmentTypeList")
    @AutoLog(value = "获取单位分级列表")
    @ApiOperation(value = "获取单位分级列表", notes = "获取单位分级列表", produces = "application/json")
    public Result<List<SysDictItemVO>> getDepartmentTypeList() {

        SysDict sysDict = sysDictService.getOne(new QueryWrapper<SysDict>().lambda().eq(SysDict::getDictCode, "DEPARTMENT_LEVEL"));
        if (sysDict == null) {
            return Result.ok(new ArrayList<SysDictItemVO>());
        }
        return Result.ok(sysDictBiz.getSysDictListByDict(sysDict.getId()));
    }

    /**
     * 通过id删除
     *
     * @param dto
     * @return
     */
    @PostMapping(value = "/delete")
    @AutoLog(value = "删除数据字典")
    @ApiOperation(value = "删除数据字典", notes = "删除数据字典", produces = "application/json")
    public Result<SysDictItem> delete(@Validated @RequestBody IdDTO dto) {

        Result<SysDictItem> result = new Result<SysDictItem>();
        SysDictItem sysDictItem = sysDictItemService.getById(dto.getId());
        if (sysDictItem == null) {
            result.error500("未找到对应实体");
        } else {
            boolean ok = sysDictItemService.removeById(dto.getId());
            if (ok) {
                result.success("已删除!");
            }
        }
        return result;
    }

    /**
     * 批量删除
     *
     * @param vo
     * @return
     */
    @PostMapping(value = "/deleteBatch")
    @AutoLog(value = "批量删除数据字典")
    @ApiOperation(value = "批量删除数据字典", notes = "批量删除数据字典", produces = "application/json")
    public Result<SysDictItem> deleteBatch(@Validated @RequestBody BatchReqVO vo) {

        Result<SysDictItem> result = new Result<SysDictItem>();
        if (vo.getIds() == null || "".equals(vo.getIds().trim())) {
            result.error500("参数不识别！");
        } else {
            sysDictItemService.removeByIds(Arrays.asList(vo.getIds().split(",")));
            result.success("已删除!");
        }
        return result;
    }

    /**
     * 获取字典定义类型列表
     *
     * @return
     */
    @GetMapping(value = "/listDictType")
    @ApiOperation(value = "获取字典定义类型列表", notes = "获取字典定义类型列表", produces = "application/json")
    public Result<List<SysDictSelectVO>> listDictType() {

        List<SysDict> list = sysDictService.list();
        List<SysDictSelectVO> voList = new ArrayList<>();
        for (SysDict sysDict : list) {
            SysDictSelectVO vo = new SysDictSelectVO();
            BeanUtils.copyProperties(sysDict, vo);
            voList.add(vo);
        }
        return Result.ok(voList);
    }



    @GetMapping(value = "/getServiceUnitsList")
    @AutoLog(value = "获取服务单位列表")
    @ApiOperation(value = "获取服务单位列表", notes = "获取服务单位列表", produces = "application/json")
    public Result<List<SysDictItemVO>> getServiceUnitsList() {

        SysDict sysDict = sysDictService.getOne(new QueryWrapper<SysDict>().lambda().eq(SysDict::getDictCode, "SERVICE_UNITS"));
        if (sysDict == null) {
            return Result.ok(new ArrayList<SysDictItemVO>());
        }
        return Result.ok(sysDictBiz.getSysDictListByDict(sysDict.getId()));
    }
}