package com.rongyichuang.user;

import com.rongyichuang.user.entity.User;
import com.rongyichuang.user.service.UserService;
import com.rongyichuang.user.repository.UserRepository;
import com.rongyichuang.employee.entity.Employee;
import com.rongyichuang.employee.repository.EmployeeRepository;
import com.rongyichuang.judge.entity.Judge;
import com.rongyichuang.judge.repository.JudgeRepository;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.transaction.annotation.Transactional;

import static org.junit.jupiter.api.Assertions.*;

/**
 * 测试saveUserPhone方法的功能
 */
@SpringBootTest
@ActiveProfiles("test")
@Transactional
public class SaveUserPhoneTest {

    @Autowired
    private UserService userService;

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private EmployeeRepository employeeRepository;

    @Autowired
    private JudgeRepository judgeRepository;

    @Test
    public void testSaveUserPhoneNewPhone() {
        System.out.println("=== 测试场景1：保存新手机号 ===");
        
        // 创建一个有openid的用户
        User user = new User();
        user.setName("测试用户");
        user.setWxOpenid("test_openid_123");
        user = userRepository.save(user);
        
        // 保存手机号（使用时间戳确保唯一性）
        String phone = "139" + String.valueOf(System.currentTimeMillis()).substring(5);
        User result = userService.saveUserPhone(user.getId(), phone);
        
        // 验证结果
        assertEquals(phone, result.getPhone());
        System.out.println("✅ 成功保存新手机号: " + phone);
    }

    @Test
    public void testSaveUserPhoneSameUser() {
        System.out.println("=== 测试场景2：保存相同用户的手机号 ===");
        
        // 创建一个已有手机号的用户
        String phone = "139" + String.valueOf(System.currentTimeMillis()).substring(5);
        User user = new User();
        user.setName("测试用户");
        user.setPhone(phone);
        user.setWxOpenid("test_openid_456");
        user = userRepository.save(user);
        
        // 再次保存相同手机号
        User result = userService.saveUserPhone(user.getId(), phone);
        
        // 验证结果
        assertEquals(phone, result.getPhone());
        System.out.println("✅ 相同用户手机号无需更新");
    }

    @Test
    public void testSaveUserPhoneWithDataMigration() {
        System.out.println("=== 测试场景3：数据迁移场景 ===");
        
        // 创建一个没有openid但有手机号的用户（老用户）
        String phone = "139" + String.valueOf(System.currentTimeMillis()).substring(5);
        User oldUser = new User();
        oldUser.setName("老用户");
        oldUser.setPhone(phone);
        // 注意：没有设置wxOpenid
        oldUser = userRepository.save(oldUser);
        
        // 为老用户创建员工信息
        Employee employee = new Employee();
        employee.setName("老用户员工");
        employee.setPhone(phone);
        employee.setUserId(oldUser.getId());
        employee.setRoleId("EMPLOYEE");
        employee = employeeRepository.save(employee);
        
        // 创建一个有openid的新用户（微信用户）
        User newUser = new User();
        newUser.setName("新用户");
        newUser.setWxOpenid("test_openid_789");
        newUser = userRepository.save(newUser);
        
        // 新用户尝试保存老用户的手机号
        User result = userService.saveUserPhone(newUser.getId(), phone);
        
        // 验证结果
        assertEquals(phone, result.getPhone());
        
        // 验证老用户的手机号被清空
        User updatedOldUser = userRepository.findById(oldUser.getId()).orElse(null);
        assertNotNull(updatedOldUser);
        assertNull(updatedOldUser.getPhone());
        
        // 验证员工信息被迁移到新用户
        Employee updatedEmployee = employeeRepository.findById(employee.getId()).orElse(null);
        assertNotNull(updatedEmployee);
        assertEquals(newUser.getId(), updatedEmployee.getUserId());
        
        System.out.println("✅ 数据迁移成功完成");
        System.out.println("  - 老用户手机号已清空");
        System.out.println("  - 员工信息已迁移到新用户");
    }

    @Test
    public void testSaveUserPhoneConflictResolution() {
        System.out.println("=== 测试场景4：冲突处理 ===");
        
        // 创建一个有openid和手机号的用户A
        String phone = "139" + String.valueOf(System.currentTimeMillis()).substring(5);
        User userA = new User();
        userA.setName("用户A");
        userA.setPhone(phone);
        userA.setWxOpenid("test_openid_A");
        userA = userRepository.save(userA);
        
        // 创建一个有openid的用户B
        User userB = new User();
        userB.setName("用户B");
        userB.setWxOpenid("test_openid_B");
        userB = userRepository.save(userB);
        
        // 用户B尝试保存用户A的手机号（应该抛出异常）
        final Long userBId = userB.getId();
        assertThrows(RuntimeException.class, () -> {
            userService.saveUserPhone(userBId, phone);
        });
        
        System.out.println("✅ 正确处理了冲突情况");
    }

    @Test
    public void testSaveUserPhoneComplexDataMigration() {
        System.out.println("=== 测试场景5：复杂数据迁移 ===");
        
        // 创建一个没有openid但有手机号的用户（老用户）
        String phone = "139" + String.valueOf(System.currentTimeMillis()).substring(5);
        User oldUser = new User();
        oldUser.setName("老用户");
        oldUser.setPhone(phone);
        oldUser = userRepository.save(oldUser);
        
        // 为老用户创建员工和裁判信息
        Employee employee = new Employee();
        employee.setName("老用户员工");
        employee.setPhone(phone);
        employee.setUserId(oldUser.getId());
        employee.setRoleId("EMPLOYEE");
        employee = employeeRepository.save(employee);
        
        Judge judge = new Judge();
        judge.setName("老用户裁判");
        judge.setPhone(phone);
        judge.setUserId(oldUser.getId());
        judge = judgeRepository.save(judge);
        
        // 创建一个有openid的新用户（微信用户）
        User newUser = new User();
        newUser.setName("新用户");
        newUser.setWxOpenid("test_openid_complex");
        newUser = userRepository.save(newUser);
        
        // 新用户尝试保存老用户的手机号
        User result = userService.saveUserPhone(newUser.getId(), phone);
        
        // 验证结果
        assertEquals(phone, result.getPhone());
        
        // 验证老用户的手机号被清空
        User updatedOldUser = userRepository.findById(oldUser.getId()).orElse(null);
        assertNotNull(updatedOldUser);
        assertNull(updatedOldUser.getPhone());
        
        // 验证员工信息被迁移到新用户
        Employee updatedEmployee = employeeRepository.findById(employee.getId()).orElse(null);
        assertNotNull(updatedEmployee);
        assertEquals(newUser.getId(), updatedEmployee.getUserId());
        
        // 验证评委信息被迁移到新用户
        Judge updatedJudge = judgeRepository.findById(judge.getId()).orElse(null);
        assertNotNull(updatedJudge);
        assertEquals(newUser.getId(), updatedJudge.getUserId());
        
        System.out.println("✅ 复杂数据迁移成功完成");
        System.out.println("  - 老用户手机号已清空");
        System.out.println("  - 员工信息已迁移到新用户");
        System.out.println("  - 评委信息已迁移到新用户");
    }
}