package com.lyms.talkonlineweb.controller;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.lyms.talkonlineweb.domain.LymsDict;
import com.lyms.talkonlineweb.domain.LymsHdepart;
import com.lyms.talkonlineweb.domain.LymsUser;
import com.lyms.talkonlineweb.domain.Regions;
import com.lyms.talkonlineweb.result.BaseResponse;
import com.lyms.talkonlineweb.service.LymsDictService;
import com.lyms.talkonlineweb.service.RegionsService;
import com.lyms.talkonlineweb.util.StringUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 获取区域
 */
@RestController
public class RegionsController {

    @Autowired
    private RegionsService regionsService;

    @Autowired
    private LymsDictService lymsDictService;

    @GetMapping("getRegions")
    public BaseResponse getRegions(Regions regions){
        BaseResponse baseResponse=new BaseResponse();
        List<Regions> regionsList=regionsService.list(Wrappers.query(regions));
        baseResponse.setObject(regionsList);
        return baseResponse;
    }

    /**
     * 获取字典数据
     * @param dict
     * @return
     */
    @GetMapping("getDict")
    public BaseResponse getDict(LymsDict dict){
        BaseResponse baseResponse=new BaseResponse();
        List<LymsDict> dictList=lymsDictService.list(Wrappers.query(dict));
        baseResponse.setObject(dictList);
        return baseResponse;
    }

    /**
     * 添加或修改字典数据
     * @param dict
     * @return
     */
    @PostMapping("saveDict")
    public BaseResponse saveDict(@RequestBody LymsDict dict){
        BaseResponse baseResponse=new BaseResponse();
        boolean f=lymsDictService.saveOrUpdate(dict);
        baseResponse.setErrorcode(f==true?0:1);
        return baseResponse;
    }

    /**
     * 删除字典数据
     * @param did
     * @return
     */
    @GetMapping("delDict")
    public BaseResponse saveDict(int did){
        BaseResponse baseResponse=new BaseResponse();
        boolean f=lymsDictService.removeById(did);
        baseResponse.setErrorcode(f==true?0:1);
        return baseResponse;
    }

    /**
     * 字典列表展示
     * @param dict
     * @param current
     * @param size
     * @return
     */
    @GetMapping("sltDict")
    public BaseResponse sltDepartLst(LymsDict dict, int current, int size){
        BaseResponse baseResponse=new BaseResponse();
        Page<LymsDict> page=new Page<>(current,size);
        QueryWrapper query=new QueryWrapper();
        query.orderByDesc("sort");
        if(null!=dict.getVtype()){
            query.eq("vtype", dict.getVtype());
        }
        if(StringUtil.isNotEmpty(dict.getValue())){
            query.like("value", dict.getValue());
        }
        if(null!=dict.getCode()){
            query.eq("code", dict.getCode());
        }
        Page<LymsDict> departPage=lymsDictService.page(page,query);
        baseResponse.setObject(departPage);

        return baseResponse;
    }

    /**
     * PC-查询同vtype类型，字典编码是否重复
     * @param  vtype 所属类型
     * @param  code 编码
     * @param  value 取值
     * @param  id 修改时用
     * @return true 可以使用，false已经存在
     */
    @GetMapping("getDictByParam")
    public BaseResponse getDictByParam(Integer vtype, Integer code,String value, @RequestParam(required = false) Integer id){
        BaseResponse baseResponse=new BaseResponse();
        try {
            Map<String, Boolean> map= new HashMap<>();
            map.put("code", true);map.put("value", true);
            QueryWrapper<LymsDict> queryWrapper=new QueryWrapper<>();
            queryWrapper.eq("vtype", vtype);
            queryWrapper.eq("code", code).or().eq("value",value );
            if(null!=id){//修改的时候判断是否重复
                QueryWrapper<LymsDict> queryWrapper2=new QueryWrapper<>();
                queryWrapper2.eq("id", id);
                LymsDict dict2=lymsDictService.getOne(queryWrapper2);
                List<LymsDict> dictlist=lymsDictService.list(queryWrapper);
                if(CollectionUtils.isNotEmpty(dictlist)){
                    if(null!=code && !dict2.getCode().equals(code)){
                        for (LymsDict dict : dictlist) {
                            if(dict.getCode().equals(code)){
                                map.put("code", false);
                            }
                        }
                    }
                    if(StringUtil.isNotEmpty(value) && !dict2.getValue().equals(value)){
                        for (LymsDict dict : dictlist) {
                            if(dict.getValue().equals(value)){
                                map.put("value", false);
                            }
                        }
                    }
                }
                baseResponse.setObject(map);
            }else {
                LymsDict dict=lymsDictService.getOne(queryWrapper);
                if(null!=code && dict.getCode().equals(code)){
                    map.put("code", false);
                }
                if(StringUtil.isNotEmpty(value) && value.equals(dict.getValue())){
                    map.put("value", false);
                }
                baseResponse.setObject(map);
            }
            baseResponse.setErrormsg("成功");
        } catch (Exception e) {
            baseResponse.setErrormsg("失败");
            e.printStackTrace();
        }
        return baseResponse;
    }

}