using Dpz.Core.Service.Network;
using Dpz.Core.Service.Network.Models;
using Dpz.Core.Web.Library.Api.Service;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.SignalR;

namespace Dpz.Core.Web.Library.Hub;

public class RobotChatHub(
    ILogger<RobotChatHub> logger,
    IAiChatService aiChatService,
    IConfiguration configuration,
    ChatCompletionService chatCompletionService,
    GenerateSessionTitleService generateSessionTitleService
) : Microsoft.AspNetCore.SignalR.Hub
{
    [Authorize]
    public async Task SendStreamMessageToChatGpt(
        string content,
        int modelValue = 1,
        string? sessionId = null
    )
    {
        if (string.IsNullOrWhiteSpace(content))
        {
            await Clients.Caller.SendCoreAsync("SystemError", [ChatGptReceiverUser("请输入内容")]);
            return;
        }

        // if (!Context.User.IsLogin())
        // {
        //     await Clients.Caller.SendCoreAsync("SystemError", [ChatGptReceiverUser("尚未登录")]);
        //     return;
        // }

        // 创建取消令牌源并存储
        var cts = new CancellationTokenSource();
        var tokenKey = "";

        try
        {
            var sender = Context.User.RequiredUserInfo;

            // 判断是否为新的会话
            var isNewSession = false;

            if (string.IsNullOrEmpty(sessionId))
            {
                sessionId = Guid.NewGuid().ToString("N");
                isNewSession = true;
            }

            // 使用 sessionId + ConnectionId 作为唯一标识
            tokenKey = $"{sessionId}_{Context.ConnectionId}";
            WebToolsExtensions.CancellationTokens[tokenKey] = cts;

            // 立即检查是否已被取消（在存储后立即检查）
            cts.Token.ThrowIfCancellationRequested();

            // 如果是新会话，通知前端新的 SessionId
            if (isNewSession)
            {
                await Clients.Caller.SendCoreAsync("NewSessionCreated", [sessionId], cts.Token);
            }

            // 解析模型枚举，如果失败则使用默认值 Gpt5Mini
            AiModel selectedModel;
            try
            {
                if (Enum.IsDefined(typeof(AiModel), modelValue))
                {
                    selectedModel = (AiModel)modelValue;
                }
                else
                {
                    selectedModel = AiModel.Gpt5Mini;
                    logger.LogWarning(
                        "无效的模型值 {Value}，使用默认模型: {Model}",
                        modelValue,
                        selectedModel
                    );
                }
            }
            catch (Exception e)
            {
                selectedModel = AiModel.Gpt5Mini;
                logger.LogError(
                    e,
                    "解析模型值 {Value} 失败，使用默认模型: {Model}",
                    modelValue,
                    selectedModel
                );
            }

            // 保存用户消息到会话
            await aiChatService.SaveUserMessageAsync(sender.Id, sessionId, content, sender);

            // 再次检查是否已被取消
            cts.Token.ThrowIfCancellationRequested();

            // 获取会话的历史记录
            var records = await aiChatService.GetSessionMessagesAsync(sessionId, 1, 5);
            var messages = records
                .OrderBy(x => x.SendTime)
                .Select(x => new ChatMessage
                {
                    Role = x.Sender?.Id == sessionId ? "assistant" : "user",
                    Message = x.Message,
                })
                .ToList();

            // 用于收集最终的完整回复
            var fullContent = new StringBuilder();

            // 流式调用 AI，每次收到增量内容就推送给客户端
            var result = await chatCompletionService.SendStreamChatWithCallbackAsync(
                messages,
                async deltaContent =>
                {
                    // 在发送前立即检查是否已取消
                    cts.Token.ThrowIfCancellationRequested();

                    // 累积完整内容
                    fullContent.Append(deltaContent);

                    // 实时推送增量内容给客户端
                    await Clients.Caller.SendCoreAsync("StreamDelta", [deltaContent], cts.Token);
                },
                opt =>
                {
                    opt.Stream = true;
                    opt.Model = selectedModel;
                },
                cts.Token
            );

            if (!result.Success)
            {
                await Clients.Caller.SendCoreAsync(
                    "SystemError",
                    [ChatGptReceiverUser(ErrorMessage(result.Message))],
                    cts.Token
                );
                return;
            }

            // 流式完成，推送完成标记
            await Clients.Caller.SendCoreAsync("StreamCompleted", [], cts.Token);

            // 保存完整回复到数据库
            var finalContent = fullContent.ToString();
            if (string.IsNullOrEmpty(finalContent))
            {
                return;
            }

            var aiUser = new VmUserInfo
            {
                Avatar = $"{configuration["CDNBaseAddress"]}/images/ChatGPT.ico",
                Enable = true,
                // 使用会话ID作为AI用户ID
                Id = sessionId,
                Key = "",
                LastAccessTime = DateTime.Now,
                Name = "AI Assistant",
                Permissions = null,
            };
            await aiChatService.SaveAiMessageAsync(sender.Id, sessionId, finalContent, aiUser);

            if (isNewSession)
            {
                var sessionName = await generateSessionTitleService.GenerateAsync(
                    sender.Id,
                    sessionId,
                    content,
                    finalContent,
                    selectedModel.ToString()
                );
                await Clients.Caller.SendCoreAsync(
                    "SessionNameGenerated",
                    [new { sessionId, sessionName }],
                    cts.Token
                );
            }
        }
        catch (OperationCanceledException)
        {
            logger.LogInformation(
                "Stream message cancelled by user, Token Key: {TokenKey}",
                tokenKey
            );
            await Clients.Caller.SendCoreAsync("StreamCancelled", [], cts.Token);
        }
        catch (Exception e)
        {
            logger.LogError(e, "Stream message to ChatGpt error");
            await Clients.Caller.SendCoreAsync(
                "SystemError",
                [ChatGptReceiverUser(ErrorMessage(e.Message))],
                cts.Token
            );
        }
        finally
        {
            // 清理取消令牌源
            WebToolsExtensions.CancellationTokens.TryRemove(tokenKey, out _);
            cts.Dispose();
        }
    }

    private object ChatGptReceiverUser(string message)
    {
        return new
        {
            id = ApplicationTools.ChatGptUserId,
            avatar = $"{configuration["CDNBaseAddress"]}/images/ChatGPT.ico",
            username = "ChatGPT",
            type = "friend",
            content = message,
            mine = false,
        };
    }

    private static string ErrorMessage(string? message)
    {
        return $"调用API出错，错误信息：<span style='color:red;'>{(message ?? "Call API fail")}</span>";
    }

    public override Task OnConnectedAsync()
    {
        var sessionId = Context
            .GetHttpContext()
            ?.Request.Cookies[Program.AuthorizeCookieName + ".SessionId"];
        Clients.Caller.SendCoreAsync("Connected", ["websocket connected.", sessionId]);
        return base.OnConnectedAsync();
    }

    public override Task OnDisconnectedAsync(Exception? exception)
    {
        var sessionId = Context
            .GetHttpContext()
            ?.Request.Cookies[Program.AuthorizeCookieName + ".SessionId"];
        Clients.Caller.SendCoreAsync("Disconnected", ["websocket disconnected.", sessionId]);
        if (exception != null)
        {
            logger.LogError(exception, "signalR disconnected");
        }

        // 清理当前连接的所有取消令牌
        var connectionId = Context.ConnectionId;
        var keysToRemove = WebToolsExtensions
            .CancellationTokens.Keys.Where(k => k.EndsWith($"_{connectionId}"))
            .ToList();

        foreach (var key in keysToRemove)
        {
            if (WebToolsExtensions.CancellationTokens.TryRemove(key, out var cts))
            {
                cts.Dispose();
                logger.LogInformation(
                    "Cleaned up cancellation token on disconnect, Token Key: {TokenKey}",
                    key
                );
            }
        }

        return base.OnDisconnectedAsync(exception);
    }
}