package com.ruoyi.account.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.account.dto.DeviceTypeDetail;
import com.ruoyi.account.dto.DeviceTypeDistributionVO;
import com.ruoyi.account.mapper.BorrowInfoMapper;
import com.ruoyi.account.pojo.BorrowInfo;
import com.ruoyi.device.mapper.DeviceLedgerMapper;
import com.ruoyi.device.pojo.DeviceLedger;
import com.ruoyi.framework.web.domain.AjaxResult;
import com.ruoyi.procurementrecord.mapper.CustomStorageMapper;
import com.ruoyi.procurementrecord.mapper.ProcurementRecordMapper;
import com.ruoyi.procurementrecord.mapper.ProcurementRecordOutMapper;
import com.ruoyi.procurementrecord.pojo.CustomStorage;
import com.ruoyi.procurementrecord.pojo.ProcurementRecordOut;
import com.ruoyi.procurementrecord.pojo.ProcurementRecordStorage;
import com.ruoyi.procurementrecord.service.impl.ProcurementRecordOutServiceImpl;
import com.ruoyi.procurementrecord.service.impl.ProcurementRecordServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.time.Year;
import java.time.temporal.ChronoUnit;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @author :yys
 * @date : 2026/1/17 10:41
 */
@Service
@Slf4j
public class AccountingServiceImpl {

    @Autowired
    private DeviceLedgerMapper deviceLedgerMapper;

    @Autowired
    private BorrowInfoMapper borrowInfoMapper;

    @Autowired
    private CustomStorageMapper customStorageMapper;

    @Autowired
    private ProcurementRecordMapper procurementRecordMapper;

    @Autowired
    private ProcurementRecordOutMapper procurementRecordOutMapper;

    public AjaxResult total(Integer year) {
        Map<String,Object> map = new HashMap<>();
        map.put("deprAmount",0); // 折旧金额
        map.put("deviceTotal",0); // 设备总数
        map.put("deviceAmount",0); // 设备资产原值
        map.put("netValue",0); // 净值
        map.put("debt",0); // 负债
        map.put("inventoryValue",0); // 库存资产
        LambdaQueryWrapper<DeviceLedger> deviceLedgerLambdaQueryWrapper = new LambdaQueryWrapper<>();
        deviceLedgerLambdaQueryWrapper.like(DeviceLedger::getCreateTime,year);
        List<DeviceLedger> deviceLedgers = deviceLedgerMapper.selectList(deviceLedgerLambdaQueryWrapper);
        if(CollectionUtils.isNotEmpty(deviceLedgers)){
            map.put("deviceTotal",deviceLedgers.size());
            BigDecimal reduce = deviceLedgers.stream()
                    .map(DeviceLedger::getTaxIncludingPriceTotal)
                    .filter(Objects::nonNull)
                    .reduce(BigDecimal.ZERO, BigDecimal::add);
            map.put("deviceAmount",reduce);
            List<DeviceLedger> collect = deviceLedgers.stream().filter(deviceLedger -> deviceLedger.getIsDepr() != null && deviceLedger.getIsDepr() == 1).collect(Collectors.toList());
            // 根据当前年份和设备录入时间年份比较 * 每年折旧金额 = 设备折旧金额
            BigDecimal total = new BigDecimal(0);
            if(CollectionUtils.isNotEmpty(collect)){
                for (DeviceLedger deviceLedger : collect) {
                    BigDecimal totalDepreciation = calculatePreciseDepreciation(deviceLedger);
                    total = total.add(totalDepreciation);
                }
                map.put("deprAmount",total);
            }
            // 净值 = 设备资产原值 - 设备累计折旧金额
            map.put("netValue",reduce.subtract(total));
        }
        // 负债
        LambdaQueryWrapper<BorrowInfo> borrowInfoLambdaQueryWrapper = new LambdaQueryWrapper<>();
        borrowInfoLambdaQueryWrapper.like(BorrowInfo::getCreateTime,year)
                .eq(BorrowInfo::getStatus,1);
        List<BorrowInfo> borrowInfos = borrowInfoMapper.selectList(borrowInfoLambdaQueryWrapper);
        if(CollectionUtils.isNotEmpty(borrowInfos)){
            BigDecimal reduce = borrowInfos.stream()
                    .map(BorrowInfo::getBorrowAmount)
                    .filter(Objects::nonNull)
                    .reduce(BigDecimal.ZERO, BigDecimal::add);
            map.put("debt",reduce);
        }
        // 库存资产
        LambdaQueryWrapper<ProcurementRecordStorage> procurementRecordStorageLambdaQueryWrapper = new LambdaQueryWrapper<>();
        procurementRecordStorageLambdaQueryWrapper.like(ProcurementRecordStorage::getCreateTime,year);
        List<ProcurementRecordStorage> procurementRecordStorages = procurementRecordMapper.selectList(procurementRecordStorageLambdaQueryWrapper);
        BigDecimal procurementRecordTotal = new BigDecimal(0);
        if(CollectionUtils.isNotEmpty(procurementRecordStorages)){
            // 获取出库数据
            LambdaQueryWrapper<ProcurementRecordOut> procurementRecordOutLambdaQueryWrapper = new LambdaQueryWrapper<>();
            procurementRecordOutLambdaQueryWrapper.like(ProcurementRecordOut::getCreateTime,year)
                    .in(ProcurementRecordOut::getProcurementRecordStorageId, procurementRecordStorages
                            .stream()
                            .map(ProcurementRecordStorage::getId)
                            .collect(Collectors.toList()))
                    .in(ProcurementRecordOut::getType,Arrays.asList(1,2));
            List<ProcurementRecordOut> procurementRecordOuts = procurementRecordOutMapper.selectList(procurementRecordOutLambdaQueryWrapper);
            for (ProcurementRecordStorage procurementRecordStorage : procurementRecordStorages) {
                // 采购，生产入库总价值
                procurementRecordTotal.add(procurementRecordStorage.getUnitPrice().multiply(procurementRecordStorage.getInboundNum()));
                // 通过入库id，类型获取出库数据
                List<ProcurementRecordOut> procurementRecordOutsByStorageId = procurementRecordOuts.stream()
                        .filter(procurementRecordOut -> procurementRecordOut.getProcurementRecordStorageId().equals(procurementRecordStorage.getId())
                        && procurementRecordOut.getType().equals(procurementRecordStorage.getType()))
                        .collect(Collectors.toList());
                if(CollectionUtils.isNotEmpty(procurementRecordOutsByStorageId)){
                    for (ProcurementRecordOut procurementRecordOut : procurementRecordOutsByStorageId) {
                        // 采购，生产出库总价值
                        procurementRecordTotal.subtract(procurementRecordStorage.getUnitPrice().multiply(procurementRecordOut.getInboundNum()));
                    }
                }

            }


        }
        LambdaQueryWrapper<CustomStorage> customStorageLambdaQueryWrapper = new LambdaQueryWrapper<>();
        customStorageLambdaQueryWrapper.like(CustomStorage::getInboundDate,year);
        List<CustomStorage> customStorages = customStorageMapper.selectList(customStorageLambdaQueryWrapper);
        BigDecimal customStorageTotal = new BigDecimal(0);
        if(CollectionUtils.isNotEmpty(customStorages)){
            // 获取出库数据
            LambdaQueryWrapper<ProcurementRecordOut> procurementRecordOutLambdaQueryWrapper = new LambdaQueryWrapper<>();
            procurementRecordOutLambdaQueryWrapper.like(ProcurementRecordOut::getCreateTime,year)
                    .in(ProcurementRecordOut::getProcurementRecordStorageId, customStorages
                            .stream()
                            .map(CustomStorage::getId)
                            .collect(Collectors.toList()))
                    .eq(ProcurementRecordOut::getType,3);
            List<ProcurementRecordOut> procurementRecordOuts = procurementRecordOutMapper.selectList(procurementRecordOutLambdaQueryWrapper);
            customStorages.forEach(customStorage -> {
                // 自定义入库总价值
                customStorageTotal.add(customStorage.getTaxInclusiveUnitPrice().multiply(customStorage.getInboundNum()));
                // 通过入库id，类型获取出库数据
                List<ProcurementRecordOut> procurementRecordOutsByStorageId = procurementRecordOuts.stream()
                        .filter(procurementRecordOut -> procurementRecordOut.getProcurementRecordStorageId().equals(customStorage.getId()))
                        .collect(Collectors.toList());
                if(CollectionUtils.isNotEmpty(procurementRecordOutsByStorageId)){
                    for (ProcurementRecordOut procurementRecordOut : procurementRecordOutsByStorageId) {
                        // 自定义出库总价值
                        customStorageTotal.subtract(procurementRecordOut.getInboundNum().multiply(customStorage.getTaxInclusiveUnitPrice()));
                    }
                }
            });
        }
        map.put("inventoryValue",procurementRecordTotal.add(customStorageTotal));
        return AjaxResult.success( map);
    }

    /**
     * 计算设备累计折旧金额
     * @param deviceLedger 设备台账实体
     * @return 累计折旧金额（BigDecimal，保留2位小数）
     */
    public static BigDecimal calculateTotalDepreciation(DeviceLedger deviceLedger) {
        // 1. 空值校验
        if (deviceLedger == null) {
            return BigDecimal.ZERO;
        }

        // 2. 判断是否开启折旧，未开启则折旧金额为0
        Integer isDepr = deviceLedger.getIsDepr();
        if (isDepr == null || isDepr != 1) { // 1-是 2-否
            return BigDecimal.ZERO;
        }

        // 3. 获取每年折旧金额，为空则返回0
        BigDecimal annualDepreciation = deviceLedger.getAnnualDepreciationAmount();
        if (annualDepreciation == null || annualDepreciation.compareTo(BigDecimal.ZERO) <= 0) {
            return BigDecimal.ZERO;
        }

        // 4. 获取设备录入时间，为空则返回0
        LocalDateTime createTime = deviceLedger.getCreateTime();
        if (createTime == null) {
            return BigDecimal.ZERO;
        }

        // 5. 计算年份差值
        int currentYear = Year.now().getValue(); // 当前年份
        int createYear = createTime.getYear();    // 设备录入年份
        int yearDiff = currentYear - createYear;

        // 6. 处理年份差值为负数的情况（录入时间在未来）
        if (yearDiff < 0) {
            return BigDecimal.ZERO;
        }

        // 7. 计算总折旧金额 = 年份差值 * 每年折旧金额
        BigDecimal totalDepreciation = annualDepreciation.multiply(BigDecimal.valueOf(yearDiff));

        // 8. 返回保留2位小数的结果（金额规范）
        return totalDepreciation.setScale(2, BigDecimal.ROUND_HALF_UP);
    }

    /**
     * 【进阶版】按实际天数计算折旧（更精准）
     * @param deviceLedger 设备台账实体
     * @return 累计折旧金额
     */
    public static BigDecimal calculatePreciseDepreciation(DeviceLedger deviceLedger) {
        if (deviceLedger == null) {
            return BigDecimal.ZERO;
        }

        // 判断是否开启折旧
        Integer isDepr = deviceLedger.getIsDepr();
        if (isDepr == null || isDepr != 1) {
            return BigDecimal.ZERO;
        }

        // 获取每年折旧金额
        BigDecimal annualDepreciation = deviceLedger.getAnnualDepreciationAmount();
        if (annualDepreciation == null || annualDepreciation.compareTo(BigDecimal.ZERO) <= 0) {
            return BigDecimal.ZERO;
        }

        // 获取设备录入时间
        LocalDateTime createTime = deviceLedger.getCreateTime();
        if (createTime == null) {
            return BigDecimal.ZERO;
        }

        // 当前时间
        LocalDateTime now = LocalDateTime.now();

        // 如果录入时间在未来，返回0
        if (createTime.isAfter(now)) {
            return BigDecimal.ZERO;
        }

        // 计算总天数
        long days = ChronoUnit.DAYS.between(createTime, now);

        // 按每年365天计算折旧金额
        BigDecimal dailyDepreciation = annualDepreciation.divide(BigDecimal.valueOf(365), 6, BigDecimal.ROUND_HALF_UP);
        BigDecimal totalDepreciation = dailyDepreciation.multiply(BigDecimal.valueOf(days));

        return totalDepreciation.setScale(2, BigDecimal.ROUND_HALF_UP);
    }

    public AjaxResult deviceTypeDistribution(Integer year) {
        // 2. 组装返回VO
       DeviceTypeDistributionVO vo = new DeviceTypeDistributionVO();
       List<DeviceTypeDetail> details = deviceLedgerMapper.getDeviceTypeDistributionByYear( year);
        vo.setDetails(details);
       if(CollectionUtils.isNotEmpty(details)){
           // 3. 提取图表所需的分类和数据
           vo.setCategories(details.stream()
                   .map(DeviceTypeDetail::getType)
                   .collect(Collectors.toList()));

           vo.setCountData(details.stream()
                   .map(DeviceTypeDetail::getCount)
                   .collect(Collectors.toList()));

           vo.setAmountData(details.stream()
                   .map(DeviceTypeDetail::getAmount)
                   .collect(Collectors.toList()));
           vo.setTotalCount(vo.getCategories().size());
       }
        return AjaxResult.success(vo);
    }

    public AjaxResult calculateDepreciation(Page page, Integer year) {
        LambdaQueryWrapper<DeviceLedger> deviceLedgerLambdaQueryWrapper = new LambdaQueryWrapper<>();
        deviceLedgerLambdaQueryWrapper.like(DeviceLedger::getCreateTime,year)
                .eq(DeviceLedger::getIsDepr,1);
        IPage<DeviceLedger> deviceLedgerIPage = deviceLedgerMapper.selectPage(page, deviceLedgerLambdaQueryWrapper);
        for (DeviceLedger record : deviceLedgerIPage.getRecords()) {
            record.setDeprAmount(calculatePreciseDepreciation(record));
            record.setNetValue(record.getTaxIncludingPriceTotal().subtract(record.getDeprAmount()));
        }
        return AjaxResult.success(deviceLedgerIPage);
    }
}