using System.Security;
using System.Text.RegularExpressions;
using System.Xml;
using Autofac;
using FitConnect.Encryption;
using FitConnect.Interfaces.Sender;
using FitConnect.Models;
using FitConnect.Models.Api.Metadata;
using FitConnect.Services.Models.v1.Submission;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using Attachment = FitConnect.Models.Attachment;
using Data = FitConnect.Models.Api.Metadata.Data;
using Metadata = FitConnect.Models.Metadata;
using Route = FitConnect.Services.Models.v1.Routes.Route;

namespace FitConnect;

/// <summary>
///     The fluent implementation for the <see cref="Sender" /> to encapsulate the FitConnect API.
/// </summary>
/// <example>
///     Reference for FluentSender
///     <code>
/// client.Sender
///     .Authenticate(clientId!, clientSecret!)
///     .CreateSubmission(new Submission { Attachments = new List() })
///     .UploadAttachments()
///     .WithData(data)
///     .Subm@it();
/// </code>
/// </example>
public class Sender : FitConnectClient, ISender {
    public string? PublicKey { get; set; }
    public Submission? Submission { get; set; }

    public Sender(FitConnectEnvironment environment, string clientId, string clientSecret,
        ILogger? logger = null) : base(environment, clientId, clientSecret, logger) {
    }

    public Sender(FitConnectEnvironment environment, string clientId, string clientSecret,
        IContainer container) : base(environment, clientId, clientSecret,
        container) {
    }


    public async Task<List<Route>> FindDestinationId(string leiaKey, string? ags = null,
        string? ars = null,
        string? areaId = null) {
        if (ags == null && ars == null && areaId == null)
            throw new ArgumentException("One of the following must be provided: ags, ars, areaId");

        var routes = await RouteService.GetDestinationIdAsync(leiaKey, ags, ars, areaId);
        Logger?.LogInformation("Received destinations: {Destinations}",
            routes.Select(d => d.DestinationId).Aggregate((a, b) => a + "," + b));
        return routes;
    }

    private async Task WithDestination(string destinationId) {
        if (!Regex.IsMatch(destinationId, GuidPattern))
            throw new ArgumentException("The destination must be a valid GUID");

        Submission = await CreateSubmission(destinationId);
    }

    public ISenderWithData WithJsonData(string data) {
        try {
            JsonConvert.DeserializeObject(data);
        }
        catch (Exception e) {
            throw new ArgumentException("The data must be valid JSON string", e);
        }


        Submission!.Data = data;
        Submission.DataMimeType = "application/json";
        return this;
    }

    public ISenderWithData WithXmlData(string data) {
        try {
            var doc = new XmlDocument();
            doc.LoadXml(data);
        }
        catch (Exception e) {
            throw new ArgumentException("The data must be valid XML string", e);
        }

        Submission!.Data = data;
        Submission.DataMimeType = "application/xml";
        return this;
    }


    async Task<Submission> Submit() {
        if (Submission == null) {
            Logger?.LogCritical("Submission is null on submit");
            throw new InvalidOperationException("Submission is not ready");
        }

        var metadata = CreateMetadata(Submission);
        Logger?.LogTrace("MetaData: {Metadata}", metadata);
        var valid = await JsonHelper.VerifyMetadata(metadata);
        if (!valid) {
            Logger?.LogError("Sending submission aborted due to validation errors");
            throw new InvalidOperationException("Submission is not ready");
        }

        Logger?.LogInformation("MetaData validation check, done");
        Logger?.LogInformation("Sending submission");
        var encryptedMeta = Encryption.Encrypt(metadata);
        Logger?.LogTrace("Encrypted metadata: {EncryptedMeta}", encryptedMeta);
        Submission.EncryptedMetadata = encryptedMeta;
        if (Submission.Data != null)
            Submission.EncryptedData = Encryption.Encrypt(Submission.Data);

        var result = await SubmissionService
            .SubmitSubmission(Submission.Id!, (SubmitSubmissionDto)Submission);

        Logger?.LogInformation("Submission sent");
        return Submission;
    }


    private void WithServiceType(string serviceName, string leikaKey) {
        if (string.IsNullOrWhiteSpace(leikaKey) || !Regex.IsMatch(leikaKey,
                LeikaKeyPattern)) {
            Logger?.LogError("The leikaKey must be a valid URN");
            throw new ArgumentException("Invalid leika key");
        }

        Submission!.ServiceType = new ServiceType {
            Name = serviceName,
            Identifier = leikaKey
        };
    }

    /// <summary>
    /// </summary>
    /// <param name="attachments"></param>
    /// <returns></returns>
    private async Task WithAttachments(params Attachment[] attachments) {
        await WithAttachments(attachments.ToList());
    }


    /// <summary>
    /// </summary>
    /// <param name="attachments"></param>
    /// <returns></returns>
    /// <exception cref="InvalidOperationException"></exception>
    /// <exception cref="ArgumentException"></exception>
    private async Task WithAttachments(IEnumerable<Attachment> attachments) {
        Submission!.Attachments = new List<Attachment>();
        foreach (var attachment in attachments) Submission!.Attachments.Add(attachment);

        if (Submission.ServiceType == null) {
            Logger?.LogError("Submission has no service type");
            throw new ArgumentException("Submission has no service type");
        }

        var created = await SubmissionService.CreateSubmission((CreateSubmissionDto)Submission);
        Submission.Id = created.SubmissionId;
        Submission.CaseId = created.CaseId;

        Logger?.LogInformation("Submission Id {CreatedSubmissionId}, CaseId {SubmissionCaseId}",
            created.SubmissionId, Submission.CaseId);

        var encryptedAttachments = Encrypt(PublicKey!, Submission.Attachments);
        await UploadAttachments(Submission.Id!, encryptedAttachments);
    }

    public ISenderWithDestination FindDestinationId(Destination destination) {
        throw new NotImplementedException();
    }

    /// <summary>
    ///     Creates a new <see cref="Submission" /> on the FitConnect server.
    /// </summary>
    /// <param name="destinationId">The id of the destination the submission has to be sent to</param>
    /// <returns></returns>
    /// <exception cref="InvalidOperationException">If sender is not authenticated</exception>
    /// <exception cref="ArgumentException">If submission is not ready to be sent</exception>
    private async Task<Submission> CreateSubmission(string destinationId) {
        PublicKey = await GetPublicKeyFromDestination(destinationId);
        Encryption = new FitEncryption(Logger) { PublicKeyEncryption = PublicKey };

        var submission = new Submission {
            DestinationId = destinationId
        };

        return submission;
    }

    internal async Task<string> GetPublicKeyFromDestination(string destinationId) {
        var publicKey = await DestinationService.GetPublicKey(destinationId);

        var keyIsValid = new CertificateHelper(Logger).ValidateCertificate(publicKey,
            VerifiedKeysAreMandatory ? LogLevel.Error : LogLevel.Warning);
        if (VerifiedKeysAreMandatory && !keyIsValid)
            throw new SecurityException("Public key is not trusted");

        return publicKey;
    }

    /// <summary>
    ///     Create Metadata incl. Hash
    /// </summary>
    /// <param name="submission"></param>
    /// <returns></returns>
    internal static string CreateMetadata(Submission submission) {
        var data = new Data {
            Hash = new DataHash {
                Type = "sha512",
                Content = FitEncryption.CalculateHash(submission.Data ?? "")
            },

            SubmissionSchema = new Fachdatenschema {
                SchemaUri = submission.ServiceType.Identifier,
                MimeType = submission.DataMimeType
            }
        };
        var contentStructure = new ContentStructure {
            Data = data,
            Attachments = submission.Attachments.Select(a =>
                new Models.Api.Metadata.Attachment {
                    Description = a.Description,
                    AttachmentId = a.Id,
                    MimeType = a.MimeType,
                    Filename = a.Filename,
                    Purpose = "attachment",
                    Hash = new AttachmentHash {
                        Type = "sha512",
                        Content = a.Hash
                    }
                }).ToList()
        };

        var metaData = new Metadata {
            ContentStructure = contentStructure
        };
        return JsonConvert.SerializeObject(metaData);
    }
    

    /// <summary>
    /// Finding Areas
    /// </summary>
    /// <param name="filter"></param>
    /// <param name="offset"></param>
    /// <param name="limit"></param>
    /// <returns></returns>
    public async Task<IEnumerable<Area>> GetAreas(string filter, int offset = 0,
        int limit = 100) {
        var dto = await RouteService.GetAreas(filter, offset, limit);
        // totalCount = dto?.TotalCount ?? 0;
        return dto?.Areas ?? new List<Area>();
    }

    /// <summary>
    ///     Uploading the encrypted data to the server
    /// </summary>
    /// <param name="submissionId">Submissions ID</param>
    /// <param name="encryptedAttachments">Encrypted attachments with id and content</param>
    private async Task<bool> UploadAttachments(string submissionId,
        Dictionary<string, string> encryptedAttachments) {
        try {
            foreach (var (id, content) in encryptedAttachments) {
                Logger?.LogInformation("Uploading attachment {Id}", id);
                await SubmissionService.UploadAttachment(submissionId, id, content);
            }

            return true;
        }
        catch (Exception e) {
            Logger?.LogError("Error Uploading attachment {message}", e.Message);
            throw;
        }
    }

    public async Task<Submission> SendAsync(SendableSubmission submission) {
        if (submission.DestinationId == null)
            throw new ArgumentNullException(nameof(SendableSubmission.DestinationId));

        if (submission.ServiceName == null)
            throw new ArgumentNullException(nameof(SendableSubmission.ServiceName));

        if (submission.LeikaKey == null)
            throw new ArgumentNullException(nameof(SendableSubmission.LeikaKey));

        if (submission.Attachments == null)
            throw new ArgumentNullException(nameof(SendableSubmission.Attachments));

        if (submission.Data == null)
            throw new ArgumentNullException(nameof(SendableSubmission.Data));

        await WithDestination(submission.DestinationId);
        WithServiceType(submission.ServiceName, submission.LeikaKey);
        await WithAttachments(submission.Attachments);
        WithData(submission.Data);
        return await Submit();
    }
}