package com.zd.airbottle.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.zd.airbottle.domain.DbBeacon;
import com.zd.airbottle.domain.DbInOutRecord;
import com.zd.airbottle.domain.DbStock;
import com.zd.airbottle.domain.DbUsageRecord;
import com.zd.airbottle.domain.bo.DbStockBo;
import com.zd.airbottle.domain.bo.DbStockParam;
import com.zd.airbottle.domain.vo.DbStockVo;
import com.zd.airbottle.service.DbBeaconService;
import com.zd.airbottle.service.DbInOutRecordService;
import com.zd.airbottle.service.DbStockService;
import com.zd.airbottle.service.DbUsageRecordService;
import com.zd.airbottle.utils.PageUtil;
import com.zd.common.core.annotation.Log;
import com.zd.common.core.log.BusinessType;
import com.zd.common.core.redis.RedisService;
import com.zd.common.core.security.TokenService;
import com.zd.common.core.utils.StringUtils;
import com.zd.common.core.web.controller.AbstractController;
import com.zd.laboratory.api.dto.CheckSubjectDto;
import com.zd.laboratory.api.feign.RemoteLaboratoryService;
import com.zd.model.constant.BaseConstants;
import com.zd.model.constant.HttpStatus;
import com.zd.model.domain.ResultData;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.time.LocalDateTime;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

/**
 * @Description 东北大学库存
 * @Author hzw
 * @Date 2023/10/16 17:50
 * @Version 2.0
 */
@Api(tags = "东北大学库存")
@RestController
@RequestMapping("/stock")
public class DbStockController extends AbstractController {
    @Autowired
    private DbStockService dbStockService;
    @Autowired
    private DbBeaconService dbBeaconService;
    @Autowired
    private DbInOutRecordService dbInOutRecordService;

    @Autowired
    private DbUsageRecordService dbUsageRecordService;
    @Autowired
    private RemoteLaboratoryService remoteLaboratoryService;

    @Autowired
    private TokenService tokenService;

    @Autowired
    private static RedisService redisService;

    /**
     * 库存入库
     *
     * @param dbStockBo
     * @return
     */
    @ApiOperation(value = "库存入库", notes = "参数说明：gasName 气体名称，level 级别，size 规格，gasComposition 气体成分,bottleColour 气瓶颜色,handwheel 手轮（0否 1是）,fixed 固定（0否 1是）,statusLabel 状态标牌（0否 1是），electronicTag 电子标签（0否 1是）,gasPressure 气体压力,validPeriod 有效期限,beaconTag 信标标签,subjectId 实验室id,subjectName 实验室名称,remark 备注 ")
    @PostMapping(value = "/enter")
    public ResultData in(@RequestBody DbStockBo dbStockBo) {
        //参数检查
        paramCheck.notNull(dbStockBo).strNotEmpty(dbStockBo.getGasName()).notNull(dbStockBo.getBeaconTag()).notNull(dbStockBo.getSubjectId());
        //验证信标
        long count1 = dbStockService.count(new LambdaQueryWrapper<DbStock>().eq(DbStock::getBeaconTag, dbStockBo.getBeaconTag()));
        if (count1 > 0) {
            return ResultData.success("当前信标已绑定！");
        }
        //查询实验室所在学院
        ResultData<List<CheckSubjectDto>> resultData = remoteLaboratoryService.findSubjectInfoList(String.valueOf(dbStockBo.getSubjectId()));
        if (resultData != null && HttpStatus.SUCCESS == resultData.getCode()) {
            List<CheckSubjectDto> data = resultData.getData();
            dbStockBo.setCollegeId(data.get(0).getDeptId());
            dbStockBo.setCollegeName(data.get(0).getCollegeName());
            dbStockBo.setRoomNum(data.get(0).getRoomNumber());
        }
        DbStock dbStock = new DbStock();
        BeanUtils.copyProperties(dbStockBo, dbStock);
        dbStock.setCreateBy(getCurrentUserId());
        dbStock.setCreateName(getCurrentUserName());
        if (dbStockService.save(dbStock)) {
            DbInOutRecord dbInOutRecord = new DbInOutRecord();
            BeanUtils.copyProperties(dbStockBo, dbInOutRecord);
            dbInOutRecord.setType(1);
            dbInOutRecord.setPhone(tokenService.getLoginUser().getSysUser().getPhonenumber());
            dbInOutRecordService.save(dbInOutRecord);
            dbBeaconService.update(new LambdaUpdateWrapper<DbBeacon>().eq(DbBeacon::getBeaconTag, dbInOutRecord.getBeaconTag()).set(DbBeacon::getState, Boolean.TRUE).set(DbBeacon::getBindingTime, LocalDateTime.now()));
            //todo 重新加载入库的信标到redis  chai
            new Thread(()->loadBeaconDate(dbStock)).start();
            return ResultData.success("操作成功");
        }
        return ResultData.fail("操作失败");
    }

    /**
     * 库存出库
     *
     * @param dbStockBo
     * @return
     */
    @ApiOperation(value = "库存出库", notes = "参数说明：id 必填 ")
    @PostMapping(value = "/out")
    public ResultData out(@RequestBody DbStockBo dbStockBo) {
        //参数检查
        paramCheck.notNull(dbStockBo).notNull(dbStockBo.getId());
        DbStock stock = dbStockService.getById(dbStockBo.getId());
        if (dbStockService.removeById(stock.getId())) {
            DbInOutRecord dbInOutRecord = new DbInOutRecord();
            BeanUtils.copyProperties(stock, dbInOutRecord);
            dbInOutRecord.setType(2);
            dbInOutRecordService.save(dbInOutRecord);
            dbBeaconService.update(new LambdaUpdateWrapper<DbBeacon>().eq(DbBeacon::getBeaconTag, dbInOutRecord.getBeaconTag()).set(DbBeacon::getState, 0));
            //todo 重新加载入库的信标到redis  chai
            new Thread(()->remBeaconDate(stock)).start();
            return ResultData.success("出库成功");
        }
        return ResultData.fail("出库失败");
    }



    /**
     * 更新库存信息
     *
     * @Param [dbStockBo]
     * @Return com.zd.model.domain.ResultData
     **/
    @ApiOperation(value = "更新库存信息", notes = "参数说明：id 必填，gasName 气体名称，level 级别，size 规格，gasComposition 气体成分,bottleColour 气瓶颜色,handwheel 手轮（0否 1是）,fixed 固定（0否 1是）,statusLabel 状态标牌（0否 1是），electronicTag 电子标签（0否 1是）,gasPressure 气体压力,validPeriod 有效期限,beaconTag 信标标签,subjectId 实验室id,subjectName 实验室名称,remark 备注 ")
    @Log(title = "更新库存信息", businessType = BusinessType.UPDATE)
    @PostMapping(value = "/update")
    public ResultData update(@RequestBody DbStockBo dbStockBo) {
        //参数检查
        paramCheck.notNull(dbStockBo).notNull(dbStockBo.getId()).notNull(dbStockBo.getBeaconTag());
        long count = dbStockService.count(new LambdaQueryWrapper<DbStock>().ne(DbStock::getBeaconTag, dbStockBo.getBeaconTag()).eq(DbStock::getBeaconTag, dbStockBo.getBeaconTag()));
        if (count > 0) {
            return ResultData.success("信标标签已存在！");
        }
        //将旧的信标从redis中移除 chai
        DbStock oldDbStock = dbStockService.getById(dbStockBo.getId());
        if (dbStockService.update(new LambdaUpdateWrapper<DbStock>().eq(DbStock::getId, dbStockBo.getId()).set(DbStock::getBeaconTag, dbStockBo.getBeaconTag()))) {
            redisService.deleteObject(BaseConstants.BEACON_MATE_DET+"~"+ oldDbStock.getBeaconTag()+"~"+oldDbStock.getSubjectId()+"~"+oldDbStock.getGasName());
            //先把对应的信标提示语撤销
            List <Map<String,Object>> beaconNoticeList = redisService.getCacheObject(BaseConstants.BEACON_MATE_NOTICE+"~"+oldDbStock.getSubjectId());
            List <Map<String,Object>> newNoticeList = new ArrayList <>();
            if(beaconNoticeList!=null){
                newNoticeList.addAll(beaconNoticeList);
            }
            //todo 循环信标通知，修改的信标提示语移除。
            if(beaconNoticeList != null){
                for(Map notice:beaconNoticeList){
                    if(notice.get("beaconTag").equals(oldDbStock.getBeaconTag())){
                        log.info("=====================================》移除返回来的信标提示语："+notice);
                        newNoticeList.remove(notice);
                    }
                }
            }
            //下发通知，告诉前端页面，查询redis获取相关信息
            if(beaconNoticeList!=null && beaconNoticeList.size()!=newNoticeList.size()){
                //判断通知消息集合有数据，说明信标有变动，需要重新变更加通知
                redisService.setCacheObject(BaseConstants.BEACON_MATE_NOTICE+"~"+ oldDbStock.getSubjectId(),newNoticeList, 30L, TimeUnit.MINUTES);
            }
            //todo 重新加载入库的信标到redis  chai
            DbStock newDbStock = dbStockService.getById(dbStockBo.getId());
            new Thread(()->loadBeaconDate(newDbStock)).start();
            return ResultData.success("操作成功");
        }
        return ResultData.fail("操作失败");
    }

    /**
     * 通过ID获取库存详情
     *
     * @param id
     * @return
     */
    @ApiOperation(value = "通过ID获取库存详情", notes = "参数说明：库存id 必填")
    @GetMapping(value = "/findById")
    public ResultData find(@RequestParam("id") Long id) {
        paramCheck.notNull(id);
        DbStock dbStock = dbStockService.getById(id);
        DbUsageRecord dbUsageRecord = dbUsageRecordService.getOne(new LambdaQueryWrapper<DbUsageRecord>().eq(DbUsageRecord::getStcokId, dbStock.getId()).orderByDesc(DbUsageRecord::getId).last("limit 1"));
        DbStockVo dbStockVo = new DbStockVo();
        BeanUtils.copyProperties(dbStock,dbStockVo);
        dbStockVo.setUser(dbUsageRecord.getCreateName());
        dbStockVo.setLastUseTime(dbUsageRecord.getCreateTime());
        return ResultData.success(dbStock);
    }

    /**
     * 获取库存list
     *
     * @param dbStockParam
     * @return
     */
    @ApiOperation(value = "获取库存list", notes = "参数说明：searchValue 关键字,collegeId 学院id，startTime 开始时间，endTime 结束时间")
    @PostMapping(value = "/list")
    public ResultData list(@RequestBody DbStockParam dbStockParam) {
        //查询条件
        LambdaQueryWrapper<DbStock> queryWrapper = new LambdaQueryWrapper<>();
        //气瓶编号 气瓶名称 实验室名称
        if (StringUtils.isNotBlank(dbStockParam.getSearchValue())) {
            queryWrapper.like(DbStock::getGasName, dbStockParam.getSearchValue()).or().like(DbStock::getSubjectName, dbStockParam.getSearchValue());
        }
        if (Objects.nonNull(dbStockParam.getCollegeId())) {
            queryWrapper.eq(DbStock::getCollegeId, dbStockParam.getCollegeId());
        }
        if (Objects.nonNull(dbStockParam.getStartTime()) && Objects.nonNull(dbStockParam.getEndTime())) {
            queryWrapper.between(DbStock::getCreateTime, dbStockParam.getStartTime(), dbStockParam.getEndTime());
        }
        //倒叙
        queryWrapper.orderByDesc(DbStock::getId);
        IPage<DbStock> result = dbStockService.page(PageUtil.getQuery(dbStockParam.getPageNum(), dbStockParam.getPageSize()), queryWrapper);
        return ResultData.success(result);
    }

    /**
     * 通过信标查询库信息
     *
     * @param BeaconTag
     * @return
     */
    @ApiOperation(value = "通过信标查询库信息", notes = "参数说明：subId 必填")
    @GetMapping(value = "/findByBeaconTag")
    public ResultData findByBancon(@RequestParam("BeaconTag") String BeaconTag) {
        paramCheck.strNotEmpty(BeaconTag);
        LambdaQueryWrapper<DbStock> queryWrapper = new LambdaQueryWrapper();
        queryWrapper.eq(DbStock::getBeaconTag, BeaconTag);
        DbStock dbStock = dbStockService.getOne(queryWrapper);
        return ResultData.success(dbStock);
    }

    /**
     * 通过subId查询库存分类
     *
     * @param subId
     * @return
     */
    @ApiOperation(value = "通过subId查询库存分类", notes = "参数说明：subId 必填")
    @GetMapping(value = "/findClassifyBySubId")
    public ResultData findClassifyBySubId(@RequestParam("subId") Long subId) {
        paramCheck.notNull(subId);
        LambdaQueryWrapper<DbStock> queryWrapper = new LambdaQueryWrapper();
        queryWrapper.eq(DbStock::getSubjectId, subId);
        List<DbStock> list = dbStockService.list(queryWrapper);
        Map <String,List<DbStock>> dbStockMap = Optional.ofNullable(list).orElseGet(Collections::emptyList).stream()
                .collect(Collectors.groupingBy(DbStock::getGasName));
        Map<String,Object> allMap = new HashMap <>();
        allMap.put("total",list.size());
        List<Map<String,Object>> classifyList = new ArrayList <>();
        dbStockMap.forEach((key,value)->{
            Map<String,Object> classifyMap = new HashMap <>();
            classifyMap.put("name",key);
            classifyMap.put("bottleSize",value.size());
            classifyList.add(classifyMap);
        });
        allMap.put("classifyList",classifyList);
        return ResultData.success(allMap);
    }

    /**
     * 通过subId查询库存列表
     *
     * @param subId
     * @return
     */
    @ApiOperation(value = "通过subId查询库存列表", notes = "参数说明：subId 必填")
    @GetMapping(value = "/findBySubId")
    public ResultData findBySubId(@RequestParam("subId") Long subId) {
        paramCheck.notNull(subId);
        LambdaQueryWrapper<DbStock> queryWrapper = new LambdaQueryWrapper();
        queryWrapper.eq(DbStock::getSubjectId, subId);
        List<DbStock> list = dbStockService.list(queryWrapper);
        return ResultData.success(list);
    }


    /**
     * 每次入库，修改，需要重新加载对应的实验室信标列表和对应的信标
     *
     * @param dbStock
     * @return
     */
    public void loadBeaconDate(DbStock dbStock){
        //查询库存信标列表，存入redis
        LambdaQueryWrapper<DbStock> queryWrapper = new LambdaQueryWrapper();
        queryWrapper.eq(DbStock::getSubjectId, dbStock.getSubjectId());
        List<DbStock> list = dbStockService.list(queryWrapper);
        redisService.setCacheObject(BaseConstants.BEACON_MATE_INFO+"~"+ dbStock.getSubjectId(),list, 7L, TimeUnit.DAYS);
        //将提交的库存数据，存入redis
        redisService.setCacheObject(BaseConstants.BEACON_MATE_DET+"~"+ dbStock.getBeaconTag()+"~"+dbStock.getSubjectId()+"~"+dbStock.getGasName(),dbStock.getBeaconTag(), 120L, TimeUnit.SECONDS);
    }

    /**
     * 每次出库需要重新加载对应的实验室信标列表和移除对应信标
     *
     * @param dbStock
     * @return
     */
    public void remBeaconDate(DbStock dbStock){
        //查询库存信标列表，存入redis
        LambdaQueryWrapper<DbStock> queryWrapper = new LambdaQueryWrapper();
        queryWrapper.eq(DbStock::getSubjectId, dbStock.getSubjectId());
        List<DbStock> list = dbStockService.list(queryWrapper);
        redisService.setCacheObject(BaseConstants.BEACON_MATE_INFO+"~"+ dbStock.getSubjectId(),list, 7L, TimeUnit.DAYS);
        //将信标从redis中移除
        redisService.deleteObject(BaseConstants.BEACON_MATE_DET+"~"+ dbStock.getBeaconTag()+"~"+dbStock.getSubjectId()+"~"+dbStock.getGasName());
    }

    /**
     * 根据实验室ids查询库存列表
     */
    @ApiOperation(value = "根据实验室ids查询库存列表")
    @GetMapping("/{ids}")
    public ResultData getStockBySubIds(@PathVariable Long[] ids)
    {
        //查询库存信标列表，存入redis
        LambdaQueryWrapper<DbStock> queryWrapper = new LambdaQueryWrapper();
        queryWrapper.in(DbStock::getSubjectId, ids);
        List<DbStock> list = dbStockService.list(queryWrapper);
        return ResultData.success(list);
    }

    /***
     *
     * @param
     * @return
     */
    @ApiOperation(value = "查询气体按名称分组")
    @GetMapping(value = "/groupBottleName")
    public ResultData findBySubId(DbStockBo bo) {
        return ResultData.success(dbStockService.selectStockListGroupBy(bo));
    }

}