package com.panzhihua.sangeshenbian.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.StrUtil;
import cn.idev.excel.EasyExcel;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.panzhihua.common.exceptions.ServiceException;
import com.panzhihua.common.model.vos.LoginUserInfoVO;
import com.panzhihua.common.model.vos.sangeshenbian.SystemUserVo;
import com.panzhihua.common.redis.RedisUtils;
import com.panzhihua.sangeshenbian.dao.PartyMemberMapper;
import com.panzhihua.sangeshenbian.enums.AuditStatusEnum;
import com.panzhihua.sangeshenbian.enums.FreezeStatusEnum;
import com.panzhihua.sangeshenbian.enums.ReportTypeEnum;
import com.panzhihua.sangeshenbian.model.entity.*;
import com.panzhihua.sangeshenbian.model.excel.PartyMemberExcel;
import com.panzhihua.sangeshenbian.model.excel.PartyMemberTemplate;
import com.panzhihua.sangeshenbian.service.*;
import com.panzhihua.sangeshenbian.warpper.*;
import lombok.RequiredArgsConstructor;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.net.URLEncoder;
import java.util.*;

/**
 * <p>
 * 党员 服务实现类
 * </p>
 *
 * @author mitao
 * @since 2025-03-13
 */
@Service
@RequiredArgsConstructor(onConstructor_ = {@Lazy})
public class PartyMemberServiceImpl extends ServiceImpl<PartyMemberMapper, PartyMember> implements IPartyMemberService {
    private final HttpServletResponse response;
    private final ISystemUserService systemUserService;
    private final IBcRegionService bcRegionService;
    private final IComStreetService comStreetService;
    private final IComActService comActService;
    private final RedisUtils redisUtils;
    /**
     * 党员分页查询列表
     *
     * @param query
     * @param loginUserInfo
     * @return
     */
    @Override
    public Page<PartyMember> pageList(PartyMemberQuery query, SystemUserVo loginUserInfo) {
        SystemUser user = systemUserService.getById(loginUserInfo.getId());
        if (Objects.isNull(user)){
            throw new ServiceException("用户不存在");
        }
        loginUserInfo.setAccountLevel(user.getAccountLevel());
        loginUserInfo.setDistrictsCode(user.getDistrictsCode());
        loginUserInfo.setStreetId(user.getStreetId());
        loginUserInfo.setCommunityId(user.getCommunityId());
        return  baseMapper.pageList(new Page<>(query.getPageNum(), query.getPageSize()),query,loginUserInfo);
    }
    /**
     * 添加党员
     * @param dto
     * @param loginUserInfo
     */
    @Override
    public void save(PartyMemberDTO dto, SystemUserVo loginUserInfo) {
        PartyMember partyMember = BeanUtil.copyProperties(dto, PartyMember.class);
        String idNumber = dto.getIdNumber();
        partyMember.setGender(getGender(idNumber));
        BcRegion districtByCode = bcRegionService.getDistrictByCode(dto.getDistrictsCode());
        if (Objects.nonNull(districtByCode)){
            partyMember.setDistricts(districtByCode.getRegionName());
        }
        ComStreet street = comStreetService.getById(dto.getStreetId());
        if (Objects.nonNull(street)){
            partyMember.setStreet(street.getName());
        }
        ComAct act = comActService.getById(dto.getCommunityId());
        if (Objects.nonNull(act)){
            partyMember.setCommunity(act.getName());
        }
        if (Objects.isNull(dto.getId())) {
            //添加
            partyMember.setCreateBy(Long.parseLong(loginUserInfo.getId().toString()));
            partyMember.setAuditStatus(AuditStatusEnum.APPROVED.getCode());
            partyMember.setFreezeStatus(FreezeStatusEnum.NORMAL.getCode());
            partyMember.setSource(1);
            save(partyMember);
        } else {
            partyMember.setIsConfirm(0);
            partyMember.setUpdateBy(Long.parseLong(loginUserInfo.getId().toString()));
            updateById(partyMember);
        }
    }
    /**
     * 冻结/解冻
     * @param id
     * @param loginUserInfo
     */
    @Override
    public PartyMember freeze(Long id, SystemUserVo loginUserInfo) {
        PartyMember partyMember = getById(id);
        partyMember.setFreezeStatus(partyMember.getFreezeStatus() == 1 ? 0 : 1);
        partyMember.setUpdateBy(Long.parseLong(loginUserInfo.getId().toString()));
        updateById(partyMember);
        return partyMember;
    }

    @Override
    public void download() throws IOException {
        response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
        response.setCharacterEncoding("utf-8");
        String fileName = URLEncoder.encode("党员导入模板", "UTF-8").replaceAll("\\+", "%20");
        response.setHeader("Content-disposition", "attachment;filename*=utf-8''" + fileName + ".xlsx");
        EasyExcel.write(response.getOutputStream(), PartyMemberTemplate.class)
                .sheet("党员导入模板")
                .doWrite(Collections.emptyList());
    }

    /**
     * 导出
     * @param query
     * @param loginUserInfo
     */
    @Override
    public void export(PartyMemberQuery query, SystemUserVo loginUserInfo) throws IOException {
        SystemUser user = systemUserService.getById(loginUserInfo.getId());
        if (Objects.isNull(user)){
            throw new ServiceException("用户不存在");
        }
        loginUserInfo.setAccountLevel(user.getAccountLevel());
        loginUserInfo.setDistrictsCode(user.getDistrictsCode());
        loginUserInfo.setStreetId(user.getStreetId());
        loginUserInfo.setCommunityId(user.getCommunityId());
        List<PartyMember> list = baseMapper.queryList(query,loginUserInfo);
        List<PartyMemberExcel> partyMemberExcels = BeanUtil.copyToList(list, PartyMemberExcel.class);
        response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
        response.setCharacterEncoding("utf-8");
        String fileName = URLEncoder.encode("党员数据", "UTF-8").replaceAll("\\+", "%20");
        response.setHeader("Content-disposition", "attachment;filename*=utf-8''" + fileName + ".xlsx");
        EasyExcel.write(response.getOutputStream(), PartyMemberExcel.class)
                .sheet("党员数据")
                .doWrite(partyMemberExcels);
    }

    /**
     * @param file
     * @param loginUserInfo
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public List<PartyMemberImportFailedVO> importExcel(MultipartFile file, SystemUserVo loginUserInfo) throws IOException {
        // 使用 FastExcel 同步读取 Excel 数据为对象列表
        List<PartyMemberTemplate> list = EasyExcel.read(file.getInputStream()).head(PartyMemberTemplate.class).headRowNumber(2).sheet().doReadSync();
        if (CollUtil.isEmpty(list)) {
            throw new ServiceException("导入数据为空");
        }

        // 存储验证失败的记录
        List<PartyMemberImportFailedVO> failedList = new ArrayList<>();
        // 存储验证成功的记录
        List<PartyMember> validPartyMembers = new ArrayList<>();

        // 手机号正则表达式
        String phoneRegex = "^1[3-9]\\d{9}$";
        // 身份证号正则表达式
        String idCardRegex = "(^\\d{15}$)|(^\\d{18}$)|(^\\d{17}(\\d|X|x)$)";

        // 批量验证数据
        for (PartyMemberTemplate template : list) {
            PartyMemberImportFailedVO failedVO = new PartyMemberImportFailedVO();
            boolean isValid = true;
            StringBuilder errorMsg = new StringBuilder();

            // 复制数据到失败记录对象
            BeanUtil.copyProperties(template, failedVO);

            // 1. 验证手机号
            if (StrUtil.isBlank(template.getPhone()) || !template.getPhone().matches(phoneRegex)) {
                isValid = false;
                errorMsg.append("手机号格式不正确; ");
            }

            // 2. 验证身份证号
            if (StrUtil.isBlank(template.getIdNumber()) || !template.getIdNumber().matches(idCardRegex)) {
                isValid = false;
                errorMsg.append("身份证号格式不正确; ");
            }

            // 3. 验证账号是否已存在
            if (StrUtil.isNotBlank(template.getPhone())) {
                LambdaQueryWrapper<PartyMember> queryWrapper = new LambdaQueryWrapper<>();
                queryWrapper.eq(PartyMember::getPhone, template.getPhone());
                long count = count(queryWrapper);
                if (count > 0) {
                    isValid = false;
                    errorMsg.append("账号已存在");
                }
            }

            // 4. 验证所在社区
            String districtName = null;
            String streetName = null;
            String communityName = null;
            String districtCode = "";
            String streetId = "";
            Long communityId = null;

            if (StrUtil.isNotBlank(template.getCommunity())) {
                String[] addressParts = template.getCommunity().split("-");
                if (addressParts.length != 3) {
                    isValid = false;
                    errorMsg.append("社区格式不正确，应为'区县-街道-社区'; ");
                } else {
                    districtName = addressParts[0];
                    streetName = addressParts[1];
                    communityName = addressParts[2];

                    // 验证区县、街道、社区信息

                    // 验证区县是否存在
                    BcRegion district = bcRegionService.getDistrictByName(districtName);

                    if (Objects.isNull(district)) {
                        isValid = false;
                        errorMsg.append("区县不存在; ");
                    } else {
                        // 验证街道是否存在且属于该区县
                        ComStreet comStreet =  comStreetService.getStreetByNameAndDistrict(streetName, district.getRegionCode());
                        districtCode = district.getRegionCode();
                        if (Objects.isNull(comStreet)) {
                            isValid = false;
                            errorMsg.append("街道不存在或不属于所选区县; ");
                        } else {
                            // 验证社区是否存在且属于该街道
                            // 实际代码应该是调用相应的Service查询社区信息
                            ComAct comAct = comActService.getCommunityByNameAndStreet(communityName, comStreet.getStreetId());
                            if (Objects.isNull(comAct)) {
                                isValid = false;
                                errorMsg.append("社区不存在或不属于所选街道; ");
                            } else {
                                streetId = comStreet.getStreetId();
                                communityId = comAct.getCommunityId();
                            }
                        }
                    }
                }
            } else {
                isValid = false;
                errorMsg.append("社区信息不能为空; ");
            }

            // 如果验证失败，添加到失败列表，否则添加到成功列表
            if (!isValid) {
                failedVO.setFailReason(errorMsg.toString());
                failedList.add(failedVO);
            } else {
                PartyMember partyMember = new PartyMember();
                BeanUtil.copyProperties(template, partyMember);

                // 设置创建人和更新人
                partyMember.setCreateBy(Long.parseLong(loginUserInfo.getId().toString()));
                partyMember.setUpdateBy(Long.parseLong(loginUserInfo.getId().toString()));
                //导入党员默认审核通过
                partyMember.setAuditStatus(AuditStatusEnum.APPROVED.getCode());
                partyMember.setSource(1);//管理后台录入
                //默认头像
                partyMember.setAvatar("https://www.psciio.com//idcard/f15c91f940624ed59537ecced1059f18.jpg");
                // 根据身份证号设置性别
                if (StrUtil.isNotBlank(template.getIdNumber())) {
                    partyMember.setGender(getGender(template.getIdNumber()));
                }

                // 然后设置到partyMember对象中
                 partyMember.setDistricts(districtName);
                 partyMember.setDistrictsCode(districtCode);
                 partyMember.setStreet(streetName);
                 partyMember.setStreetId(streetId);
                 partyMember.setCommunity(communityName);
                 partyMember.setCommunityId(communityId);

                validPartyMembers.add(partyMember);
            }
        }

        // 处理验证成功的数据
        if (!validPartyMembers.isEmpty()) {
            // 批量保存
            saveBatch(validPartyMembers);
        }

        // 返回验证失败的数据
        return failedList;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void applyForMembership(PartyMemberApplicationRequest dto, LoginUserInfoVO loginUserInfo) {
        PartyMember partyMember = BeanUtil.copyProperties(dto, PartyMember.class);
        String idNumber = dto.getIdNumber();
        partyMember.setPhone(loginUserInfo.getPhone());
        partyMember.setGender(getGender(idNumber));
        partyMember.setCreateBy(loginUserInfo.getUserId());
        partyMember.setUpdateBy(loginUserInfo.getUserId());
        partyMember.setAuditStatus(AuditStatusEnum.PENDING.getCode());
        partyMember.setCreateTime(DateUtil.date());
        partyMember.setUpdateTime(DateUtil.date());
        partyMember.setSource(0);
        saveOrUpdate(partyMember);
    }


    /**
     * 审核
     *
     * @param dto
     * @param loginUserInfo
     */
    @Override
    public PartyMember audit(PartyMemberDTO dto, SystemUserVo loginUserInfo) {
        PartyMember partyMember = BeanUtil.copyProperties(dto, PartyMember.class);
        partyMember.setUpdateBy(Long.parseLong(loginUserInfo.getId().toString()));
        updateById(partyMember);
        return this.getById(dto.getId());
    }

    @Override
    public Page<PendingPartyMemberApplicationVO> preAuditList(Page<PendingPartyMemberApplicationVO> page,
                                                              LoginUserInfoVO loginUserInfo) {
        SystemUser adminUser = systemUserService.getOne(new LambdaQueryWrapper<SystemUser>()
                .eq(SystemUser::getPhone, loginUserInfo.getPhone())
                .eq(SystemUser::getIsAdmin, 1)
                .ne(SystemUser::getStatus, 3)
                .ne(SystemUser::getAccountLevel, 5)
                .last("LIMIT 1"));



        if (adminUser == null){
            throw new ServiceException("无权审核");
        }

        Integer identity = (Integer) redisUtils.get("identity:" + loginUserInfo.getPhone());
        if(identity != null && identity != 2){
            throw new ServiceException("请切换至管理员身份");
        }

        int accountLevel = adminUser.getAccountLevel();
        Long communityId = null;
        String streetId = null;
        String districtsCode = null;
        if (accountLevel == ReportTypeEnum.COMMUNITY.getCode()) {
            communityId = adminUser.getCommunityId();
        } else if (accountLevel == ReportTypeEnum.STREET.getCode()) {
            streetId = adminUser.getStreetId();
        } else if (accountLevel == ReportTypeEnum.DISTRICT.getCode()) {
            districtsCode = adminUser.getDistrictsCode();
        } else if(accountLevel != ReportTypeEnum.CITY.getCode()){
            throw new ServiceException("无权审核:未知等级");
        }
        String phone = loginUserInfo.getPhone();
        return this.baseMapper.queryPreAuditPage(page, phone, accountLevel, districtsCode, streetId, communityId);
    }

    /**
     * 根据身份证号获取性别
     * @param idNumber
     * @return
     */
    public static Integer getGender(String idNumber) {
        char genderChar = idNumber.charAt(16);
        int genderDigit = Character.getNumericValue(genderChar);
        return (genderDigit % 2 == 0) ? 0 : 1;
    }


    /**
     * 根据电话号码查询有效的党员数据
     * @param phone
     * @return
     */
    @Override
	public PartyMember getPartyMemberByPhone(String phone) {
        PartyMember one = this.getOne(new LambdaQueryWrapper<PartyMember>().eq(PartyMember::getPhone, phone)
                .eq(PartyMember::getAuditStatus, 1).eq(PartyMember::getFreezeStatus, 0).eq(PartyMember::getDelFlag, 0));
		return one;
	}

    @Override
    public Boolean verifyPartyMemberByPhone(String phone) {
        Optional<PartyMember> partyMember = this.lambdaQuery().eq(PartyMember::getPhone, phone).oneOpt();
        return partyMember.isPresent();
    }
}