package com.xy.service;

import cn.hutool.json.JSONUtil;
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.*;
import com.xy.dto.DeviceAlgorithmChargingDto;
import com.xy.dto.DeviceChargingDto;
import com.xy.dto.DeviceInfoDto;
import com.xy.entity.DeviceCharging;
import com.xy.entity.DeviceChargingHistory;
import com.xy.entity.DeviceTypeAlgorithmBeforConfig;
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.extern.slf4j.Slf4j;
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.math.BigDecimal;
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
 */
@Slf4j
@Service
@Api(tags = "设备计费表")
@AllArgsConstructor(onConstructor_ = @Lazy)
public class DeviceChargingServiceImpl extends ServiceImpl<DeviceChargingMapper, DeviceCharging> implements DeviceChargingService {

    private DeviceChargingHistoryServiceImpl deviceChargingHistoryService;

    private DeviceInfoServiceImpl deviceInfoService;

    private DeviceChargingServiceImpl deviceChargingService;

    private DeviceTypeAlgorithmBeforConfigServiceImpl deviceTypeAlgorithmBeforConfigService;

    @PostMapping("payCheck")
    @ApiOperation("购买反显")
    public R<DeviceChargingDto.PayCheckVo> payCheck(@RequestBody @Validated DeviceChargingDto.PayCheck payCheck) {
        DeviceInfoDto.Vo deviceInfo = deviceInfoService.obj(new DeviceInfoDto.Obj().setDeviceId(payCheck.getDeviceId()).setIsStatus(true)).getData();
        if (deviceInfo == null) {
            return R.fail("设备不存在");
        }
        //封装设备信息
        DeviceChargingDto.PayCheckVo payCheckVo = new DeviceChargingDto.PayCheckVo();
        String deviceTypeName = SysDictUtils.get(EnumDeviceType.Code.CODE.getCode(), String.valueOf(deviceInfo.getDeviceType())).getMsg();
        Integer standard = SysDictUtils.getValue(EnumDeviceCharging.Code.CODE.getCode(), String.valueOf(deviceInfo.getDeviceType()), Integer.class);
        DeviceChargingDto.PayCheckVo.DeviceInfo deviceInfoObj = Beans.copy(Beans.copy(DeviceChargingDto.PayCheckVo.DeviceInfo.class, deviceInfo), deviceInfo.getDeviceStatus())
                .setDeviceTypeName(deviceTypeName)
                .setStandard(BigDecimal.valueOf(standard).divide(BigDecimal.valueOf(100), 2, BigDecimal.ROUND_DOWN).doubleValue() + "元/年")
                .setMoney(standard);
        //封装算法购买信息
        DeviceTypeAlgorithmBeforConfig deviceTypeAlgorithmBeforConfig = deviceTypeAlgorithmBeforConfigService.getOne(new LambdaQueryWrapper<DeviceTypeAlgorithmBeforConfig>()
                .eq(DeviceTypeAlgorithmBeforConfig::getDeviceType, deviceInfo.getDeviceType())
                .eq(DeviceTypeAlgorithmBeforConfig::getMercId, deviceInfo.getMercId())
                .eq(DeviceTypeAlgorithmBeforConfig::getAlgorithmId, deviceInfo.getAlgorithmId())
        );
        SysDictRedis moonAlgorithmTypes = SysDictUtils.get(EnumAlgorithmTypes.Code.CODE.getCode(), String.valueOf(deviceInfo.getAlgorithmId()));
        String algorithmPayConfig = SysDictUtils.getValue(EnumAlgorithmPayConfig.Code.CODE.getCode(), String.valueOf(deviceInfo.getAlgorithmId()), String.class);
        DeviceAlgorithmChargingDto.AlgorithmMoonConfig algorithmMoonConfig = JSONUtil.parseObj(algorithmPayConfig).toBean(DeviceAlgorithmChargingDto.AlgorithmMoonConfig.class);
        DeviceAlgorithmChargingDto.AlgorithmMoonConfig.Inf inf = algorithmMoonConfig.getInf();
        DeviceChargingDto.PayCheckVo.DeviceAlgorithmCharging infDeviceAlgorithmCharging = Beans.copy(DeviceChargingDto.PayCheckVo.DeviceAlgorithmCharging.class, deviceInfo)
                .setDeviceTypeName(deviceTypeName)
                .setAlgorithmId(deviceInfo.getAlgorithmId())
                .setAlgorithmName(moonAlgorithmTypes.getMsg())
                .setStandard(BigDecimal.valueOf(algorithmMoonConfig.getPrice()).divide(BigDecimal.valueOf(100), 2, BigDecimal.ROUND_DOWN).doubleValue() + "元/每笔(" + inf.getSize() + "笔)")
                .setMoney(deviceTypeAlgorithmBeforConfig == null ? inf.getMoney() : deviceTypeAlgorithmBeforConfig.getMoney());
        //封装算法包月信息
        DeviceAlgorithmChargingDto.AlgorithmMoonConfig.Moon moon = algorithmMoonConfig.getMoon();
        DeviceChargingDto.PayCheckVo.DeviceAlgorithmCharging moonDeviceAlgorithmCharging = Beans.copy(DeviceChargingDto.PayCheckVo.DeviceAlgorithmCharging.class, deviceInfo)
                .setDeviceTypeName(deviceTypeName)
                .setAlgorithmId(deviceInfo.getAlgorithmId())
                .setAlgorithmName(moonAlgorithmTypes.getMsg())
                .setStandard(BigDecimal.valueOf(algorithmMoonConfig.getPrice()).divide(BigDecimal.valueOf(100), 2, BigDecimal.ROUND_DOWN).doubleValue() + "元/包月(" + moon.getSize() + "笔)")
                .setMoney(moon.getMoney());
        payCheckVo.setDeviceInfo(deviceInfoObj).setInfDeviceAlgorithmCharging(infDeviceAlgorithmCharging).setMoonDeviceAlgorithmCharging(moonDeviceAlgorithmCharging);
        return R.ok(payCheckVo);
    }

    @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(R.Enum.CHARGING.getCode(), R.Enum.CHARGING.getMsg());
        }
        int contrast = DataTime.stringContrast(DataTime.toString(deviceCharging.getTimeout()), DataTime.toString(now));
        if (deviceCharging.getChargingX() == 0 && contrast <= 0) {
            throw new CommRuntimeException(R.Enum.CHARGING.getCode(), R.Enum.CHARGING.getMsg());
        }
        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())
                    .setLastChargingPayType(deviceChargingHistory.getChargingType())
                    .setLastChargingMoney(deviceChargingHistory.getChargingMoney())
                    .setLastChargingTime(now);
            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);
                //激活设备
                if (deviceChargingHistory.getChargingType() != 100) {
                    if (deviceInfo.getActiveState() == 2) {
                        deviceInfo.setActiveState(1);
                    }
                    if (!Emptys.check(deviceInfo.getActiveTime())) {
                        deviceInfo.setActiveTime(now);
                    }
                }
                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();
    }
}