using System.Drawing.Imaging;
using System.IO;
using System.Net;
using Azaion.Common.Database;
using Azaion.Common.DTO;
using Azaion.Common.DTO.Config;
using Azaion.Common.DTO.Queue;
using Azaion.Common.Extensions;
using Azaion.CommonSecurity.DTO;
using Azaion.CommonSecurity.Services;
using LinqToDB;
using LinqToDB.Data;
using MediatR;
using MessagePack;
using Microsoft.Extensions.Options;
using Newtonsoft.Json;
using RabbitMQ.Stream.Client;
using RabbitMQ.Stream.Client.Reliable;

namespace Azaion.Common.Services;

public class AnnotationService
{
    private readonly AzaionApiClient _apiClient;
    private readonly IDbFactory _dbFactory;
    private readonly FailsafeAnnotationsProducer _producer;
    private readonly IGalleryService _galleryService;
    private readonly IMediator _mediator;
    private readonly IHardwareService _hardwareService;
    private readonly QueueConfig _queueConfig;
    private Consumer _consumer = null!;

    public AnnotationService(AzaionApiClient apiClient,
        IDbFactory dbFactory,
        FailsafeAnnotationsProducer producer,
        IOptions<QueueConfig> queueConfig,
        IGalleryService galleryService,
        IMediator mediator,
        IHardwareService hardwareService)
    {
        _apiClient = apiClient;
        _dbFactory = dbFactory;
        _producer = producer;
        _galleryService = galleryService;
        _mediator = mediator;
        _hardwareService = hardwareService;
        _queueConfig = queueConfig.Value;

        Task.Run(async () => await Init()).Wait();
    }

    private async Task Init(CancellationToken cancellationToken = default)
    {
        var consumerSystem = await StreamSystem.Create(new StreamSystemConfig
        {
            Endpoints = new List<EndPoint>{new DnsEndPoint(_queueConfig.Host, _queueConfig.Port)},
            UserName = _queueConfig.ConsumerUsername,
            Password = _queueConfig.ConsumerPassword
        });
        var offset = (await _dbFactory.Run(db => db.QueueOffsets.FirstOrDefaultAsync(
            x => x.QueueName == Constants.MQ_ANNOTATIONS_QUEUE, token: cancellationToken))
            )?.Offset ?? 0;
        _consumer = await Consumer.Create(new ConsumerConfig(consumerSystem, Constants.MQ_ANNOTATIONS_QUEUE)
        {
            Reference = _hardwareService.GetHardware().Hash,
            OffsetSpec = new OffsetTypeOffset(offset + 1),
            MessageHandler = async (stream, consumer, context, message) =>
            {
                await Consume(MessagePackSerializer.Deserialize<AnnotationCreatedMessage>(message.Data.Contents), cancellationToken);
                await _dbFactory.Run(async db => await db.QueueOffsets
                    .Where(x => x.QueueName == Constants.MQ_ANNOTATIONS_QUEUE)
                    .Set(x => x.Offset, context.Offset)
                    .UpdateAsync(token: cancellationToken));

                await ThrottleExt.ThrottleRunAfter(() =>
                {
                    _dbFactory.SaveToDisk();
                    return Task.CompletedTask;
                }, TimeSpan.FromSeconds(3), cancellationToken);

            }
        });
    }

    //AI / Manual
    public async Task SaveAnnotation(string fName, string imageExtension, List<Detection> detections, SourceEnum source, Stream? stream = null, CancellationToken token = default) =>
        await SaveAnnotationInner(DateTime.UtcNow, fName, imageExtension, detections, source, stream, _apiClient.User.Role, _apiClient.User.Email, token);

    //Manual
    public async Task ValidateAnnotation(Annotation annotation, CancellationToken token = default) =>
        await SaveAnnotationInner(DateTime.UtcNow, annotation.Name, annotation.ImageExtension, annotation.Detections.ToList(), SourceEnum.Manual, null, _apiClient.User.Role, _apiClient.User.Email, token);

    //Queue (only from operators)
    public async Task Consume(AnnotationCreatedMessage message, CancellationToken cancellationToken = default)
    {
        if (message.CreatedRole != RoleEnum.Operator) //Process only operator's messages
            return;

        await SaveAnnotationInner(
            message.CreatedDate,
            message.Name,
            message.ImageExtension,
            JsonConvert.DeserializeObject<List<Detection>>(message.Detections) ?? [],
            message.Source,
            new MemoryStream(message.Image),
            message.CreatedRole,
            message.CreatedEmail,
            cancellationToken);
    }

    private async Task SaveAnnotationInner(DateTime createdDate, string fName, string imageExtension, List<Detection> detections, SourceEnum source, Stream? stream,
        RoleEnum userRole,
        string createdEmail,
        CancellationToken token = default)
    {
        //Flow for roles:
        // Operator or (AI from any role) -> Created
        // Validator, Admin & Manual -> Validated

        AnnotationStatus status;

        var annotation = await _dbFactory.Run(async db =>
        {
            var ann = await db.Annotations.FirstOrDefaultAsync(x => x.Name == fName, token: token);
            status = userRole.IsValidator() && source == SourceEnum.Manual
                ? AnnotationStatus.Validated
                : AnnotationStatus.Created;

            await db.Detections.DeleteAsync(x => x.AnnotationName == fName, token: token);
            await db.BulkCopyAsync(detections, cancellationToken: token);
            if (ann != null)
                await db.Annotations
                    .Where(x => x.Name == fName)
                    .Set(x => x.Source, source)
                    .Set(x => x.AnnotationStatus, status)
                    .UpdateAsync(token: token);
            else
            {
                ann = new Annotation
                {
                    CreatedDate = createdDate,
                    Name = fName,
                    ImageExtension = imageExtension,
                    CreatedEmail = createdEmail,
                    CreatedRole = userRole,
                    AnnotationStatus = status,
                    Source = source,
                    Detections = detections
                };
                await db.InsertAsync(ann, token: token);
            }
            return ann;
        });

        if (stream != null)
        {
            var img = System.Drawing.Image.FromStream(stream);
            img.Save(annotation.ImagePath, ImageFormat.Jpeg); //todo: check png images coming from queue
        }
        await YoloLabel.WriteToFile(detections, annotation.LabelPath, token);
        await _galleryService.CreateThumbnail(annotation, token);
        await _producer.SendToQueue(annotation, token);

        await _mediator.Publish(new AnnotationCreatedEvent(annotation), token);
        await ThrottleExt.ThrottleRunAfter(() =>
        {
            _dbFactory.SaveToDisk();
            return Task.CompletedTask;
        }, TimeSpan.FromSeconds(5), token);
    }
}