using FitConnect.Interfaces;
using FitConnect.Models;

namespace FitConnect;

public class EncryptedSubmissionBuilder : IEncryptedBuilderWithData,
    IEncryptedBuilderWithMetadata, IEncryptedBuilderWithAttachments,
    IEncryptedBuilderWithDestination, IEncryptedBuilderWithService {
    private Uri? SchemaUri { get; set; }

    private readonly SendableEncryptedSubmission _submission;

    internal EncryptedSubmissionBuilder() {
        _submission = new SendableEncryptedSubmission();
    }


    public SendableEncryptedSubmission Build() {
        _submission.SchemaUri = SchemaUri;
        return _submission;
    }


    public IEncryptedBuilderWithAttachments AddEncryptedAttachment(Guid id, string content) {
        _submission.Attachments ??= new Dictionary<Guid, string>();
        _submission.Attachments.Add(id, content);
        return this;
    }

    public IEncryptedBuilderWithAttachments AddEncryptedAttachments(
        Dictionary<Guid, string> attachments) {
        _submission.Attachments ??= new Dictionary<Guid, string>();

        foreach (var (id, data) in attachments) {
            _submission.Attachments.Add(id, data);
        }

        return this;
    }

    public IEncryptedBuilderWithAttachments AddEncryptedAttachments(
        params EncryptedAttachment[] attachments) {
        _submission.Attachments ??= new Dictionary<Guid, string>();

        foreach (var attachment in attachments) {
            var (id, data) = attachment.Deconstruct();
            _submission.Attachments.Add(id, data);
        }

        return this;
    }

    public IEncryptedBuilderWithService
        SetServiceType(string serviceIdentifier, string serviceName) {
        _submission.ServiceName = serviceName;
        _submission.ServiceIdentifier = serviceIdentifier;
        return this;
    }

    public IEncryptedBuilderWithData SetEncryptedData(string data) {
        _submission.Data = data;
        return this;
    }


    public IEncryptedBuilderWithMetadata SetEncryptedMetadata(string metadata) {
        _submission.Metadata = metadata;
        return this;
    }

    /// <summary>
    /// Set the destination where the submission should be sent to.
    /// </summary>
    /// <param name="destinationId">Guid of the destination</param>
    /// <returns></returns>
    public IEncryptedBuilderWithDestination SetDestination(Guid destinationId) {
        _submission.DestinationId = destinationId;
        return this;
    }
}

public interface IEncryptedBuilderWithDestination {
    /// <summary>
    /// Setting the service identifier and service name for this submission.
    /// </summary>
    /// <remarks>This method overwrites a previously set value</remarks>
    /// <param name="serviceIdentifier">Service identifier urn for the submission</param>
    /// <param name="serviceName">An optional name for the Service</param>
    /// <returns></returns>
    IEncryptedBuilderWithService SetServiceType(string serviceIdentifier, string serviceName);
}

public interface IEncryptedBuilderWithService {
    
    /// <summary>
    /// Setting the encrypted metadata for this submission.
    /// </summary>
    /// <param name="metadata"><b>Encrypted</b> <see cref="Metadata"/></param>
    /// <returns></returns>
    IEncryptedBuilderWithMetadata SetEncryptedMetadata(string metadata);
}

public interface IEncryptedBuilderWithMetadata {
    
    /// <summary>
    /// Setting the encrypted data for this submission.
    /// </summary>
    /// <param name="data"><b>Encrypted</b> data</param>
    /// <returns></returns>
    IEncryptedBuilderWithData SetEncryptedData(string data);
}

public interface IEncryptedBuilderWithData {
    /// <summary>
    /// Adding encrypted attachments to this submission.
    /// </summary>
    /// <param name="attachments"><b>Encrypted</b> attachments</param>
    /// <returns></returns>
    IEncryptedBuilderWithAttachments AddEncryptedAttachments(Dictionary<Guid, string> attachments);
    
    /// <summary>
    /// Adding a single encrypted attachment to this submission.
    /// </summary>
    /// <param name="id">Guid of the attachment</param>
    /// <param name="content"><b>Encrypted</b> content data of the attachment</param>
    /// <returns></returns>
    IEncryptedBuilderWithAttachments AddEncryptedAttachment(Guid id, string content);
}

public interface IEncryptedBuilderWithAttachments {
    
    /// <summary>
    /// Build the submission out of the given data
    /// </summary>
    /// <returns>A sendable submission that can be transmitted via <see cref="ISender.SendAsync(FitConnect.SendableEncryptedSubmission)"/></returns>
    SendableEncryptedSubmission Build();
}