package com.panzhihua.sangeshenbian.service.impl;

import cn.hutool.core.bean.BeanUtil;
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.panzhihua.common.model.vos.LoginUserInfoVO;
import com.panzhihua.sangeshenbian.model.dto.ComplaintCompletionDTO;
import com.panzhihua.sangeshenbian.model.dto.ComplaintProcessDTO;
import com.panzhihua.sangeshenbian.model.entity.Complaint;
import com.panzhihua.common.exceptions.ServiceException;
import com.panzhihua.sangeshenbian.enums.ReportTypeEnum;
import com.panzhihua.sangeshenbian.model.dto.*;
import com.panzhihua.sangeshenbian.model.entity.*;
import com.panzhihua.sangeshenbian.enums.ProcessStatusEnum;
import com.panzhihua.sangeshenbian.dao.ComplaintMapper;
import com.panzhihua.sangeshenbian.model.entity.ComplaintFlow;
import com.panzhihua.sangeshenbian.model.entity.ComplaintProgress;
import com.panzhihua.sangeshenbian.model.entity.SystemUser;
import com.panzhihua.sangeshenbian.model.query.BasePage;
import com.panzhihua.sangeshenbian.model.query.ComplaintQuery;
import com.panzhihua.sangeshenbian.model.vo.ComplaintTodoVO;
import com.panzhihua.sangeshenbian.service.IComplaintFlowService;
import com.panzhihua.sangeshenbian.service.IComplaintProgressService;
import com.panzhihua.sangeshenbian.service.IComplaintService;
import com.panzhihua.sangeshenbian.model.vo.DispatchVO;
import com.panzhihua.sangeshenbian.service.*;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.panzhihua.sangeshenbian.model.vo.ComplaintVO;
import com.panzhihua.sangeshenbian.service.ISystemUserService;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Optional;

import static cn.hutool.core.util.ObjectUtil.isNull;

/**
 * <p>
 * 问题报告表 服务实现类
 * </p>
 *
 * @author
 * @since 2025-02-22
 */
@Service
@RequiredArgsConstructor(onConstructor_ = {@Lazy})
public class ComplaintServiceImpl extends ServiceImpl<ComplaintMapper, Complaint> implements IComplaintService {
    private final ISystemUserService systemUserService;
    private final IComplaintFlowService complaintFlowService;
    private final IComplaintProgressService complaintProgressService;

    private final IComplaintAuditRecordService complaintAuditRecordService;
    private final IBcRegionService bcRegionService;
    private final IComStreetService comStreetService;
    private final IComActService comActService;

    @Override
    public void saveComplaint(Complaint complaint, Long userId) {
        // 获取当前日期（年月日）
        String datePrefix = new SimpleDateFormat("yyyyMMdd").format(new Date());

        // 查询当前日期的最大流水号
        Complaint lastComplaint = getOne(new LambdaQueryWrapper<Complaint>()
                .likeRight(Complaint::getSerialNumber, datePrefix) // 查询以当前日期开头的流水号
                .orderByDesc(Complaint::getSerialNumber)
                .last("limit 1"));

        String serialNumber;
        if (isNull(lastComplaint)) {
            // 如果当天没有记录，从 0001 开始
            serialNumber = datePrefix + "0001";
        } else {
            // 获取当前日期的最大流水号，并递增
            String lastSerialNumber = lastComplaint.getSerialNumber();
            int num = Integer.parseInt(lastSerialNumber.substring(lastSerialNumber.length() - 4)); // 提取后4位数字
            serialNumber = datePrefix + String.format("%04d", num + 1); // 递增并格式化为4位
        }

        // 设置流水号
        complaint.setSerialNumber(serialNumber);

        // 设置其他字段
        complaint.setStatus(ProcessStatusEnum.PROCESSING.getCode());
        complaint.setCreateTime(new Date(System.currentTimeMillis()));
        complaint.setCreateBy(userId);
        complaint.setUpdateBy(userId);
        complaint.setUpdateTime(new Date(System.currentTimeMillis()));

        // 保存诉求记录
        save(complaint);
    }

    /**
     * @param query
     * @param loginUserInfoVO
     * @return
     */
    @Override
    public Page<ComplaintVO> complaintList(ComplaintQuery query, LoginUserInfoVO loginUserInfoVO) {
        Page<ComplaintVO> page = new Page<>(query.getPageNum(), query.getPageSize());
        //判断当前登录用户级别，查询对应工单
        Optional<SystemUser> systemUserByPhone = systemUserService.getSystemUserByPhone(loginUserInfoVO.getPhone());
        String targetId = "";
        int isSuperior = 0;
        //上级
        if (systemUserByPhone.isPresent()) {
            SystemUser systemUser = systemUserByPhone.get();
            Integer accountLevel = systemUser.getAccountLevel();
            switch (accountLevel) {
                case 1:
                    //市级
                    targetId = "510400";
                    break;
                case 2:
                    //区县级
                    targetId = systemUser.getDistrictsCode();
                    break;
                case 3:
                    //街道
                    targetId = systemUser.getStreetCode();
                    break;
                case 4:
                    //社区
                    targetId = systemUser.getCommunityCode();
                    break;
            }
            isSuperior = 1;
        } else {
        //党员
            targetId = loginUserInfoVO.getUserId().toString();
        }
        //查询对应诉求
        page = baseMapper.selectComplaintPage(page, query, targetId,isSuperior);
        return page;
    }

    /**
     * 工单详情
     * @param id
     * @return
     */
    @Override
    public ComplaintVO detail(Long id) {
        ComplaintVO detail = baseMapper.getDetail(id);
        if (detail.getStatus().equals(0)) {
            List<ComplaintFlow> list = complaintFlowService.lambdaQuery().eq(ComplaintFlow::getComplaintId, id).orderByAsc(ComplaintFlow::getCreateTime).list();
            detail.setComplaintFlows(list);
        }
        //查询办理进度
        List<ComplaintProgress> list = complaintProgressService.lambdaQuery().eq(ComplaintProgress::getComplaintId, id)
                .orderByAsc(ComplaintProgress::getCreateTime).list();
        detail.setComplaintProgresses(list);
        return detail;
    }

    /**
     * 办理进度录入
     *
     * @param dto
     * @param loginUserInfoVO
     */
    @Override
    public void saveProcess(ComplaintProcessDTO dto, LoginUserInfoVO loginUserInfoVO) {
        ComplaintProgress complaintProgress = BeanUtil.copyProperties(dto, ComplaintProgress.class);
        complaintProgress.setCreateTime(new Date());
        complaintProgress.setCreateBy(loginUserInfoVO.getUserId());
        complaintProgress.setCreateByName(loginUserInfoVO.getName());
        complaintProgressService.save(complaintProgress);
    }

    /**
     * 办理结果录入
     *
     * @param dto
     * @param loginUserInfoVO
     */
    @Override
    public void saveResult(ComplaintCompletionDTO dto, LoginUserInfoVO loginUserInfoVO) {
        Complaint complaint = BeanUtil.copyProperties(dto, Complaint.class);
        complaint.setUpdateTime(new Date());
        complaint.setCompletionUserId(loginUserInfoVO.getUserId());
        complaint.setCompletionUsername(loginUserInfoVO.getName());
        complaint.setCompletionTime(new Date());
        this.updateById(complaint);
    }
    /**
     * 办理进度列表
     * @param complaintId
     * @return
     */
    @Override
    public List<ComplaintProgress> progress(Long complaintId) {
        //查询办理进度
        return complaintProgressService.lambdaQuery().eq(ComplaintProgress::getComplaintId, complaintId)
                .orderByAsc(ComplaintProgress::getCreateTime).list();
    }

    @Override
    public void saveReport(ComplaintReportDTO dto, LoginUserInfoVO loginUserInfoVO) {
        String phone = loginUserInfoVO.getPhone();

        SystemUser adminUser = systemUserService.getOne(new LambdaQueryWrapper<SystemUser>()
                .eq(SystemUser::getPhone, phone)
                .eq(SystemUser::getIsAdmin, 1)
                .eq(SystemUser::getStatus, 3)
                .last("LIMIT 1"));

        Long superiorId;
        int reportType;
        if (adminUser == null) {
            superiorId = loginUserInfoVO.getCommunityId();
            reportType = ReportTypeEnum.COMMUNITY.getCode();
        } else {
            int accountLevel = adminUser.getAccountLevel(); // 改为基本类型
            if (accountLevel == 1) {
                throw new ServiceException("市级账号,无法上报！");
            }
            reportType = accountLevel + 1;

            // 使用基本类型比较并补充默认分支
            if (accountLevel == ReportTypeEnum.COMMUNITY.getCode()) {
                superiorId = Long.parseLong(adminUser.getStreetCode());
            } else if (accountLevel == ReportTypeEnum.STREET.getCode()) {
                superiorId = Long.parseLong(adminUser.getDistrictsCode());
            } else if (accountLevel == ReportTypeEnum.DISTRICT.getCode()) {
                superiorId = 510400L; // 攀枝花市
            } else {
                // 处理未预期的账号等级
                throw new ServiceException("未知的账号等级");
            }
        }

        Complaint complaint = getById(dto.getComplaintId());
        complaint.setReportType(reportType);
        complaint.setSuperiorId(superiorId);
        updateById(complaint);

        // 标记最新
        complaintAuditRecordService.update(new LambdaUpdateWrapper<ComplaintAuditRecord>()
                .eq(ComplaintAuditRecord::getComplaintId, dto.getComplaintId())
                .set(ComplaintAuditRecord::getLatestFlag,false));

        // 添加审核记录
        complaintAuditRecordService.createComplaintAuditRecord(dto.getComplaintId(), 2, dto.getComment(), loginUserInfoVO.getUserId());
    }

    @Override
    public void saveDispatch(ComplaintDispatch dto, LoginUserInfoVO loginUserInfoVO) {
        String phone = loginUserInfoVO.getPhone();
        SystemUser adminUser = systemUserService.getOne(new LambdaQueryWrapper<SystemUser>()
                .eq(SystemUser::getPhone, phone)
                .eq(SystemUser::getIsAdmin, 1)
                .eq(SystemUser::getStatus, 3)
                .last("LIMIT 1"));

        if (adminUser == null) {
            throw new ServiceException("无权下派");
        }

        long superiorId;
        int reportType;
        int accountLevel = adminUser.getAccountLevel(); // 改为基本类型
        if (accountLevel == 1) {
            throw new ServiceException("市级账号,无法上报！");
        }
        reportType = accountLevel - 1;

        // 使用基本类型比较并补充默认分支
        if (accountLevel == ReportTypeEnum.STREET.getCode()) {
            superiorId = Long.parseLong(adminUser.getCommunityCode());
        } else if (accountLevel == ReportTypeEnum.DISTRICT.getCode()) {
            superiorId = Long.parseLong(adminUser.getStreetCode());
        } else if (accountLevel == ReportTypeEnum.CITY.getCode()) {
            superiorId = Long.parseLong(adminUser.getDistrictsCode());
        } else {
            // 处理未预期的账号等级
            throw new ServiceException("未知的账号等级");
        }

        Complaint complaint = getById(dto.getComplaintId());
        complaint.setReportType(reportType);
        complaint.setSuperiorId(superiorId);
        updateById(complaint);

        // 添加流转记录
        complaintFlowService.createFlow(dto.getComplaintId(), 1, loginUserInfoVO.getUserId());
    }

    @Override
    public void reportAudit(ComplaintReporAuditDTO complaintReporAuditDTO, LoginUserInfoVO loginUserInfoVO) {
        complaintAuditRecordService.audit(complaintReporAuditDTO.getId(), loginUserInfoVO.getUserId(),
                complaintReporAuditDTO.getAuditResult(), complaintReporAuditDTO.getRejectReason());

        // 添加流转记录
        ComplaintAuditRecord complaintAuditRecord = complaintAuditRecordService.getById(complaintReporAuditDTO.getId());
        complaintFlowService.createFlow(complaintAuditRecord.getComplaintId(), 0, loginUserInfoVO.getUserId());
    }


    @Override
    public void saveDelay(ComplaintDelayDTO dto, LoginUserInfoVO loginUserInfoVO) {
        // 标记最新
        complaintAuditRecordService.update(new LambdaUpdateWrapper<ComplaintAuditRecord>()
                .eq(ComplaintAuditRecord::getComplaintId, dto.getComplaintId())
                .set(ComplaintAuditRecord::getLatestFlag,false));
        // 添加审核记录
        complaintAuditRecordService.createComplaintAuditRecord(dto.getComplaintId(), 1, dto.getComment(), loginUserInfoVO.getUserId());
    }


    @Override
    public void delayAudit(ComplaintDelayAuditDTO complaintDelayAuditDTO, LoginUserInfoVO loginUserInfoVO) {
        complaintAuditRecordService.audit(complaintDelayAuditDTO.getId(), loginUserInfoVO.getUserId(),
                complaintDelayAuditDTO.getAuditResult(), complaintDelayAuditDTO.getRejectReason());
    }

    @Override
    public List<DispatchVO> getDispatchList(LoginUserInfoVO loginUserInfoVO) {

        String phone = loginUserInfoVO.getPhone();
        SystemUser adminUser = systemUserService.getOne(new LambdaQueryWrapper<SystemUser>()
                .eq(SystemUser::getPhone, phone)
                .eq(SystemUser::getIsAdmin, 1)
                .eq(SystemUser::getStatus, 3)
                .last("LIMIT 1"));

        if (adminUser == null) {
            throw new ServiceException("无权下派");
        }
        int accountLevel = adminUser.getAccountLevel(); // 改为基本类型
        if (accountLevel == 1) {
            throw new ServiceException("市级账号,无法上报！");
        }

        // 使用基本类型比较并补充默认分支
        List<DispatchVO> dispatchVOList = new ArrayList<>();
        if (accountLevel == ReportTypeEnum.STREET.getCode()) {
            List<ComAct> list = comActService.list();
            for (ComAct comAct : list) {
                DispatchVO dispatchVO = new DispatchVO();
                dispatchVO.setId(comAct.getCommunityId());
                dispatchVO.setName(comAct.getName());
                dispatchVOList.add(dispatchVO);
            }
        } else if (accountLevel == ReportTypeEnum.DISTRICT.getCode()) {
            List<ComStreet> list = comStreetService.list();
            for (ComStreet street : list) {
                DispatchVO dispatchVO = new DispatchVO();
                dispatchVO.setId(Long.valueOf(street.getStreetId()));
                dispatchVO.setName(street.getName());
                dispatchVOList.add(dispatchVO);
            }
        } else if (accountLevel == ReportTypeEnum.CITY.getCode()) {
            List<BcRegion> list = bcRegionService.list(new LambdaQueryWrapper<BcRegion>()
                    .eq(BcRegion::getHierarchyOrder, 3));
            for (BcRegion region : list) {
                DispatchVO dispatchVO = new DispatchVO();
                dispatchVO.setId(Long.valueOf(region.getRegionCode()));
                dispatchVO.setName(region.getRegionName());
                dispatchVOList.add(dispatchVO);
            }
        } else {
            // 处理未预期的账号等级
            throw new ServiceException("未知的账号等级");
        }
        return dispatchVOList;
    }
    /**
     * 获取待办诉求
     * @param basePage
     * @param loginUserInfo
     * @return
     */
    @Override
    public Page<ComplaintTodoVO> getTodoList(BasePage basePage, LoginUserInfoVO loginUserInfo) {
        Optional<SystemUser> systemUserByPhone = systemUserService.getSystemUserByPhone(loginUserInfo.getPhone());
        String targetId = "";
        int isSuperior = 0;
        //上级
        if (systemUserByPhone.isPresent()) {
            SystemUser systemUser = systemUserByPhone.get();
            Integer accountLevel = systemUser.getAccountLevel();
            switch (accountLevel) {
                case 1:
                    //市级
                    targetId = "510400";
                    break;
                case 2:
                    //区县级
                    targetId = systemUser.getDistrictsCode();
                    break;
                case 3:
                    //街道
                    targetId = systemUser.getStreetCode();
                    break;
                case 4:
                    //社区
                    targetId = systemUser.getCommunityCode();
                    break;
            }
            isSuperior = 1;
        } else {
            //党员
            targetId = loginUserInfo.getUserId().toString();
        }
        Page<ComplaintTodoVO> page = baseMapper.getTodoList(new Page<>(basePage.getPageNum(), basePage.getPageSize()), targetId,isSuperior);
        return page;
    }
    /**
     * 延期情况说明
     * @param complaintId
     * @return
     */
    @Override
    public ComplaintAuditRecord delayDetail(Long complaintId) {
        return complaintAuditRecordService.lambdaQuery().eq(ComplaintAuditRecord::getComplaintId, complaintId)
                .eq(ComplaintAuditRecord::getAuditType, 1)
                .eq(ComplaintAuditRecord::getLatestFlag, true)
                .last("LIMIT 1").one();
    }
}