package com.ruoyi.user.service.impl;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import com.ruoyi.common.core.exception.ServiceException;
import com.ruoyi.user.domain.AccountCertificationApply;
import com.ruoyi.user.domain.AccountUser;
import com.ruoyi.user.domain.dto.CompanyCertificationApplyDto;
import com.ruoyi.user.domain.vo.AccountCertificationStatusVo;
import com.ruoyi.user.domain.vo.CompanyCertificationStatusVo;
import com.ruoyi.user.mapper.AccountCertificationApplyMapper;
import com.ruoyi.user.mapper.AccountCertificationMapper;
import com.ruoyi.user.mapper.AccountUserMapper;

/**
 * 会员主体认证申请 服务单元测试
 *
 * 覆盖 C 端个人主体认证提交：正常提交（落待审核申请 + 联动认证状态为审核中）、
 * 待审核申请存在时防重拒绝、以及会员ID/姓名/身份证号缺失时的入参校验；
 * 另覆盖认证状态查询：有申请时回填资料与驳回原因、无申请/无登录态时返回空对象。
 *
 * @author hugray
 */
@ExtendWith(MockitoExtension.class)
class AccountCertificationApplyServiceImplTest
{
    private static final Long USER_ID = 66L;

    private static final String REAL_NAME = "张三";

    private static final String ID_CARD = "110101199003071234";

    @Mock
    private AccountCertificationApplyMapper certificationApplyMapper;

    @Mock
    private AccountCertificationMapper certificationMapper;

    @Mock
    private AccountUserMapper accountUserMapper;

    @InjectMocks
    private AccountCertificationApplyServiceImpl certificationApplyService;

    @Test
    @DisplayName("正常提交应落一条待审核的个人申请并把认证状态置为审核中")
    void submitPersonalCertification_shouldInsertPendingApplyAndSetAuditing()
    {
        when(certificationApplyMapper.countPendingPersonalApplyByUserId(USER_ID)).thenReturn(0);
        when(certificationApplyMapper.insertCertificationApply(any(AccountCertificationApply.class))).thenReturn(1);

        certificationApplyService.submitPersonalCertification(USER_ID, "  张三  ", "11010119900307123x");

        // 申请快照：个人主体、待审核、姓名去空白、身份证号末位小写 x 统一转大写
        ArgumentCaptor<AccountCertificationApply> applyCaptor = ArgumentCaptor.forClass(AccountCertificationApply.class);
        verify(certificationApplyMapper).insertCertificationApply(applyCaptor.capture());
        AccountCertificationApply saved = applyCaptor.getValue();
        assertEquals(USER_ID, saved.getUserId());
        assertEquals("1", saved.getSubjectType());
        assertEquals("0", saved.getAuditStatus());
        assertEquals(REAL_NAME, saved.getRealName());
        assertEquals("11010119900307123X", saved.getIdCard());

        // 状态联动：account_user.auth_status = '1'（审核中）
        ArgumentCaptor<AccountUser> userCaptor = ArgumentCaptor.forClass(AccountUser.class);
        verify(accountUserMapper).updateUserAuthStatus(userCaptor.capture());
        assertEquals(USER_ID, userCaptor.getValue().getUserId());
        assertEquals("1", userCaptor.getValue().getAuthStatus());
    }

    @Test
    @DisplayName("已有待审核申请时应拒绝重复提交且不落库")
    void submitPersonalCertification_shouldThrow_whenPendingApplyExists()
    {
        when(certificationApplyMapper.countPendingPersonalApplyByUserId(USER_ID)).thenReturn(1);

        ServiceException ex = assertThrows(ServiceException.class,
            () -> certificationApplyService.submitPersonalCertification(USER_ID, REAL_NAME, ID_CARD));

        assertEquals("已有实名认证申请正在审核中，请勿重复提交", ex.getMessage());
        verify(certificationApplyMapper, never()).insertCertificationApply(any(AccountCertificationApply.class));
    }

    @Test
    @DisplayName("会员ID为空时应抛出提交失败")
    void submitPersonalCertification_shouldThrow_whenUserIdNull()
    {
        ServiceException ex = assertThrows(ServiceException.class,
            () -> certificationApplyService.submitPersonalCertification(null, REAL_NAME, ID_CARD));

        assertEquals("提交实名认证失败", ex.getMessage());
        verify(certificationApplyMapper, never()).insertCertificationApply(any(AccountCertificationApply.class));
    }

    @Test
    @DisplayName("姓名为空时应抛出提示且不落库")
    void submitPersonalCertification_shouldThrow_whenRealNameBlank()
    {
        ServiceException ex = assertThrows(ServiceException.class,
            () -> certificationApplyService.submitPersonalCertification(USER_ID, "", ID_CARD));

        assertEquals("姓名与身份证号不能为空", ex.getMessage());
        verify(certificationApplyMapper, never()).insertCertificationApply(any(AccountCertificationApply.class));
    }

    @Test
    @DisplayName("身份证号为空时应抛出提示且不落库")
    void submitPersonalCertification_shouldThrow_whenIdCardBlank()
    {
        ServiceException ex = assertThrows(ServiceException.class,
            () -> certificationApplyService.submitPersonalCertification(USER_ID, REAL_NAME, null));

        assertEquals("姓名与身份证号不能为空", ex.getMessage());
        verify(certificationApplyMapper, never()).insertCertificationApply(any(AccountCertificationApply.class));
    }

    @Test
    @DisplayName("查询认证状态应回填最近一次申请的资料与驳回原因")
    void getCertificationStatus_shouldFillFromLatestApply()
    {
        AccountCertificationApply apply = new AccountCertificationApply();
        apply.setRealName(REAL_NAME);
        apply.setIdCard(ID_CARD);
        apply.setAuditStatus("2");
        apply.setAuditRemark("身份证照片不清晰，请重新提交");
        when(certificationApplyMapper.selectLatestPersonalApplyByUserId(USER_ID)).thenReturn(apply);

        AccountCertificationStatusVo vo = certificationApplyService.getCertificationStatus(USER_ID);

        assertEquals(REAL_NAME, vo.getRealName());
        assertEquals(ID_CARD, vo.getIdCard());
        assertEquals("2", vo.getAuditStatus());
        assertEquals("身份证照片不清晰，请重新提交", vo.getAuditRemark());
    }

    @Test
    @DisplayName("从未提交时查询认证状态应返回空对象而非 null")
    void getCertificationStatus_shouldReturnEmpty_whenNoApply()
    {
        when(certificationApplyMapper.selectLatestPersonalApplyByUserId(USER_ID)).thenReturn(null);

        AccountCertificationStatusVo vo = certificationApplyService.getCertificationStatus(USER_ID);

        assertNull(vo.getRealName());
        assertNull(vo.getIdCard());
        assertNull(vo.getAuditStatus());
        assertNull(vo.getAuditRemark());
    }

    @Test
    @DisplayName("会员ID为空时查询认证状态应返回空对象且不查库")
    void getCertificationStatus_shouldReturnEmpty_whenUserIdNull()
    {
        AccountCertificationStatusVo vo = certificationApplyService.getCertificationStatus(null);

        assertNull(vo.getAuditStatus());
        verify(certificationApplyMapper, never()).selectLatestPersonalApplyByUserId(any());
    }

    @Test
    @DisplayName("正常提交应落一条待审核的企业申请并把企业认证状态置为审核中")
    void submitCompanyCertification_shouldInsertPendingApplyAndSetCompanyAuditing()
    {
        when(certificationApplyMapper.countPendingCompanyApplyByUserId(USER_ID)).thenReturn(0);
        when(certificationApplyMapper.insertCertificationApply(any(AccountCertificationApply.class))).thenReturn(1);

        certificationApplyService.submitCompanyCertification(USER_ID, buildCompanyDto("3", "1", null));

        // 申请快照：企业主体(3)、待审核、无有效期（长期）
        ArgumentCaptor<AccountCertificationApply> applyCaptor = ArgumentCaptor.forClass(AccountCertificationApply.class);
        verify(certificationApplyMapper).insertCertificationApply(applyCaptor.capture());
        AccountCertificationApply saved = applyCaptor.getValue();
        assertEquals(USER_ID, saved.getUserId());
        assertEquals("3", saved.getSubjectType());
        assertEquals("0", saved.getAuditStatus());
        assertEquals("测试企业有限公司", saved.getCompanyName());

        // 状态联动：account_user.company_auth_status = '1'（审核中），且不动个人 auth_status
        ArgumentCaptor<AccountUser> userCaptor = ArgumentCaptor.forClass(AccountUser.class);
        verify(accountUserMapper).updateUserCompanyAuthStatus(userCaptor.capture());
        assertEquals("1", userCaptor.getValue().getCompanyAuthStatus());
        verify(accountUserMapper, never()).updateUserAuthStatus(any(AccountUser.class));
    }

    @Test
    @DisplayName("有效期选「短期」但未填起止日期时应抛出提示且不落库")
    void submitCompanyCertification_shouldThrow_whenShortTermPeriodMissing()
    {
        ServiceException ex = assertThrows(ServiceException.class,
            () -> certificationApplyService.submitCompanyCertification(USER_ID, buildCompanyDto("3", "2", null)));

        assertEquals("请选择营业执照有效期起止日期", ex.getMessage());
        verify(certificationApplyMapper, never()).insertCertificationApply(any(AccountCertificationApply.class));
    }

    @Test
    @DisplayName("已有待审核的企业申请时应拒绝重复提交且不落库")
    void submitCompanyCertification_shouldThrow_whenPendingApplyExists()
    {
        when(certificationApplyMapper.countPendingCompanyApplyByUserId(USER_ID)).thenReturn(1);

        ServiceException ex = assertThrows(ServiceException.class,
            () -> certificationApplyService.submitCompanyCertification(USER_ID, buildCompanyDto("2", "1", null)));

        assertEquals("已有企业认证申请正在审核中，请勿重复提交", ex.getMessage());
        verify(certificationApplyMapper, never()).insertCertificationApply(any(AccountCertificationApply.class));
    }

    @Test
    @DisplayName("会员ID为空时提交企业认证应抛出提交失败")
    void submitCompanyCertification_shouldThrow_whenUserIdNull()
    {
        ServiceException ex = assertThrows(ServiceException.class,
            () -> certificationApplyService.submitCompanyCertification(null, buildCompanyDto("3", "1", null)));

        assertEquals("提交企业认证失败", ex.getMessage());
        verify(certificationApplyMapper, never()).insertCertificationApply(any(AccountCertificationApply.class));
    }

    @Test
    @DisplayName("查询企业认证状态应回填最近一次申请的资料与驳回原因")
    void getCompanyCertificationStatus_shouldFillFromLatestApply()
    {
        AccountCertificationApply apply = new AccountCertificationApply();
        apply.setSubjectType("3");
        apply.setCompanyName("测试企业有限公司");
        apply.setAuditStatus("2");
        apply.setAuditRemark("营业执照照片不清晰，请重新提交");
        when(certificationApplyMapper.selectLatestCompanyApplyByUserId(USER_ID)).thenReturn(apply);

        CompanyCertificationStatusVo vo = certificationApplyService.getCompanyCertificationStatus(USER_ID);

        assertEquals("3", vo.getSubjectType());
        assertEquals("测试企业有限公司", vo.getCompanyName());
        assertEquals("2", vo.getAuditStatus());
        assertEquals("营业执照照片不清晰，请重新提交", vo.getAuditRemark());
    }

    @Test
    @DisplayName("从未提交企业认证时查询状态应返回空对象而非 null")
    void getCompanyCertificationStatus_shouldReturnEmpty_whenNoApply()
    {
        when(certificationApplyMapper.selectLatestCompanyApplyByUserId(USER_ID)).thenReturn(null);

        CompanyCertificationStatusVo vo = certificationApplyService.getCompanyCertificationStatus(USER_ID);

        assertNull(vo.getCompanyName());
        assertNull(vo.getAuditStatus());
        assertNull(vo.getAuditRemark());
    }

    /** 构造一份字段齐全的企业认证入参：validType 控制营业执照有效期类型，licensePeriod 为起止日期 */
    private CompanyCertificationApplyDto buildCompanyDto(String subjectType, String validType, String licensePeriod)
    {
        CompanyCertificationApplyDto dto = new CompanyCertificationApplyDto();
        dto.setSubjectType(subjectType);
        dto.setCompanyName("测试企业有限公司");
        dto.setLicenseImage("/upload/license.png");
        dto.setCreditCode("91310000MA1FL0XXXX");
        dto.setLicenseValidType(validType);
        dto.setLicenseValidPeriod(licensePeriod);
        dto.setRegisteredRegion("上海市 上海市 浦东新区");
        dto.setCompanyAddress("浦东新区世纪大道 1 号");
        dto.setLegalPerson("李四");
        dto.setLegalIdCardFront("/upload/id-front.png");
        dto.setLegalIdCardBack("/upload/id-back.png");
        dto.setLegalIdValidType("1");
        dto.setLegalIdValidPeriod(null);
        dto.setLegalIdAddress("浦东新区世纪大道 1 号");
        dto.setContactName("王五");
        dto.setContactPhone("13800000000");
        dto.setContactEmail("test@example.com");
        dto.setPayeeType("1");
        dto.setBankCardImage("/upload/bank.png");
        dto.setBankCardNo("6222020000000000000");
        dto.setBankCity("上海市");
        return dto;
    }
}