package com.dora.service.impl;

import com.dora.entity.MembershipPlan;
import com.dora.entity.Order;
import com.dora.entity.User;
import com.dora.event.UserGainedFanEvent;
import com.dora.mapper.MembershipPlanMapper;
import com.dora.mapper.UserMapper;
import com.dora.service.PromotionCommissionService;
import com.dora.service.UserMembershipUpdateService;
import org.springframework.context.ApplicationEventPublisher;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;

/**
 * 用户会员权益更新服务实现类
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class UserMembershipUpdateServiceImpl implements UserMembershipUpdateService {

    private final UserMapper userMapper;
    private final MembershipPlanMapper membershipPlanMapper;
    private final PromotionCommissionService promotionCommissionService;
    private final ApplicationEventPublisher eventPublisher;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean updateUserMembershipByOrder(Order order) {
        try {
            // 1. 验证订单
            if (!validateOrderForMembershipUpdate(order)) {
                log.error("订单验证失败，无法更新会员权益，订单号：{}", order.getOrderNo());
                return false;
            }
            
            // 2. 获取用户信息
            User user = userMapper.selectById(order.getUserId());
            if (user == null) {
                log.error("用户不存在，无法更新会员权益，用户ID：{}", order.getUserId());
                return false;
            }
            
            // 3. 获取套餐信息
            MembershipPlan plan = membershipPlanMapper.selectById(order.getPlanId());
            if (plan == null) {
                log.error("套餐不存在，无法更新会员权益，套餐ID：{}", order.getPlanId());
                return false;
            }
            
            // 4. 记录原始状态
            Integer oldRole = user.getRole();
            LocalDateTime oldMembershipExpire = user.getMembershipExpiresAt();
            
            // 5. 计算新的会员到期时间（优先使用订单中的实际时长）
            LocalDateTime newMembershipExpire = calculateNewMembershipExpireTime(user, order, plan);
            
            // 6. 更新用户角色（取最高等级）
            Integer newRole = Math.max(user.getRole() != null ? user.getRole() : 1, plan.getTargetRole());
            
            // 7. 更新用户信息
            user.setRole(newRole);
            user.setMembershipExpiresAt(newMembershipExpire);
            user.setUpdateTime(LocalDateTime.now());
            
            int updateResult = userMapper.updateById(user);
            if (updateResult <= 0) {
                log.error("更新用户信息失败，用户ID：{}", user.getId());
                return false;
            }
            
            log.info("用户会员权益更新成功 - 用户ID：{}，订单号：{}，角色：{} -> {}，会员到期：{} -> {}", 
                    user.getId(), order.getOrderNo(), oldRole, newRole, oldMembershipExpire, newMembershipExpire);
            
            // 8. 处理推广分成（实时处理）
            try {
                promotionCommissionService.processOrderPromotionCommission(order);
            } catch (Exception e) {
                log.error("处理推广分成失败，但不影响会员权益更新 - orderId: {}", order.getId(), e);
                // 推广分成失败不影响会员权益更新的成功
            }

            // 9. 发布用户成为付费粉丝事件（如果有推广人）
            if (user.getInviterId() != null) {
                try {
                    UserGainedFanEvent event = new UserGainedFanEvent(this, user.getInviterId(), user.getId(), true);
                    eventPublisher.publishEvent(event);
                } catch (Exception e) {
                    log.error("发布用户获得付费粉丝事件失败 - userId: {}, inviterId: {}", 
                            user.getId(), user.getInviterId(), e);
                }
            }
            
            return true;
            
        } catch (Exception e) {
            log.error("更新用户会员权益失败，订单号：{}", order.getOrderNo(), e);
            return false;
        }
    }

    @Override
    public boolean validateOrderForMembershipUpdate(Order order) {
        if (order == null) {
            return false;
        }
        
        // 检查订单状态是否为已完成
        if (order.getStatus() == null || order.getStatus() != 1) {
            log.warn("订单状态不正确，无法更新会员权益，订单号：{}，状态：{}", order.getOrderNo(), order.getStatus());
            return false;
        }
        
        // 检查是否有套餐ID
        if (order.getPlanId() == null) {
            log.warn("订单没有套餐ID，无法更新会员权益，订单号：{}", order.getOrderNo());
            return false;
        }
        
        // 检查是否有用户ID
        if (order.getUserId() == null) {
            log.warn("订单没有用户ID，无法更新会员权益，订单号：{}", order.getOrderNo());
            return false;
        }
        
        return true;
    }

    /**
     * 计算新的会员到期时间
     * @param user 用户
     * @param order 订单（优先使用订单中的实际时长）
     * @param plan 套餐（作为备用）
     * @return 新的到期时间
     */
    private LocalDateTime calculateNewMembershipExpireTime(User user, Order order, MembershipPlan plan) {
        LocalDateTime now = LocalDateTime.now();
        LocalDateTime currentExpire = user.getMembershipExpiresAt();
        
        // 优先使用订单中的实际时长，如果没有则使用套餐时长
        Integer durationDays = order.getActualDurationDays() != null ? 
            order.getActualDurationDays() : plan.getDurationDays();
        
        // 如果当前会员未过期，在现有基础上延长
        if (currentExpire != null && currentExpire.isAfter(now)) {
            return currentExpire.plusDays(durationDays);
        } else {
            // 如果当前会员已过期或没有会员，从当前时间开始计算
            return now.plusDays(durationDays);
        }
    }
}
