package com.ruoyi.account.service.impl;

import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.ruoyi.account.api.model.TAppUser;
import com.ruoyi.account.api.model.TAppUserWhitelist;
import com.ruoyi.account.api.vo.AppUserWhitelistImportResultVO;
import com.ruoyi.account.mapper.TAppUserWhitelistMapper;
import com.ruoyi.account.service.TAppUserService;
import com.ruoyi.account.service.TAppUserWhitelistSiteService;
import com.ruoyi.chargingPile.api.feignClient.PartnerClient;
import com.ruoyi.chargingPile.api.feignClient.SiteClient;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.security.service.TokenService;
import com.ruoyi.system.api.feignClient.SysUserClient;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.mock.web.MockMultipartFile;
import org.springframework.test.util.ReflectionTestUtils;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionStatus;

import java.io.ByteArrayOutputStream;
import java.util.Collections;
import java.util.concurrent.atomic.AtomicLong;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

@ExtendWith(MockitoExtension.class)
class TAppUserWhitelistServiceImplTest {
    @Mock private TAppUserWhitelistMapper mapper;
    @Mock private TAppUserWhitelistSiteService whitelistSiteService;
    @Mock private TAppUserService appUserService;
    @Mock private SiteClient siteClient;
    @Mock private PartnerClient partnerClient;
    @Mock private TokenService tokenService;
    @Mock private SysUserClient sysUserClient;
    @Mock private PlatformTransactionManager transactionManager;

    private TAppUserWhitelistServiceImpl service;

    @BeforeEach
    void setUp() {
        service = new TAppUserWhitelistServiceImpl();
        ReflectionTestUtils.setField(service, "baseMapper", mapper);
        ReflectionTestUtils.setField(service, "whitelistSiteService", whitelistSiteService);
        ReflectionTestUtils.setField(service, "appUserService", appUserService);
        ReflectionTestUtils.setField(service, "siteClient", siteClient);
        ReflectionTestUtils.setField(service, "partnerClient", partnerClient);
        ReflectionTestUtils.setField(service, "tokenService", tokenService);
        ReflectionTestUtils.setField(service, "sysUserClient", sysUserClient);
        ReflectionTestUtils.setField(service, "transactionManager", transactionManager);
    }

    @Test
    void importsValidRowsAndReturnsOnlyInvalidRows() throws Exception {
        when(siteClient.getSiteAll()).thenReturn(R.ok(Collections.emptyList()));
        when(mapper.selectValidByPhone(any())).thenReturn(null);
        TransactionStatus transactionStatus = mock(TransactionStatus.class);
        when(transactionManager.getTransaction(any())).thenReturn(transactionStatus);
        LambdaQueryChainWrapper<TAppUser> appUserQuery = mock(LambdaQueryChainWrapper.class);
        when(appUserService.lambdaQuery()).thenReturn(appUserQuery);
        when(appUserQuery.eq(any(), any())).thenReturn(appUserQuery);
        when(appUserQuery.last(any())).thenReturn(appUserQuery);
        when(appUserQuery.one()).thenReturn(null);
        AtomicLong ids = new AtomicLong(1L);
        doAnswer(invocation -> {
            TAppUserWhitelist whitelist = invocation.getArgument(0);
            whitelist.setId(ids.getAndIncrement());
            return 1;
        }).when(mapper).insert(any(TAppUserWhitelist.class));

        AppUserWhitelistImportResultVO result = service.importWhitelist(importFile());

        assertEquals(3, result.getTotalCount());
        assertEquals(2, result.getSuccessCount());
        assertEquals(1, result.getErrorCount());
        assertEquals("13540211237", result.getErrorMessage().get(0).getPhone());
        verify(mapper, org.mockito.Mockito.times(2)).insert(any(TAppUserWhitelist.class));
    }

    private MockMultipartFile importFile() throws Exception {
        try (XSSFWorkbook workbook = new XSSFWorkbook(); ByteArrayOutputStream output = new ByteArrayOutputStream()) {
            org.apache.poi.ss.usermodel.Sheet sheet = workbook.createSheet("白名单用户");
            org.apache.poi.ss.usermodel.Row header = sheet.createRow(0);
            header.createCell(0).setCellValue("用户手机号");
            header.createCell(1).setCellValue("享受权益");
            header.createCell(2).setCellValue("白名单电站");
            addRow(sheet, 1, "13540211236", "1", "all");
            addRow(sheet, 2, "13540211238", "2", "all");
            addRow(sheet, 3, "13540211237", "", "all");
            workbook.write(output);
            return new MockMultipartFile("file", "whitelist.xlsx",
                    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", output.toByteArray());
        }
    }

    private void addRow(org.apache.poi.ss.usermodel.Sheet sheet, int index,
                        String phone, String benefitType, String whitelistSite) {
        org.apache.poi.ss.usermodel.Row row = sheet.createRow(index);
        row.createCell(0).setCellValue(phone);
        row.createCell(1).setCellValue(benefitType);
        row.createCell(2).setCellValue(whitelistSite);
    }
}