using System.Text;
using System.Text.Json;
using System.Web;
using Dpz.Core.Entity.Base.Image;
using Dpz.Core.EnumLibrary;
using Dpz.Core.Infrastructure;
using Dpz.Core.Infrastructure.Imaging;
using Dpz.Core.MessageQueue.Abstractions;
using Dpz.Core.MessageQueue.Enums;
using Dpz.Core.Public.ViewModel;
using Dpz.Core.Public.ViewModel.Messages;
using Dpz.Core.Public.ViewModel.Request;
using Dpz.Core.Service.Network;
using Dpz.Core.Service.ObjectStorage.Services;
using Dpz.Core.Service.RepositoryService;
using Dpz.Core.Web.Jobs.Hangfire;
using Dpz.Core.Web.Jobs.Models;
using Hangfire;
using MongoDB.Bson;
using OpenAI.Chat;
using ReverseMarkdown;

namespace Dpz.Core.Web.Jobs.Services;

public abstract class TaskService(
    IArticleService articleService,
    IObjectStorageOperation objectStorageService,
    IHttpClientFactory httpClientFactory,
    IPushMessage pushMessage,
    ILoggerFactory logger,
    List<string> tags,
    IOpenAiService openAiService,
    IConfiguration configuration,
    IMessagePublisher<NewsArticleMessage> messagePublisher,
    IMessagePublisher<BatchCompletionMessage> batchCompletionPublisher,
    IMessagePublisher<DeleteMarkdownMessage> deleteMarkdownMessagePublisher,
    IImageFormatDetector imageFormatDetector
) : JobActivator
{
    /// <summary>
    /// 日志记录
    /// </summary>
    private readonly ILogger<TaskService> _logger = logger.CreateLogger<TaskService>();

    /// <summary>
    /// 文章Service
    /// </summary>
    protected readonly IArticleService ArticleService = articleService;

    /// <summary>
    /// HttpClientFactory
    /// </summary>
    protected readonly IHttpClientFactory HttpClientFactory = httpClientFactory;

    /// <summary>
    /// 消息发布者
    /// </summary>
    private readonly IMessagePublisher<NewsArticleMessage> _messagePublisher = messagePublisher;

    /// <summary>
    /// 批次完成消息发布者
    /// </summary>
    private readonly IMessagePublisher<BatchCompletionMessage> _batchCompletionPublisher =
        batchCompletionPublisher;

    /// <summary>
    /// 当前批次ID
    /// </summary>
    private string? _currentBatchId;

    /// <summary>
    /// 当前批次已成功发送的消息数
    /// </summary>
    private int _sentMessageCount;

    /// <summary>
    /// 爬取进度
    /// </summary>
    private decimal Progress { get; set; }

    /// <summary>
    /// 进度单调递增保护
    /// </summary>
    private readonly SemaphoreSlim _progressSemaphore = new(1, 1);

    /// <summary>
    /// 并发爬取限制
    /// </summary>
    private readonly SemaphoreSlim _concurrencyLimiter = new(3, 3);

    /// <summary>
    /// 文章标签
    /// </summary>
    private List<string> Tags { get; } = tags;

    protected abstract Task<IReadOnlyCollection<string>> GetTaskUrlsAsync();

    /// <summary>
    /// 爬取文章内容
    /// </summary>
    /// <param name="article">文章实体</param>
    /// <param name="url">文章地址</param>
    /// <returns></returns>
    protected abstract Task<VmUserInfo?> GetArticleContentAsync(
        CreateArticleRequest article,
        string url
    );

    /// <summary>
    /// 推送爬取消息
    /// </summary>
    /// <param name="message"></param>
    /// <param name="type"></param>
    protected virtual async Task PushProgressMessage(
        string message,
        MessageType type = MessageType.Success
    )
    {
        var progressMessage = new ProgressMessage
        {
            ProgressValues = [type == MessageType.Over ? 1m : Progress],
            Message = message,
            Type = type,
        };
        await pushMessage.PushCnBetaMessageAsync(progressMessage);
    }

    /// <summary>
    /// 下载图片并上传到云储存
    /// </summary>
    /// <param name="url">需要下载图片的地址</param>
    /// <returns></returns>
    protected virtual async Task<ImageMetadata?> DownloadImageToObjectStorageAsync(string url)
    {
        var uri = HandleUrl(url, "x-bce-process");
        if (uri == null)
        {
            return null;
        }

        try
        {
            // download
            var (buffer, fileExtension) = await ApplicationTools.RetryAsync(
                async () => await DownloadImageAsync(uri),
                TimeSpan.FromSeconds(1)
            );

            // upload
            return await ApplicationTools.RetryAsync(
                async () => await UploadImageAsync(buffer, fileExtension),
                TimeSpan.FromSeconds(1)
            );
        }
        catch (Exception e)
        {
            var message = $"downloading images from the {uri} failed";
            await PushProgressMessage($"{message},{e.Message}");
            _logger.LogError(e, "{Message}", message);
            return null;
        }
    }

    /// <summary>
    /// 下载图片
    /// </summary>
    /// <param name="uri"></param>
    /// <returns></returns>
    /// <exception cref="BusinessException"></exception>
    protected virtual async Task<(byte[] Buffer, string FileExtension)> DownloadImageAsync(Uri uri)
    {
        var httpClient = HttpClientFactory.CreateClient("edge");
        var request = new HttpRequestMessage(HttpMethod.Get, uri);
        var response = await httpClient.SendAsync(request);
        if (!response.IsSuccessStatusCode)
        {
            throw new BusinessException(
                $"download image fail,response status code:{response.StatusCode}"
            );
        }

        var stream = await response.Content.ReadAsStreamAsync();

        if (
            string.Equals(
                response.Content.Headers.ContentType?.ToString() ?? "",
                "image/svg+xml",
                StringComparison.OrdinalIgnoreCase
            )
        )
        {
            using var memoryStream = new MemoryStream();
            stream.Position = 0;
            await stream.CopyToAsync(memoryStream);
            var bytes = memoryStream.ToArray();
            await stream.DisposeAsync();
            return (bytes, "svg");
        }

        return await RecognizeImageAsync(stream);
    }

    /// <summary>
    /// 上传图片
    /// </summary>
    /// <param name="buffer"></param>
    /// <param name="fileExtension"></param>
    /// <returns></returns>
    protected virtual async Task<ImageMetadata?> UploadImageAsync(
        byte[] buffer,
        string fileExtension
    )
    {
        var date = DateTime.Now;
        var path =
#if DEBUG
        new List<string>
        {
            "Test",
            "images",
            date.Year.ToString(),
            date.Month.ToString(),
            date.Day.ToString(),
        };
#else
        new List<string>
        {
            "images",
            date.Year.ToString(),
            date.Month.ToString(),
            date.Day.ToString(),
        };
#endif
        var result = await objectStorageService.UploadAsync(
            buffer,
            path,
            $"{ObjectId.GenerateNewId()}.{fileExtension}"
        );

        return result as ImageMetadata?;
    }

    /// <summary>
    /// handle url
    /// </summary>
    /// <param name="url">url</param>
    /// <param name="key">remove query string key</param>
    /// <returns></returns>
    protected virtual Uri? HandleUrl(string url, params string[] key)
    {
        if (string.IsNullOrEmpty(url))
        {
            _logger.LogError("url is empty");
            return null;
        }

        if (url.StartsWith("//"))
        {
            url = "https:" + url;
        }

        if (!Uri.TryCreate(url, UriKind.RelativeOrAbsolute, out var uri))
        {
            _logger.LogError("{Url}未能成功构建Uri", url);
            return null;
        }

        // this gets all the query string key value pairs as a collection
        var newQueryString = HttpUtility.ParseQueryString(uri.Query);

        // this removes the key if exists
        foreach (var item in key)
        {
            newQueryString.Remove(item);
        }

        // this gets the page path from root without QueryString
        var pagePathWithoutQueryString = uri.GetLeftPart(UriPartial.Path);

        return new Uri(
            newQueryString.Count > 0
                ? $"{pagePathWithoutQueryString}?{newQueryString}"
                : pagePathWithoutQueryString
        );
    }

    /// <summary>
    /// 识别图像
    /// </summary>
    /// <param name="stream"></param>
    /// <returns></returns>
    protected virtual async Task<(byte[] Buffer, string FileExtension)> RecognizeImageAsync(
        Stream stream
    )
    {
        if (stream == null)
        {
            throw new ArgumentNullException(nameof(stream));
        }

        using var memory = new MemoryStream();
        await stream.CopyToAsync(memory);
        var buffer = memory.ToArray();

        var info = imageFormatDetector.Detect(buffer);

        if (!info.IsKnown)
        {
            throw new BusinessException("未获取到图像格式");
        }

        return (buffer, info.DefaultExtension);
    }

    /// <summary>
    /// 获取到的html源码转成markdown
    /// </summary>
    /// <param name="html"></param>
    /// <returns></returns>
    protected virtual string HtmlToMarkdown(string html)
    {
        var config = new Config
        {
            Tags = { Unknown = Config.UnknownTagsOption.Bypass },
            GithubFlavored = true,
            Flavor = Config.MarkdownFlavor.CommonMark,
            Formatting = { RemoveComments = true },
            Links = { SmartHref = true },
        };
        var converter = new Converter(config);
        var markdown = converter.Convert(html);
        return markdown;
    }

    /// <summary>
    /// 发布文章
    /// </summary>
    /// <param name="feedUrl">文章地址</param>
    /// <param name="batchId">批次ID</param>
    /// <param name="cancellationToken"></param>
    /// <returns></returns>
    protected virtual async Task PublishArticleAsync(
        string feedUrl,
        string? batchId = null,
        CancellationToken cancellationToken = default
    )
    {
        var article = new CreateArticleRequest
        {
            Title = "",
            Markdown = "",
            From = feedUrl,
            Tags = Tags,
        };

        var author = await GetArticleContentAsync(article, feedUrl);
        if (author == null)
        {
            return;
        }
        var useAiAnalyze = configuration.GetValue("ArticleUesAIAnalyze", false);
        try
        {
            if (useAiAnalyze)
            {
                await AnalyzeArticleAsync(article, cancellationToken);
            }

            var message = new NewsArticleMessage
            {
                Title = article.Title,
                Markdown = article.Markdown,
                Introduction = article.Introduction,
                From = article.From,
                PublishTime = article.PublishTime ?? DateTime.Now,
                Tags = article.Tags,
                Author = author,
                AdWeight = article.AdWeight,
                Source = "Dpz.Core.Web.Jobs",
                BatchId = batchId,
                MainImageMetadata = article.MainImageMetadata,
                Images = article.Images,
            };

            await _messagePublisher.PublishAsync(message, cancellationToken: cancellationToken);
            await PushProgressMessage($"已发布文章: {article.Title}");
            Interlocked.Increment(ref _sentMessageCount);
        }
        catch (Exception ex)
        {
            await deleteMarkdownMessagePublisher.PublishAsync(
                new DeleteMarkdownMessage { MarkdownContents = [article.Markdown] },
                cancellationToken: cancellationToken
            );
            _logger.LogError(ex, "发送文章消息失败: {Title}", article.Title);
        }
    }

    private async Task AnalyzeArticleAsync(
        CreateArticleRequest article,
        CancellationToken cancellationToken = default
    )
    {
        var prompt = BuildAnalysisPrompt();
        var result = await openAiService.SendMessageAsync(
            messages: [new SystemChatMessage(prompt), new UserChatMessage(article.Markdown)],
            options: option =>
            {
                option.Model = "deepseek-v4-flash";
            },
            cancellationToken: cancellationToken
        );

        if (!result.Success || result.Data == null)
        {
            _logger.LogWarning(
                "发送AI分析失败，错误消息：{Message}，参数：{@Arguments}",
                result.Message,
                result.Arguments
            );
            return;
        }

        if (
            !result.Data.TryDeserialize<ArticleAnalyze>(
                out var analyze,
                out var message,
                new JsonSerializerOptions { PropertyNameCaseInsensitive = true }
            )
            || analyze == null
        )
        {
            _logger.LogWarning("解析AI结果失败，错误消息：{Message}", message);
            return;
        }

        _logger.LogInformation("AI分析结果：{@Result}", analyze);

        if (!string.IsNullOrEmpty(analyze.Introduction))
        {
            article.Introduction = analyze.Introduction;
        }

        article.AdWeight = analyze.AdWeight;

        if (analyze.AdWeight is > 0.7 and < 0.8)
        {
            _logger.LogWarning("广告概率：{AdWeight}%", analyze.AdWeight * 100);
        }

        if (analyze.AdWeight >= 0.8)
        {
            var dic = new Dictionary<string, string> { { "From", article.From ?? "" } };
            using (_logger.BeginScope(dic))
            {
                _logger.LogWarning("广告概率：{AdWeight}%", analyze.AdWeight * 100);
            }
        }
        await Task.Delay(300, cancellationToken);
    }

    /// <summary>
    /// 构建 AI 分析提示词
    /// </summary>
    private static string BuildAnalysisPrompt()
    {
        const string json = """
            { "category": "分类","introduction": "文章摘要","adWeight": 0.00 }
            """;
        return new StringBuilder()
            .AppendLine("帮我分析一下文章，并严格以以下JSON格式返回。")
            .AppendLine()
            .AppendLine("```json")
            .AppendLine(json)
            .AppendLine("```")
            .AppendLine()
            .AppendLine("字段说明：")
            .AppendLine("1. category ：文章分类")
            .AppendLine("2. introduction ：文章摘要")
            .AppendLine(
                "3. adWeight ： 是否为广告，以权重来区分，权重包含小数，最小为0，即不是广告，最大为1，一定是广告"
            )
            .AppendLine()
            .AppendLine("------")
            .AppendLine("发送给你的内容是一篇新闻文章")
            .AppendLine()
            .AppendLine()
            .ToString();
    }

    /// <summary>
    /// 开始爬虫任务
    /// </summary>
    [ProlongExpirationTime]
    public async Task StartAsync()
    {
        _currentBatchId = $"batch_{DateTime.UtcNow:yyyyMMddHHmmss}_{Guid.NewGuid():N}";
        _sentMessageCount = 0;
        var batchStartTime = DateTime.UtcNow;

        _logger.LogInformation("爬虫任务开始, BatchId={BatchId}", _currentBatchId);
        try
        {
            var source = await GetTaskUrlsAsync();
            _logger.LogInformation("获取到{Count}条数据", source.Count);

            var parallelOptions = new ParallelOptions
            {
                CancellationToken = CancellationToken.None,
            };

            var totalCount = source.Count;
            var requestCounter = 0;
            var processedCount = 0;

            await Parallel.ForEachAsync(
                source,
                parallelOptions,
                async (item, cancelToken) =>
                {
                    await _concurrencyLimiter.WaitAsync(cancelToken);
                    try
                    {
                        var current = Interlocked.Increment(ref processedCount);
                        var newProgress = (decimal)current / totalCount;

                        await _progressSemaphore.WaitAsync(cancelToken);
                        try
                        {
                            if (newProgress > Progress)
                            {
                                Progress = newProgress;
                            }
                        }
                        finally
                        {
                            _progressSemaphore.Release();
                        }

                        var myCount = Interlocked.Increment(ref requestCounter);
                        if (myCount % 3 == 0)
                        {
                            const int delay = 1500;
                            await PushProgressMessage(
                                $"等待{delay / 1000m}秒后继续执行",
                                MessageType.Info
                            );
                            await Task.Delay(delay, cancelToken);
                        }

                        await PublishArticleAsync(item, _currentBatchId, cancelToken);
                    }
                    finally
                    {
                        _concurrencyLimiter.Release();
                    }
                }
            );
        }
        catch (Exception exception)
        {
            _logger.LogError(exception, "任务异常结束");
            return;
        }
        finally
        {
            var batchEndTime = DateTime.UtcNow;

            _logger.LogInformation(
                "爬虫任务结束, BatchId={BatchId}, 成功发送{SentCount}条消息",
                _currentBatchId,
                _sentMessageCount
            );

            if (_sentMessageCount > 0)
            {
                var batchCompletionMessage = new BatchCompletionMessage
                {
                    BatchId = _currentBatchId,
                    TotalMessages = _sentMessageCount,
                    BatchType = MessageQueueBusinessType.Article,
                    StartTime = batchStartTime,
                    EndTime = batchEndTime,
                    Source = "Dpz.Core.Web.Jobs",
                    Metadata = new Dictionary<string, string>
                    {
                        ["Duration"] = (batchEndTime - batchStartTime).TotalSeconds.ToString("F2"),
                        ["Tags"] = string.Join(",", Tags),
                    },
                };

                await _batchCompletionPublisher.PublishAsync(batchCompletionMessage);

                _logger.LogInformation(
                    "批次完成消息已发送, BatchId={BatchId}, TotalMessages={TotalMessages}",
                    _currentBatchId,
                    _sentMessageCount
                );
            }
        }

        await PushProgressMessage("爬虫任务结束", MessageType.Over);
        _logger.LogInformation("爬虫任务结束");
    }

    public override object ActivateJob(Type jobType)
    {
        _logger.LogInformation("invoke activate job");
        return base.ActivateJob(jobType);
    }

    [ProlongExpirationTime]
    public async Task DeleteAsync()
    {
        await ArticleService.DeleteOldCnBetaAsync(12, 50);
    }
}