package com.ruoyi.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.utils.MapUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.domain.*;
import com.ruoyi.mapper.ArchiveSignatureMapper;
import com.ruoyi.mapper.ArchiverecordstouserMapper;
import com.ruoyi.service.IArchiveSignatureService;
import com.ruoyi.service.IArchiverecordstouserService;
import com.ruoyi.util.ErrorcodeExceptionextends;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.*;

@Service
public class ArchiveSignatureServiceImpl extends ServiceImpl<ArchiveSignatureMapper, ArchiveSignature> implements IArchiveSignatureService {


    private LambdaQueryWrapper<ArchiveSignature> buildCondition(ArchiveSignature archiveSignature){
        LambdaQueryWrapper<ArchiveSignature> lqw = new LambdaQueryWrapper<>();
        lqw.like(!StringUtils.isEmpty(archiveSignature.getSigaName()), ArchiveSignature::getSigaName, archiveSignature.getSigaName());

        lqw.orderByDesc(ArchiveSignature::getCreateTime);
        System.out.println("ssssssssssssddd0000000000000000");
        return lqw;

    }

    @Override
    public AjaxResult selectDataList(ArchiveSignature archiveSignature, Integer pageNum, Integer pageSize) {
        LambdaQueryWrapper<ArchiveSignature> lqw = buildCondition(archiveSignature);


        Page<ArchiveSignature> archiveSignaturePage = new Page<>(pageNum, pageSize);
        Page<ArchiveSignature> pageResult = page(archiveSignaturePage, lqw);

        List<ArchiveSignature> beanRecords = pageResult.getRecords();//得到查询出来的数据



        //  List<ArchiveRecords> beanRecords = list(lqw);
        //   log.info("从数据库中查到的为:{}", beanRecords);
        //    return markOwnData(familyId, fatherFaId, motherFaId, beanRecords);
        HashMap<String, Object> data = MapUtils.getResult(pageResult, beanRecords);


        return AjaxResult.success(data);      }

    @Override
    public ArchiveSignature selectArchiveSignatureById(Long id) {
        LambdaQueryWrapper<ArchiveSignature> lqw = new LambdaQueryWrapper<>();
        lqw.eq(id!=null, ArchiveSignature::getId, id);
        List<ArchiveSignature> lists = this.list(lqw);
        if(!lists.isEmpty())
            return lists.get(0);
        else
            return null;
    }

    @Override
    public AjaxResult importExcel(MultipartFile file) {
        ExcelUtil<ArchiveSignature> util = new ExcelUtil<>(ArchiveSignature.class);
        List<ArchiveSignature> dataList = null;
        try {
            dataList = util.importExcel(file.getInputStream());
        } catch (Exception e) {
            throw new RuntimeException("没有按照规则导入数据");
        }

        assert dataList != null;

        for (ArchiveSignature archiveSignature : dataList) {
            // physcialService.mySave(physcial);
            this.insertArchiveSignature(archiveSignature);
        }

        return AjaxResult.success();
    }

    @Override
    public List<ArchiveSignature> selectArchiveSignatureList(ArchiveSignature archiveSignature) {

        LambdaQueryWrapper<ArchiveSignature> lqw = new LambdaQueryWrapper<>();
        LambdaQueryWrapper<ArchiveSignature> lambdaQueryWrapper = buildCondition(archiveSignature);
        List<ArchiveSignature> beanRecords = list(lambdaQueryWrapper);
        return beanRecords;
    }

    @Override
    public List<ArchiveSignature> selectArchiveSignatureByIds(Long[] ids) {
        // 创建查询条件
        LambdaQueryWrapper<ArchiveSignature> lambdaQueryWrapper = new LambdaQueryWrapper<>();

        // 根据ids查询
        lambdaQueryWrapper.in(ArchiveSignature::getId, Arrays.asList(ids));

        // 如果不是管理员，需要考虑权限过滤（可根据实际权限需求调整）
//        if (userid != 1) {
//            // 这里可以添加权限相关的过滤条件
//        }

        List<ArchiveSignature> beanRecords = list(lambdaQueryWrapper);
        return beanRecords;
    }

    @Override
    public int insertArchiveSignature(ArchiveSignature archiveSignature) {
        LocalDateTime time = LocalDateTime.now();
        if(archiveSignature.getSigaName()==null||StringUtils.isEmpty(archiveSignature.getSigaName()))
            throw new RuntimeException("签名信息不能为空！");
        Date date = Date.from(time.atZone(ZoneId.systemDefault()).toInstant());
        archiveSignature.setCreateTime(date);
    //    System.out.println(archiveRecords.getRecordId());
        //根据档号查询，是否已经有档号，有的话，就不让插入
        LambdaQueryWrapper<ArchiveSignature> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(!StringUtils.isEmpty(archiveSignature.getSigaName()), ArchiveSignature::getSigaName,
                archiveSignature.getSigaName());
        List<ArchiveSignature> lis = list(lambdaQueryWrapper);
        if(!lis.isEmpty())
        {
            return 0;
        }
      //  archiveRecords.setRecordStatus("未录入");
        //  archiveRecords
        boolean res = this.save(archiveSignature);

        //0表示失败，1表示成功
        if(res)
            return 1;
        else
            return 0;
    }

    @Override
    public int updateArchiveSignature(ArchiveSignature archiveSignature) {

        boolean result = false;
        try {
            // 使用LambdaUpdateWrapper构造更新条件，确保null值也能更新到数据库
            LambdaUpdateWrapper<ArchiveSignature> updateWrapper = new LambdaUpdateWrapper<>();
            updateWrapper.eq(ArchiveSignature::getId, archiveSignature.getId());

            // 明确设置需要更新的字段
            updateWrapper.set(ArchiveSignature::getSigaName, archiveSignature.getSigaName());
            updateWrapper.set(ArchiveSignature::getCreateTime, archiveSignature.getCreateTime());

            // 执行更新操作
            result = update(updateWrapper);
        } catch (Exception e) {
            System.out.println(e);
            throw new ErrorcodeExceptionextends(500, "不允许签名信息重复！");
        }
        if(result)
            return 1;
        else
            return 0;

    }

    @Override
    public int deleteArchiveSignatureByIds(Long[] ids) {
        if (this.removeByIds(Arrays.asList(ids))) {
            return 1;
        }
        else
            return 0;

    }

    @Override
    public int deleteArchiveSignatureById(Long id) {
        return this.baseMapper.deleteById(id);
    }
}