package com.rongyichuang.user.service;

import com.rongyichuang.user.entity.User;
import com.rongyichuang.user.repository.UserRepository;
import com.rongyichuang.employee.repository.EmployeeRepository;
import com.rongyichuang.judge.repository.JudgeRepository;
import com.rongyichuang.player.repository.PlayerRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Optional;

/**
 * 用户服务类
 */
@Service
@Transactional
public class UserService {

    private static final Logger logger = LoggerFactory.getLogger(UserService.class);

    @Autowired
    private UserRepository userRepository;
    
    @Autowired
    private EmployeeRepository employeeRepository;
    
    @Autowired
    private JudgeRepository judgeRepository;
    
    @Autowired
    private PlayerRepository playerRepository;
    
    private final BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();

    /**
     * 根据手机号查找或创建用户
     * 如果用户存在，更新姓名和密码（如果提供了密码）
     * 如果用户不存在，创建新用户
     * 
     * @param phone 手机号
     * @param name 姓名
     * @param password 密码（可以为null，表示不更新密码）
     * @return 用户实体
     */
    public User findOrCreateUserByPhone(String phone, String name, String password) {
        Optional<User> existingUser = userRepository.findByPhone(phone);
        
        if (existingUser.isPresent()) {
            // 用户存在，更新姓名和密码（如果提供了密码）
            User user = existingUser.get();
            user.setName(name);
            if (password != null && !password.trim().isEmpty()) {
                user.setPassword(passwordEncoder.encode(password));
            }
            return userRepository.save(user);
        } else {
            // 用户不存在，创建新用户
            User newUser = new User();
            newUser.setName(name);
            newUser.setPhone(phone);
            if (password != null && !password.trim().isEmpty()) {
                newUser.setPassword(passwordEncoder.encode(password));
            } else {
                // 如果没有提供密码，设置一个默认密码
                newUser.setPassword(passwordEncoder.encode("123456"));
            }
            return userRepository.save(newUser);
        }
    }

    /**
     * 根据手机号查找用户
     */
    public Optional<User> findByPhone(String phone) {
        return userRepository.findByPhone(phone);
    }

    /**
     * 保存用户
     */
    public User save(User user) {
        return userRepository.save(user);
    }

    /**
     * 根据ID查找用户
     */
    public Optional<User> findById(Long id) {
        return userRepository.findById(id);
    }

    /**
     * 保存用户手机号码
     * 核心逻辑：
     * 1. 查询当前t_user里面是否存在相同的电话号码，如果没有，就更新到当前user里面
     * 2. 如果存在相同的电话号码，并且对应user的openid是null，那么清空原来user的phone设置为null，
     *    把新的电话号码更新到当前用户的phone字段，同时更新t_player、t_judge、t_employee关联的user_id到新的user_id
     * 
     * @param currentUserId 当前用户ID
     * @param phone 要保存的手机号码
     * @return 更新后的用户实体
     */
    @Transactional
    public User saveUserPhone(Long currentUserId, String phone) {
        logger.info("开始处理用户手机号码保存，用户ID: {}, 手机号: {}", currentUserId, phone);
        
        // 获取当前用户
        User currentUser = userRepository.findById(currentUserId)
                .orElseThrow(() -> new RuntimeException("用户不存在，ID: " + currentUserId));
        
        // 检查是否存在相同手机号的用户
        Optional<User> existingPhoneUser = userRepository.findByPhone(phone);
        
        if (existingPhoneUser.isEmpty()) {
            // 情况1：没有其他用户使用这个手机号，直接更新当前用户
            logger.info("手机号 {} 未被使用，直接更新到用户 {}", phone, currentUserId);
            currentUser.setPhone(phone);
            return userRepository.save(currentUser);
        } else {
            User phoneUser = existingPhoneUser.get();
            
            // 如果是同一个用户，无需处理
            if (phoneUser.getId().equals(currentUserId)) {
                logger.info("手机号 {} 已属于当前用户 {}，无需更新", phone, currentUserId);
                return currentUser;
            }
            
            // 情况2：存在相同手机号的用户，且该用户的openid为null
            if (phoneUser.getWxOpenid() == null || phoneUser.getWxOpenid().trim().isEmpty()) {
                logger.info("发现手机号 {} 被用户 {} 使用，但该用户无openid，开始数据迁移", phone, phoneUser.getId());
                
                // 迁移关联数据
                migrateUserRelatedData(phoneUser.getId(), currentUserId);
                
                // 清空原用户的手机号
                phoneUser.setPhone(null);
                userRepository.save(phoneUser);
                logger.info("已清空原用户 {} 的手机号", phoneUser.getId());
                
                // 更新当前用户的手机号
                currentUser.setPhone(phone);
                User savedUser = userRepository.save(currentUser);
                logger.info("已将手机号 {} 更新到当前用户 {}", phone, currentUserId);
                
                return savedUser;
            } else {
                // 情况3：存在相同手机号的用户，且该用户有openid，不能覆盖
                logger.warn("手机号 {} 已被用户 {} 使用，且该用户有openid，无法更新", phone, phoneUser.getId());
                throw new RuntimeException("手机号已被其他微信用户使用，无法更新");
            }
        }
    }

    /**
     * 迁移用户关联数据
     * 将原用户的员工、评委、学员信息迁移到新用户
     * 
     * @param fromUserId 原用户ID
     * @param toUserId 目标用户ID
     */
    private void migrateUserRelatedData(Long fromUserId, Long toUserId) {
        logger.info("开始迁移用户关联数据，从用户 {} 到用户 {}", fromUserId, toUserId);
        
        // 迁移员工信息
        employeeRepository.findByUserId(fromUserId).ifPresent(employee -> {
            logger.info("迁移员工信息，员工ID: {}, 姓名: {}", employee.getId(), employee.getName());
            employee.setUserId(toUserId);
            employeeRepository.save(employee);
        });
        
        // 迁移评委信息
        judgeRepository.findByUserId(fromUserId).ifPresent(judge -> {
            logger.info("迁移评委信息，评委ID: {}, 姓名: {}", judge.getId(), judge.getName());
            judge.setUserId(toUserId);
            judgeRepository.save(judge);
        });
        
        // 迁移学员信息
        playerRepository.findByUserId(fromUserId).ifPresent(player -> {
            logger.info("迁移学员信息，学员ID: {}, 姓名: {}", player.getId(), player.getName());
            player.setUserId(toUserId);
            playerRepository.save(player);
        });
        
        logger.info("用户关联数据迁移完成");
    }
}