package com.ruoyi.sales.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.enums.FileNameType;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.sales.mapper.AreaMapper;
import com.ruoyi.sales.mapper.BidWinningLedgerMapper;
import com.ruoyi.sales.mapper.BidWinningLedgerRecordMapper;
import com.ruoyi.sales.mapper.CommonFileMapper;
import com.ruoyi.sales.pojo.Area;
import com.ruoyi.sales.pojo.BidWinningLedger;
import com.ruoyi.sales.pojo.BidWinningLedgerRecord;
import com.ruoyi.sales.pojo.CommonFile;
import com.ruoyi.sales.service.BidWinningLedgerService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.io.IOException;
import java.util.Date;
import java.util.List;

@Service
@RequiredArgsConstructor
public class BidWinningLedgerServiceImpl extends ServiceImpl<BidWinningLedgerMapper, BidWinningLedger> implements BidWinningLedgerService {

    private final BidWinningLedgerMapper bidWinningLedgerMapper;
    private final BidWinningLedgerRecordMapper bidWinningLedgerRecordMapper;
    private final CommonFileMapper commonFileMapper;
    private final AreaMapper areaMapper;
    private final CommonFileServiceImpl commonFileService;

    @Override
    public IPage<BidWinningLedger> listPage(Page page, BidWinningLedger bidWinningLedger) {
        LambdaQueryWrapper<BidWinningLedger> queryWrapper = new LambdaQueryWrapper<>();
        if (bidWinningLedger != null) {
            if (StringUtils.isNotEmpty(bidWinningLedger.getCustomerName())) {
                queryWrapper.like(BidWinningLedger::getCustomerName, bidWinningLedger.getCustomerName());
            }
            if (StringUtils.isNotEmpty(bidWinningLedger.getProvince())) {
                queryWrapper.eq(BidWinningLedger::getProvince, bidWinningLedger.getProvince());
            }
            if (StringUtils.isNotEmpty(bidWinningLedger.getCity())) {
                queryWrapper.eq(BidWinningLedger::getCity, bidWinningLedger.getCity());
            }
            if (StringUtils.isNotEmpty(bidWinningLedger.getEntryPerson())) {
                queryWrapper.like(BidWinningLedger::getEntryPerson, bidWinningLedger.getEntryPerson());
            }
            if (StringUtils.isNotEmpty(bidWinningLedger.getStatus())) {
                queryWrapper.eq(BidWinningLedger::getStatus, bidWinningLedger.getStatus());
            }
            if (StringUtils.isNotEmpty(bidWinningLedger.getEntryDateStart()) && StringUtils.isNotEmpty(bidWinningLedger.getEntryDateEnd())) {
                queryWrapper.ge(BidWinningLedger::getEntryDate, bidWinningLedger.getEntryDateStart())
                        .le(BidWinningLedger::getEntryDate, bidWinningLedger.getEntryDateEnd());
            }
        }
        queryWrapper.orderByDesc(BidWinningLedger::getUpdateTime)
                .orderByDesc(BidWinningLedger::getEntryDate);
        return bidWinningLedgerMapper.selectPage(page, queryWrapper);
    }

    @Override
    public BidWinningLedger getDetail(Long id) {
        BidWinningLedger bidWinningLedger = bidWinningLedgerMapper.selectById(id);
        if (bidWinningLedger == null) {
            return null;
        }
        bidWinningLedger.setCommonFiles(commonFileService.getFileList(id, FileNameType.BID_WINNING_LEDGER.getValue()));
        bidWinningLedger.setRecordList(bidWinningLedgerRecordMapper.selectList(new LambdaQueryWrapper<BidWinningLedgerRecord>()
                .eq(BidWinningLedgerRecord::getBidWinningLedgerId, id)
                .orderByDesc(BidWinningLedgerRecord::getCreateTime)));
        return bidWinningLedger;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean addLedger(BidWinningLedger bidWinningLedger) throws IOException {
        fillDefaultFields(bidWinningLedger);
        boolean saved = save(bidWinningLedger);
        if (saved) {
            commonFileService.migrateTempFilesToFormal(bidWinningLedger.getId(), bidWinningLedger.getTempFileIds());
        }
        return saved;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean updateLedger(BidWinningLedger bidWinningLedger) throws IOException {
        fillDefaultFields(bidWinningLedger);
        boolean updated = updateById(bidWinningLedger);
        if (updated) {
            commonFileService.migrateTempFilesToFormal(bidWinningLedger.getId(), bidWinningLedger.getTempFileIds());
        }
        return updated;
    }

    @Override
    public boolean addRecord(BidWinningLedgerRecord bidWinningLedgerRecord) {
        if (StringUtils.isEmpty(bidWinningLedgerRecord.getEntryPerson())) {
            bidWinningLedgerRecord.setEntryPerson(SecurityUtils.getLoginUser().getUser().getNickName());
        }
        if (bidWinningLedgerRecord.getEntryDate() == null) {
            bidWinningLedgerRecord.setEntryDate(new Date());
        }
        int inserted = bidWinningLedgerRecordMapper.insert(bidWinningLedgerRecord);
        if (inserted > 0 && bidWinningLedgerRecord.getBidWinningLedgerId() != null) {
            BidWinningLedger updateEntity = new BidWinningLedger();
            updateEntity.setId(bidWinningLedgerRecord.getBidWinningLedgerId());
            updateEntity.setStatus(bidWinningLedgerRecord.getStatus());
            bidWinningLedgerMapper.updateById(updateEntity);
            return true;
        }
        return inserted > 0;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean removeLedgerBatchByIds(List<Long> ids) {
        if (ids == null || ids.isEmpty()) {
            return false;
        }
        bidWinningLedgerRecordMapper.delete(new LambdaQueryWrapper<BidWinningLedgerRecord>()
                .in(BidWinningLedgerRecord::getBidWinningLedgerId, ids));
        commonFileMapper.delete(new LambdaQueryWrapper<CommonFile>()
                .in(CommonFile::getCommonId, ids)
                .eq(CommonFile::getType, FileNameType.BID_WINNING_LEDGER.getValue()));
        return removeByIds(ids);
    }

    @Override
    public List<Area> getProvinceList() {
        return areaMapper.selectList(new LambdaQueryWrapper<Area>().eq(Area::getLevel, 1).eq(Area::getParentId, 0));
    }

    @Override
    public List<Area> getCityList(Integer provinceId) {
        return areaMapper.selectList(new LambdaQueryWrapper<Area>().eq(Area::getLevel, 2).eq(Area::getParentId, provinceId));
    }

    private void fillDefaultFields(BidWinningLedger bidWinningLedger) {
        if (StringUtils.isEmpty(bidWinningLedger.getEntryPerson())) {
            bidWinningLedger.setEntryPerson(SecurityUtils.getLoginUser().getUser().getNickName());
        }
        if (bidWinningLedger.getEntryDate() == null) {
            bidWinningLedger.setEntryDate(new Date());
        }
    }
}