package com.ruoyi.im.service.impl;

import com.alibaba.fastjson2.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.netease.nim.server.sdk.core.BizName;
import com.netease.nim.server.sdk.core.YunxinApiHttpClient;
import com.netease.nim.server.sdk.core.YunxinApiResponse;
import com.netease.nim.server.sdk.core.exception.YunxinSdkException;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.im.comm.Result;
import com.ruoyi.im.config.AppAuthConfig;
import com.ruoyi.system.domain.UserAccount;
import com.ruoyi.im.service.ImApiServcie;
import com.ruoyi.im.dto.RegisterDto;
import com.ruoyi.system.service.UserAccountService;
import com.ruoyi.im.util.SymmetricCryptoUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import org.springframework.util.CollectionUtils;

import javax.annotation.PostConstruct;
import java.time.Instant;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.atomic.AtomicLong;

@Service
@Slf4j
public class ImApiServcieImpl implements ImApiServcie {
    @Autowired
    private UserAccountService userAccountService;

    // 使用单例客户端，避免重复初始化
    private YunxinApiHttpClient yunxinClient;

    // 使用并发安全的集合存储正在生成的账号，防止重复
    private final Set<Long> generatingAccounts = Collections.newSetFromMap(new ConcurrentHashMap<>());

    // 使用原子计数器优化账号生成
    private final AtomicLong lastTimestamp = new AtomicLong(0);
    private final AtomicLong sequence = new AtomicLong(0);

    @PostConstruct
    public void init() {
        // 初始化云信客户端，只执行一次
        String appkey = AppAuthConfig.DEFAULT_CONFIG.getAppKey();
        String appsecret = AppAuthConfig.DEFAULT_CONFIG.getAppSecret();
        int timeoutMillis = 5000;

        this.yunxinClient = new YunxinApiHttpClient.Builder(BizName.IM, appkey, appsecret)
                .timeoutMillis(timeoutMillis)
                .build();
    }

    @Override
    @Transactional(rollbackFor = Exception.class) // 添加事务注解确保操作原子性
    public Result register(RegisterDto dto) {
        try {
            // 验证手机号是否已存在（数据库唯一索引提供最终保障）
            List<UserAccount> accounts = userAccountService.list(
                    new LambdaQueryWrapper<>(UserAccount.class)
                            .eq(UserAccount::getAccount, dto.getAccount())
            );

            if (!CollectionUtils.isEmpty(accounts)) {
                return Result.error("手机号已注册！");
            }

            // 创建本地用户账户记录
            UserAccount userAccount = new UserAccount();
            userAccount.setAccount(dto.getAccount());
            userAccount.setPhoneNumber(dto.getAccount());
            userAccount.setCloudMessageAccount(dto.getAccount());
            userAccount.setPassword(SymmetricCryptoUtil.encryptPassword(dto.getPassword()));

            if (!userAccountService.save(userAccount)) {
                return Result.error("注册失败，请重试");
            }

            // 注册云信账号（远程调用）
            String path = "/user/create.action";
            Map<String, String> paramMap = new HashMap<>();
            paramMap.put("accid", dto.getAccount());
            paramMap.put("token", dto.getPassword());

            YunxinApiResponse response = yunxinClient.executeV1Api(path, paramMap);

            // 处理云信响应
            String data = response.getData();
            JSONObject json = JSONObject.parseObject(data);
            int code = json.getIntValue("code");

            if (code == 200) {
                return Result.success("注册成功");
            } else if (code == 414) {
                // 手动触发回滚（事务注解会自动处理）
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return Result.error("账号已被注册！");
            } else {
                // 其他错误码同样触发回滚
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                log.error("云信注册失败，响应: {}, traceId: {}", data, response.getTraceId());
                return Result.error("注册失败，错误码: " + code);
            }

        } catch (YunxinSdkException e) {
            // 云信调用异常时回滚事务
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            log.error("云信服务调用异常 traceId: {}", e.getTraceId(), e);
            return Result.error("注册失败，系统异常");
        } catch (Exception e) {
            // 其他异常同样回滚
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            log.error("注册过程发生未知异常", e);
            return Result.error("注册失败，请重试");
        }
    }

    /**
     * 优化的账号生成方法，使用雪花算法变体提高并发性能
     */
    public long generateUniqueCloudMessageAccount() {
        final int maxAttempts = 10; // 减少尝试次数，提高效率

        for (int attempt = 0; attempt < maxAttempts; attempt++) {
            long account = generateSnowflakeLikeId();

            // 使用并发集合检查是否正在生成相同账号
            if (generatingAccounts.add(account)) {
                try {
                    // 检查数据库是否存在
                    boolean exists = userAccountService.lambdaQuery()
                            .eq(UserAccount::getCloudMessageAccount, account)
                            .exists();

                    if (!exists) {
                        return account;
                    }
                } finally {
                    // 无论成功与否，都从集合中移除
                    generatingAccounts.remove(account);
                }
            }

            // 短暂等待后重试
            try {
                Thread.sleep(ThreadLocalRandom.current().nextInt(10, 50));
            } catch (InterruptedException e) {
                e.printStackTrace();
                Thread.currentThread().interrupt();
                throw new RuntimeException("生成账号被中断", e);
            }
        }

        throw new RuntimeException("无法在" + maxAttempts + "次尝试内生成唯一账号");
    }

    /**
     * 基于雪花算法的ID生成器，提高并发性能
     */
    private long generateSnowflakeLikeId() {
        long currentTime = System.currentTimeMillis();
        long timestamp = currentTime % 100_000_000L; // 取时间戳的后8位

        // 使用原子操作确保序列号递增
        long seq;
        long lastTime;
        do {
            lastTime = lastTimestamp.get();
            if (currentTime == lastTime) {
                seq = sequence.incrementAndGet() % 100;
            } else {
                sequence.set(0);
                lastTimestamp.set(currentTime);
                seq = 0;
            }
        } while (!lastTimestamp.compareAndSet(lastTime, currentTime));

        // 组合时间戳和序列号，生成9位ID
        return timestamp * 100 + seq;
    }
}