package cn.iocoder.yudao.module.finance.service.asset;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.module.finance.controller.admin.asset.vo.FinFixedAssetDepreciateRespVO;
import cn.iocoder.yudao.module.finance.controller.admin.asset.vo.FinFixedAssetPageReqVO;
import cn.iocoder.yudao.module.finance.controller.admin.asset.vo.FinFixedAssetSaveReqVO;
import cn.iocoder.yudao.module.finance.dal.dataobject.asset.FinFixedAssetDO;
import cn.iocoder.yudao.module.finance.dal.mysql.asset.FinFixedAssetMapper;
import cn.iocoder.yudao.module.finance.enums.FinFixedAssetStatusEnum;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.module.finance.enums.ErrorCodeConstants.*;
import static cn.iocoder.yudao.module.finance.service.asset.FinAssetAmountUtils.calcDepreciableBase;
import static cn.iocoder.yudao.module.finance.service.asset.FinAssetAmountUtils.calcMonthlyAmount;

/**
 * 固定资产 Service 实现类
 *
 * @author 超级管理员
 */
@Service
@Validated
public class FinFixedAssetServiceImpl implements FinFixedAssetService {

    @Resource
    private FinFixedAssetMapper fixedAssetMapper;

    @Override
    public Long createFixedAsset(FinFixedAssetSaveReqVO createReqVO) {
        // 1. 校验资产编号唯一
        validateAssetCodeUnique(null, createReqVO.getAssetCode());
        // 2. 插入：新资产尚未计提折旧
        FinFixedAssetDO asset = BeanUtils.toBean(createReqVO, FinFixedAssetDO.class);
        asset.setAssetCode(StrUtil.trim(asset.getAssetCode()));
        asset.setResidualRate(ObjectUtil.defaultIfNull(asset.getResidualRate(), BigDecimal.ZERO));
        asset.setStatus(ObjectUtil.defaultIfNull(asset.getStatus(), FinFixedAssetStatusEnum.IN_USE.getStatus()));
        asset.setAccumulatedDepreciation(BigDecimal.ZERO);
        fillNetValue(asset);
        fixedAssetMapper.insert(asset);
        return asset.getId();
    }

    @Override
    public void updateFixedAsset(FinFixedAssetSaveReqVO updateReqVO) {
        // 1.1 校验存在
        FinFixedAssetDO oldAsset = validateFixedAssetExists(updateReqVO.getId());
        // 1.2 校验资产编号唯一
        validateAssetCodeUnique(updateReqVO.getId(), updateReqVO.getAssetCode());

        // 2.1 更新（累计折旧不从前端接收，沿用库中值）
        FinFixedAssetDO updateObj = BeanUtils.toBean(updateReqVO, FinFixedAssetDO.class);
        updateObj.setAssetCode(StrUtil.trim(updateObj.getAssetCode()));
        updateObj.setResidualRate(ObjectUtil.defaultIfNull(updateObj.getResidualRate(), BigDecimal.ZERO));
        updateObj.setStatus(ObjectUtil.defaultIfNull(updateObj.getStatus(), oldAsset.getStatus()));
        updateObj.setAccumulatedDepreciation(ObjectUtil.defaultIfNull(oldAsset.getAccumulatedDepreciation(), BigDecimal.ZERO));
        // 2.2 原值、残值率变化后，按新的应计提总额封顶累计折旧，并重算净值
        BigDecimal depreciableBase = calcDepreciableBase(defaultIfNull(updateObj.getOriginalValue()),
                updateObj.getResidualRate());
        if (updateObj.getAccumulatedDepreciation().compareTo(depreciableBase) > 0) {
            updateObj.setAccumulatedDepreciation(depreciableBase);
        }
        fillNetValue(updateObj);
        fixedAssetMapper.updateById(updateObj);
    }

    @Override
    public void deleteFixedAsset(Long id) {
        validateFixedAssetExists(id);
        fixedAssetMapper.deleteById(id);
    }

    @Override
    public void deleteFixedAssetList(List<Long> ids) {
        if (CollUtil.isEmpty(ids)) {
            return;
        }
        fixedAssetMapper.deleteByIds(ids);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public FinFixedAssetDepreciateRespVO depreciateFixedAssetList(List<Long> ids) {
        // 1. 查询待计提的资产：已报废的不再计提
        List<FinFixedAssetDO> assets = CollUtil.isEmpty(ids)
                ? fixedAssetMapper.selectList() : fixedAssetMapper.selectListByIds(ids);
        List<FinFixedAssetDO> updateList = new ArrayList<>();
        BigDecimal totalMonthlyDepreciation = BigDecimal.ZERO;
        for (FinFixedAssetDO asset : assets) {
            if (FinFixedAssetStatusEnum.SCRAPPED.getStatus().equals(asset.getStatus())) {
                continue;
            }
            BigDecimal originalValue = defaultIfNull(asset.getOriginalValue());
            BigDecimal residualRate = defaultIfNull(asset.getResidualRate());
            int usefulLife = ObjectUtil.defaultIfNull(asset.getUsefulLife(), 0);
            BigDecimal accumulated = defaultIfNull(asset.getAccumulatedDepreciation());
            // 1.1 已提足的不再计提
            BigDecimal depreciableBase = calcDepreciableBase(originalValue, residualRate);
            BigDecimal remaining = depreciableBase.subtract(accumulated);
            if (remaining.compareTo(BigDecimal.ZERO) <= 0) {
                continue;
            }
            // 1.2 参数异常导致月折旧额非正
            BigDecimal monthlyDepreciation = usefulLife <= 0 ? BigDecimal.ZERO
                    : calcMonthlyAmount(originalValue, residualRate, usefulLife);
            if (monthlyDepreciation.compareTo(BigDecimal.ZERO) <= 0) {
                throw exception(FIXED_ASSET_DEPRECIATE_NEGATIVE, asset.getAssetName(),
                        formatAmount(originalValue), usefulLife, formatAmount(residualRate));
            }
            // 1.3 最后一期按剩余可折旧额封顶，净值不会被提成负数
            BigDecimal periodDepreciation = monthlyDepreciation.min(remaining);
            BigDecimal newAccumulated = accumulated.add(periodDepreciation);
            updateList.add(new FinFixedAssetDO().setId(asset.getId())
                    .setAccumulatedDepreciation(newAccumulated)
                    .setNetValue(originalValue.subtract(newAccumulated).max(BigDecimal.ZERO)));
            totalMonthlyDepreciation = totalMonthlyDepreciation.add(periodDepreciation);
        }
        // 2. 没有可计提的资产，明确告知
        if (updateList.isEmpty()) {
            throw exception(FIXED_ASSET_DEPRECIATE_EMPTY);
        }
        // 3. 批量更新
        fixedAssetMapper.updateBatch(updateList);
        return new FinFixedAssetDepreciateRespVO().setProcessedCount(updateList.size())
                .setTotalMonthlyDepreciation(totalMonthlyDepreciation);
    }

    @Override
    public FinFixedAssetDO getFixedAsset(Long id) {
        return fixedAssetMapper.selectById(id);
    }

    @Override
    public PageResult<FinFixedAssetDO> getFixedAssetPage(FinFixedAssetPageReqVO pageReqVO) {
        return fixedAssetMapper.selectPage(pageReqVO);
    }

    @Override
    public List<FinFixedAssetDO> getFixedAssetList(Collection<Long> ids) {
        if (CollUtil.isEmpty(ids)) {
            return Collections.emptyList();
        }
        return fixedAssetMapper.selectListByIds(ids);
    }

    @Override
    public List<FinFixedAssetDO> getFixedAssetList() {
        return fixedAssetMapper.selectList();
    }

    private FinFixedAssetDO validateFixedAssetExists(Long id) {
        if (id == null) {
            throw exception(FIXED_ASSET_NOT_EXISTS);
        }
        FinFixedAssetDO asset = fixedAssetMapper.selectById(id);
        if (asset == null) {
            throw exception(FIXED_ASSET_NOT_EXISTS);
        }
        return asset;
    }

    private void validateAssetCodeUnique(Long id, String assetCode) {
        FinFixedAssetDO asset = fixedAssetMapper.selectByAssetCode(StrUtil.trim(assetCode));
        if (asset == null) {
            return;
        }
        if (id == null || !asset.getId().equals(id)) {
            throw exception(FIXED_ASSET_CODE_DUPLICATE, assetCode);
        }
    }

    /**
     * 净值 = 原值 - 累计折旧，且不小于 0
     */
    private void fillNetValue(FinFixedAssetDO asset) {
        BigDecimal netValue = defaultIfNull(asset.getOriginalValue())
                .subtract(defaultIfNull(asset.getAccumulatedDepreciation()));
        asset.setNetValue(netValue.max(BigDecimal.ZERO));
    }

    private static BigDecimal defaultIfNull(BigDecimal amount) {
        return amount == null ? BigDecimal.ZERO : amount;
    }

    private static String formatAmount(BigDecimal amount) {
        return amount.setScale(2, RoundingMode.HALF_UP).toPlainString();
    }

}