package com.ruoyi.outsourcing.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.account.mapper.PaymentRecordMapper;
import com.ruoyi.account.pojo.PaymentRecord;
import com.ruoyi.basic.enums.ApplicationTypeEnum;
import com.ruoyi.basic.enums.RecordTypeEnum;
import com.ruoyi.basic.utils.FileUtil;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.outsourcing.dto.OutsourcingPartnerDto;
import com.ruoyi.outsourcing.excel.OutsourcingPartnerExcelDto;
import com.ruoyi.outsourcing.mapper.OutsourcingPartnerMapper;
import com.ruoyi.outsourcing.mapper.OutsourcingOrderMapper;
import com.ruoyi.outsourcing.pojo.OutsourcingOrder;
import com.ruoyi.outsourcing.pojo.OutsourcingPartner;
import com.ruoyi.outsourcing.service.IOutsourcingPartnerService;
import com.ruoyi.outsourcing.vo.OutsourcingPartnerTransactionsDetailsVo;
import com.ruoyi.outsourcing.vo.OutsourcingPartnerTransactionsVo;
import com.ruoyi.outsourcing.vo.OutsourcingPartnerVo;
import jakarta.servlet.http.HttpServletResponse;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.web.multipart.MultipartFile;

import java.time.LocalDate;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 委外合作商档案 Service 实现
 */
@Service
@RequiredArgsConstructor
public class OutsourcingPartnerServiceImpl extends ServiceImpl<OutsourcingPartnerMapper, OutsourcingPartner>
        implements IOutsourcingPartnerService {

    private final OutsourcingPartnerMapper partnerMapper;
    private final OutsourcingOrderMapper outsourcingOrderMapper;
    private final PaymentRecordMapper paymentRecordMapper;
    private final FileUtil fileUtil;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Long savePartner(OutsourcingPartnerDto dto) {
        if (dto.getPartnerName() == null || dto.getPartnerName().trim().isEmpty()) {
            throw new ServiceException("请填写合作商名称");
        }
        checkPartnerNameDuplicate(dto.getPartnerName(), null);

        OutsourcingPartner partner = new OutsourcingPartner();
        BeanUtils.copyProperties(dto, partner);
        partner.setId(null);
        partner.setTenantId(null);
        partner.setDeptId(null);
        partner.setCreateUser(null);
        partner.setCreateTime(null);
        partner.setUpdateTime(null);
        if (partner.getMaintainTime() == null) {
            partner.setMaintainTime(LocalDate.now());
        }
        if (partner.getMaintainUserId() == null) {
            partner.setMaintainUserId(SecurityUtils.getUserId());
        }
        partnerMapper.insert(partner);

        fileUtil.saveStorageAttachment(ApplicationTypeEnum.FILE, RecordTypeEnum.OUTSOURCING_PARTNER,
                partner.getId(), dto.getStorageBlobDTOS());
        return partner.getId();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean updatePartner(OutsourcingPartnerDto dto) {
        if (dto.getId() == null) {
            throw new ServiceException("合作商id不能为空");
        }
        if (partnerMapper.selectById(dto.getId()) == null) {
            throw new ServiceException("合作商不存在");
        }
        checkPartnerNameDuplicate(dto.getPartnerName(), dto.getId());

        OutsourcingPartner partner = new OutsourcingPartner();
        BeanUtils.copyProperties(dto, partner);
        // 租户、创建信息由系统维护，置空后 MyBatis-Plus 不会更新这些列
        partner.setTenantId(null);
        partner.setDeptId(null);
        partner.setCreateUser(null);
        partner.setCreateTime(null);
        partner.setUpdateTime(null);
        boolean updated = partnerMapper.updateById(partner) > 0;

        if (updated) {
            fileUtil.saveStorageAttachment(ApplicationTypeEnum.FILE, RecordTypeEnum.OUTSOURCING_PARTNER,
                    dto.getId(), dto.getStorageBlobDTOS());
        }
        return updated;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean delPartner(List<Long> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            throw new ServiceException("请选择至少一条数据");
        }
        Long orderCount = outsourcingOrderMapper.selectCount(Wrappers.<OutsourcingOrder>lambdaQuery()
                .in(OutsourcingOrder::getPartnerId, ids));
        if (orderCount != null && orderCount > 0) {
            throw new ServiceException("合作商已存在委外订单，不允许删除");
        }
        Long paymentCount = paymentRecordMapper.selectCount(Wrappers.<PaymentRecord>lambdaQuery()
                .eq(PaymentRecord::getPartyType, 3)
                .in(PaymentRecord::getPartyId, ids));
        if (paymentCount != null && paymentCount > 0) {
            throw new ServiceException("合作商已存在往来收付款记录，不允许删除");
        }

        fileUtil.deleteStorageAttachmentsByApplicationAndRecordTypeAndRecordIds(
                ApplicationTypeEnum.FILE, RecordTypeEnum.OUTSOURCING_PARTNER, ids);
        return this.removeByIds(ids);
    }

    @Override
    public OutsourcingPartnerVo partnerDetail(Long id) {
        OutsourcingPartner partner = partnerMapper.selectById(id);
        if (partner == null) {
            throw new ServiceException("合作商不存在");
        }
        OutsourcingPartnerVo vo = new OutsourcingPartnerVo();
        BeanUtils.copyProperties(partner, vo);
        vo.setStorageBlobVOS(fileUtil.getStorageBlobVOsByApplicationAndRecordTypeAndRecordId(
                ApplicationTypeEnum.FILE, RecordTypeEnum.OUTSOURCING_PARTNER, id));
        return vo;
    }

    @Override
    public IPage<OutsourcingPartnerDto> partnerListPage(Page page, OutsourcingPartnerDto dto) {
        return partnerMapper.partnerListPage(page, dto);
    }

    @Override
    public void partnerExport(HttpServletResponse response, OutsourcingPartnerDto dto) {
        List<OutsourcingPartnerExcelDto> list = partnerMapper.partnerExportList(dto);
        ExcelUtil<OutsourcingPartnerExcelDto> util = new ExcelUtil<>(OutsourcingPartnerExcelDto.class);
        util.exportExcel(response, list, "合作商档案");
    }

    @Override
    public Boolean importData(MultipartFile file) {
        try {
            ExcelUtil<OutsourcingPartnerExcelDto> util = new ExcelUtil<>(OutsourcingPartnerExcelDto.class);
            List<OutsourcingPartnerExcelDto> list = util.importExcel(file.getInputStream());
            if (CollectionUtils.isEmpty(list)) {
                return false;
            }
            List<OutsourcingPartner> partners = list.stream().map(excel -> {
                OutsourcingPartner partner = new OutsourcingPartner();
                BeanUtils.copyProperties(excel, partner);
                partner.setMaintainUserId(SecurityUtils.getUserId());
                partner.setMaintainTime(LocalDate.now());
                return partner;
            }).collect(Collectors.toList());
            return this.saveOrUpdateBatch(partners);
        } catch (Exception e) {
            throw new ServiceException("合作商导入失败：" + e.getMessage());
        }
    }

    @Override
    public List<OutsourcingPartner> options() {
        return partnerMapper.selectList(new LambdaQueryWrapper<OutsourcingPartner>()
                .select(OutsourcingPartner::getId, OutsourcingPartner::getPartnerName)
                .orderByDesc(OutsourcingPartner::getId));
    }

    @Override
    public IPage<OutsourcingPartnerTransactionsVo> partnerTransactions(Page page, String partnerName) {
        return partnerMapper.partnerTransactions(page, partnerName);
    }

    @Override
    public IPage<OutsourcingPartnerTransactionsDetailsVo> partnerTransactionsDetails(Page page, Long partnerId) {
        return partnerMapper.partnerTransactionsDetails(page, partnerId);
    }

    /**
     * 合作商名称在租户内唯一
     */
    private void checkPartnerNameDuplicate(String partnerName, Long excludeId) {
        if (partnerName == null || partnerName.trim().isEmpty()) {
            return;
        }
        Long tenantId = SecurityUtils.getLoginUser().getTenantId();
        LambdaQueryWrapper<OutsourcingPartner> wrapper = Wrappers.<OutsourcingPartner>lambdaQuery()
                .eq(tenantId != null, OutsourcingPartner::getTenantId, tenantId)
                .isNull(tenantId == null, OutsourcingPartner::getTenantId)
                .eq(OutsourcingPartner::getPartnerName, partnerName)
                .ne(excludeId != null, OutsourcingPartner::getId, excludeId);
        if (partnerMapper.selectCount(wrapper) > 0) {
            throw new ServiceException("合作商已存在");
        }
    }
}