using System.Diagnostics;
using BfiMonitor;
using Microsoft.Extensions.Logging;
using Microsoft.Playwright;
using Quartz;

[DisallowConcurrentExecution]
internal sealed class CheckMonitoringJob(
    PlaywrightBrowserService browserService,
    ScreeningRepository repository,
    ILogger<CheckMonitoringJob> logger,
    TimeProvider timeProvider
) : IJob
{
    public async Task Execute(IJobExecutionContext context)
    {
        var monitorId = context.MergedJobDataMap.GetInt("monitorId");
        var force = context.MergedJobDataMap.GetBoolean("force");

        using var activity = Tracing.StartCheckerJobForMonitor(monitorId);
        activity?.SetTag("Force", force);

        var monitor = await repository.GetMonitoringByIdAsync(monitorId, context.CancellationToken);
        if (monitor is null)
        {
            logger.LogMonitoringNotFound(monitorId);
            activity?.SetTag("EndReason", "MonitoringNotFound");
            activity?.SetStatus(ActivityStatusCode.Ok);
            return;
        }

        activity?.SetTag("MonitorUrl", monitor.Url);

        if (monitor.ArchivedAt is not null)
        {
            logger.LogMonitoringArchived(monitorId);
            activity?.SetTag("EndReason", "MonitoringArchived");
            activity?.SetStatus(ActivityStatusCode.Ok);
            return;
        }

        if (monitor.PausedAt is not null && !force)
        {
            logger.LogMonitoringPaused(monitorId);
            activity?.SetTag("EndReason", "MonitoringPaused");
            activity?.SetStatus(ActivityStatusCode.Ok);
            return;
        }

        var latestHtml = await repository.LatestHtml(monitor.Id, context.CancellationToken);
        logger.LogLatestHtml(monitor.Id, latestHtml);

        var page = await browserService.NewPageAsync();
        try
        {
            logger.LogFetchingSite(monitor.Id, monitor.Url);
            await page.GotoAsync(
                monitor.Url,
                new() { WaitUntil = WaitUntilState.DOMContentLoaded, Timeout = TimeSpan.FromSeconds(45).Milliseconds }
            );
            await Task.Delay(TimeSpan.FromSeconds(2));
            var resultsElement = await page.WaitForSelectorAsync(monitor.Selector);
            if (resultsElement is null)
            {
                logger.LogNoResultsElementFound(monitor.Id, monitor.Selector);
                activity?.SetTag("EndReason", "NoResultsElementFound");
                activity?.SetStatus(ActivityStatusCode.Ok);
                return;
            }

            var currentHtml = await resultsElement.InnerHTMLAsync();
            logger.LogCurrentHtml(monitor.Id, currentHtml);

            if (currentHtml == latestHtml)
            {
                logger.LogHtmlNotUpdated(monitor.Id);
                activity?.SetTag("EndReason", "HtmlNotUpdated");
                activity?.SetStatus(ActivityStatusCode.Ok);
                return;
            }

            logger.LogHtmlUpdated(monitor.Id);
            await repository.InsertNewDetection(
                monitor.Id,
                currentHtml,
                timeProvider.GetUtcNow(),
                context.CancellationToken
            );

            var label = string.IsNullOrWhiteSpace(monitor.Name) ? monitor.Url : monitor.Name;
            var message = $"Site updated: {label}";
            foreach (var phoneNumber in monitor.PhoneNumbers)
            {
                var dataMap = new JobDataMap { { "phoneNumber", phoneNumber }, { "message", message } };
                var trigger = TriggerBuilder.Create().ForJob(SendSmsJob.Key).UsingJobData(dataMap).StartNow().Build();
                await context.Scheduler.ScheduleJob(trigger, context.CancellationToken);
                logger.LogSmsScheduled(phoneNumber);
            }

            activity?.SetTag("EndReason", "ChangeDetected");
            activity?.SetStatus(ActivityStatusCode.Ok);
        }
        catch (Exception ex)
        {
            activity?.SetTag("EndReason", "Exception");
            activity?.SetStatus(ActivityStatusCode.Error, ex.Message);
            activity?.AddException(ex);
            throw;
        }
        finally
        {
            await page.CloseAsync();
        }
    }
}

internal static partial class CheckMonitoringJobLoggerExtensions
{
    [LoggerMessage(LogLevel.Information, "Monitor {MonitorId}: not found, skipping check")]
    public static partial void LogMonitoringNotFound(this ILogger logger, int monitorId);

    [LoggerMessage(LogLevel.Information, "Monitor {MonitorId}: archived, skipping check")]
    public static partial void LogMonitoringArchived(this ILogger logger, int monitorId);

    [LoggerMessage(LogLevel.Information, "Monitor {MonitorId}: paused, skipping scheduled check")]
    public static partial void LogMonitoringPaused(this ILogger logger, int monitorId);

    [LoggerMessage(LogLevel.Information, "Monitor {MonitorId}: latest HTML was {LatestHtml}")]
    public static partial void LogLatestHtml(this ILogger logger, int monitorId, string? latestHtml);

    [LoggerMessage(LogLevel.Warning, "Monitor {MonitorId}: no {ElementSelector} element found")]
    public static partial void LogNoResultsElementFound(this ILogger logger, int monitorId, string elementSelector);

    [LoggerMessage(LogLevel.Information, "Monitor {MonitorId}: fetching {Url}")]
    public static partial void LogFetchingSite(this ILogger logger, int monitorId, string url);

    [LoggerMessage(LogLevel.Information, "Monitor {MonitorId}: current HTML is {CurrentHtml}")]
    public static partial void LogCurrentHtml(this ILogger logger, int monitorId, string? currentHtml);

    [LoggerMessage(LogLevel.Information, "Monitor {MonitorId}: HTML has not changed")]
    public static partial void LogHtmlNotUpdated(this ILogger logger, int monitorId);

    [LoggerMessage(LogLevel.Information, "Monitor {MonitorId}: HTML has changed")]
    public static partial void LogHtmlUpdated(this ILogger logger, int monitorId);

    [LoggerMessage(LogLevel.Information, "Scheduled SMS to {PhoneNumber}")]
    public static partial void LogSmsScheduled(this ILogger logger, string phoneNumber);
}