package com.xy.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.xy.collections.list.JArrayList;
import com.xy.collections.list.JList;
import com.xy.collections.map.JMap;
import com.xy.device.EnumDeviceCharging;
import com.xy.device.EnumDeviceChargingHistoryStatus;
import com.xy.dto.DeviceChargingDto;
import com.xy.dto.DeviceInfoDto;
import com.xy.entity.DeviceCharging;
import com.xy.entity.DeviceChargingHistory;
import com.xy.entity.SysDictRedis;
import com.xy.error.CommRuntimeException;
import com.xy.mapper.DeviceChargingMapper;
import com.xy.utils.*;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.AllArgsConstructor;
import lombok.SneakyThrows;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;

import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;

import static com.xy.utils.PlusBeans.toIPage;
import static com.xy.utils.PlusBeans.toPageBean;


/**
 * <p>
 * 设备计费表 服务实现类
 * </p>
 *
 * @author lijin
 * @since 2023-04-14
 */
@Service
@Api(tags = "设备计费表")
@AllArgsConstructor(onConstructor_ = @Lazy)
public class DeviceChargingServiceImpl extends ServiceImpl<DeviceChargingMapper, DeviceCharging> implements DeviceChargingService {

    private DeviceChargingHistoryServiceImpl deviceChargingHistoryService;

    private DeviceInfoServiceImpl deviceInfoService;

    private DeviceChargingServiceImpl deviceChargingService;

    @PostMapping("check")
    @ApiOperation("检查")
    public R check(@RequestBody @Validated DeviceChargingDto.Check check) {
        LocalDateTime now = LocalDateTime.now();
        DeviceCharging deviceCharging = getById(check.getDeviceId());
        if (deviceCharging == null) {
            deviceChargingService.save(new DeviceCharging()
                    .setDeviceId(check.getDeviceId())
                    .setTimeout(now)
                    .setCreateTime(now)
            );
            throw new CommRuntimeException("设备欠费，请充值");
        }
        int contrast = DataTime.stringContrast(DataTime.toString(deviceCharging.getTimeout()), DataTime.toString(now));
        if (deviceCharging.getChargingX() == 0 && contrast <= 0) {
            throw new CommRuntimeException("设备欠费，请充值");
        }
        return R.ok();
    }

    @PostMapping("page")
    @ApiOperation("分页查询")
    public R<PageBean<DeviceChargingDto.PageVo>> page(@RequestBody DeviceChargingDto.Page page) {
        Integer value = SysDictUtils.getValue(EnumDeviceCharging.Code.CODE.getCode(), EnumDeviceCharging.N_200.getCode(), Integer.class);
        String theTime = DataTime.getStringAround(0, 0, value, 0, 0, 0);
        page.setThisTime(LocalDateTime.now()).setTheTime(DataTime.toLocal(theTime));
        IPage<DeviceChargingDto.PageVo> iPage = baseMapper.page(toIPage(page.getPage()), page);
        List<DeviceChargingDto.PageVo> records = iPage.getRecords();
        if (Emptys.check(records)) {
            Map<String, SysDictRedis> stringSysDictRedisMap = SysDictUtils.get(EnumDeviceCharging.Code.CODE.getCode());
            for (DeviceChargingDto.PageVo record : records) {
                //封装过期状态说明
                String timeoutStatus;
                DeviceChargingDto.Vo deviceCharging = record.getDeviceCharging();
                LocalDateTime timeout = deviceCharging.getTimeout();
                long s = DataTime.diff(page.getThisTime(), timeout, "s");
                if (s <= 0) {
                    timeoutStatus = "欠费(" + (~(s / 86400 - 1)) + "天)";
                } else {
                    timeoutStatus = s <= value * 86400 ? "即将到期(" + s / 86400 + "天)" : "正常(" + s / 86400 + "天)";
                }
                record.getDeviceCharging().setTimeoutStatus(timeoutStatus);
                //封装计费标准金额
                DeviceInfoDto.Vo deviceInfo = record.getDeviceInfo();
                SysDictRedis sysDictRedis = stringSysDictRedisMap.get(deviceInfo.getDeviceType().toString());
                if (sysDictRedis != null) {
                    record.setChargingMoney(Integer.valueOf(sysDictRedis.getValue()));
                }
            }
        }
        return R.ok(toPageBean(iPage));
    }

    @Override
    @ApiOperation("购买")
    public R pay(DeviceChargingDto.Pay pay) {
        JList<DeviceChargingDto.Pay.DeviceCharging> deviceChargings = new JArrayList<>(pay.getDeviceChargings());
        Integer payType = pay.getPayType();
        LocalDateTime now = LocalDateTime.now();
        JList<DeviceChargingHistory> deviceChargingHistories = new JArrayList<>();
        deviceChargings.forEach(deviceCharging -> {
            DeviceChargingHistory deviceChargingHistory = new DeviceChargingHistory()
                    .createId()
                    .setOrderId(pay.getOrderId())
                    .setDeviceId(deviceCharging.getDeviceId())
                    .setChargingSize(deviceCharging.getNum())
                    .setChargingMoney(deviceCharging.getChargingMoney())
                    .setChargingType(payType)
                    .setStandard(deviceCharging.getStandard())
                    .setCreateTime(now)
                    .setUpdateTime(now);
            deviceChargingHistories.add(deviceChargingHistory);
        });
        if (!Emptys.check(deviceChargingHistories)) {
            return R.fail();
        }
        //添加设备计费历史表
        deviceChargingHistoryService.saveBatch(deviceChargingHistories);
        return R.ok();
    }

    @Override
    @ApiOperation("购买回调")
    public R payNotice(DeviceChargingDto.PayNotice payNotice) {
        //查询设备计费历史表
        List<DeviceChargingHistory> list = deviceChargingHistoryService.list(new LambdaQueryWrapper<DeviceChargingHistory>().eq(DeviceChargingHistory::getOrderId, payNotice.getOrderId()));
        if (!Emptys.check(list)) {
            return R.ok();
        }
        JList<DeviceChargingHistory> deviceChargingHistories = new JArrayList<>(list);
        LocalDateTime now = LocalDateTime.now();
        //查询设备计费表
        List<DeviceCharging> deviceChargings = list(new LambdaQueryWrapper<DeviceCharging>().in(DeviceCharging::getDeviceId, deviceChargingHistories.getProperty(DeviceChargingHistory::getDeviceId)));
        JMap<Long, DeviceCharging> deviceChargingsJMaps = new JArrayList<>(deviceChargings).toMap(DeviceCharging::getDeviceId).cover();
        //获取已支付字典
        Integer status = SysDictUtils.getValue(EnumDeviceChargingHistoryStatus.Code.CODE.getCode(), EnumDeviceChargingHistoryStatus.N_2.getCode(), Integer.class);
        JList<DeviceCharging> updateDeviceCharging = new JArrayList<>();
        JList<DeviceInfoDto.Update> updateDeviceInfos = new JArrayList<>();
        JList<DeviceChargingHistory> updateDeviceChargingHistory = new JArrayList<>();
        for (DeviceChargingHistory deviceChargingHistory : deviceChargingHistories) {
            DeviceCharging deviceCharging = deviceChargingsJMaps.get(deviceChargingHistory.getDeviceId());
            Integer chargingSize = deviceChargingHistory.getChargingSize();
            boolean fal = false;
            //设备计费历史完成
            deviceChargingHistory.setStatus(status);
            if (deviceChargingHistory.getChargingType() == 100) {
                //赠送天数
                deviceCharging.setChargingX(deviceCharging.getChargingX() + chargingSize);
                fal = true;
            } else {
                String timeout = DataTime.getStringAround(chargingSize, 0, 0, 0, 0, 0, DataTime.toString(deviceCharging.getTimeout()));
                deviceCharging.setChargingSumMoney(deviceCharging.getChargingSumMoney() + deviceChargingHistory.getChargingMoney())
                        .setTimeout(DataTime.toLocal(timeout));
                //过期时间大于当前时间
                if (DataTime.stringContrast(timeout, DataTime.toString(now)) > 0) {
                    fal = true;
                }
            }
            if (fal) {
                //设备重新计费
                deviceCharging.setIsJob(true);
                //解冻设备
                DeviceInfoDto.Update deviceInfo = new DeviceInfoDto.Update()
                        .setDeviceId(deviceChargingHistory.getDeviceId());
                deviceInfo.setFreezeStatus(1);
                deviceInfo.setBusyState(1);
                updateDeviceInfos.add(deviceInfo);
            }
            updateDeviceCharging.add(deviceCharging);
            updateDeviceChargingHistory.add(deviceChargingHistory);
        }
        int size = 50;
        //修改设备计费记录
        if (Emptys.check(updateDeviceCharging)) {
            JList<JList<DeviceCharging>> partition = updateDeviceCharging.partition(size);
            partition.forEach(data -> updateBatchById(data));
        }
        //修改设备计费历史记录
        if (Emptys.check(updateDeviceChargingHistory)) {
            JList<JList<DeviceChargingHistory>> partition = updateDeviceChargingHistory.partition(size);
            partition.forEach(data -> deviceChargingHistoryService.updateBatchById(data));
        }
        //修改设备
        if (Emptys.check(updateDeviceInfos)) {
            JList<JList<DeviceInfoDto.Update>> partition = updateDeviceInfos.partition(size);
            partition.forEach(data -> deviceInfoService.updateBatch(data));
        }
        return R.ok();
    }
}