using System;

using System.Collections.Concurrent;

using System.Threading.Tasks;

​

// A thread-safe message queue

public class MessageQueue<T>

{

    private readonly ConcurrentQueue<T> _queue = new ConcurrentQueue<T>();

​

    /// <summary>

    /// Adds a message to the queue.

    /// </summary>

    public void Enqueue(T message)

    {

        _queue.Enqueue(message);

    }

​

    /// <summary>

    /// Attempts to remove a message from the queue.

    /// </summary>

    public bool TryDequeue(out T message)

    {

        return _queue.TryDequeue(out message);

    }

}

​

// Define the CloudEvent type

public class CloudEvent

{

    public string Id { get; set; }

    public string Source { get; set; } // Source of the event (e.g., service name)

    public string Type { get; set; } // Type of the event (e.g., "com.example.object.created")

    public DateTime Time { get; set; } // Timestamp of the event

    public object Data { get; set; } // Event payload

​

    public override string ToString()

    {

        return $"CloudEvent(Id={Id}, Source={Source}, Type={Type}, Time={Time}, Data={Data})";

    }

}

​

// Coding Challenge Instructions:

// =======================================

// You are tasked with designing and implementing a generic event system that uses the provided

// MessageQueue<T> and the CloudEvent class as the backbone for communication. Follow the steps below:

//

// 1. Design Interfaces:

//    - Define two interfaces:

//        a) An interface for an event producer that sends CloudEvent messages to a destination.

//        b) An interface for an event consumer that processes CloudEvent messages from a source.

//    - Ensure your interfaces are generic, reusable, and work specifically with the CloudEvent type.

//

// 2. Implement the Interfaces:

//    - Create classes that implement the producer and consumer interfaces.

//    - The producer should add CloudEvent messages to the provided MessageQueue<T>.

//    - The consumer should poll and process CloudEvent messages from the MessageQueue<T>.

//

// 3. Demonstrate the Implementation:

//    - In the Main method:

//        a) Create a message queue for CloudEvent objects.

//        b) Instantiate the producer and consumer.

//        c) Use the producer to send several CloudEvent messages.

//        d) Use the consumer to process these messages.

//    - Ensure the consumer processes all messages added by the producer.

//

// Example Output:

// =======================================

// Sending CloudEvent: CloudEvent(Id=1, Source=/service, Type=com.example.object.created, Time=2024-01-01, Data=Sample Data)

// Sending CloudEvent: CloudEvent(Id=2, Source=/service, Type=com.example.object.updated, Time=2024-01-01, Data=Another Data)

// Processing CloudEvent: CloudEvent(Id=1, Source=/service, Type=com.example.object.created, Time=2024-01-01, Data=Sample Data)

// Processing CloudEvent: CloudEvent(Id=2, Source=/service, Type=com.example.object.updated, Time=2024-01-01, Data=Another Data)

​

// Define your interfaces here

​

// Implement your producer and consumer classes here

​

public class Program

{

    public static async Task Main(string[] args)

    {

        // Step 1: Create a message queue for CloudEvent

        var messageQueue = new MessageQueue<CloudEvent>();

​

        // Step 2: Create an instance of your producer

        // IEventProducer<CloudEvent> producer = new YourProducerImplementation(messageQueue);

​

        // Step 3: Create an instance of your consumer

        // IEventConsumer<CloudEvent> consumer = new YourConsumerImplementation(messageQueue);

​

        // Step 4: Use the producer to send CloudEvent messages

        // Example:

        // var cloudEvent1 = new CloudEvent { Id = "1", Source = "/service", Type = "com.example.object.created", Time = DateTime.UtcNow, Data = "Sample Data" };

        // var cloudEvent2 = new CloudEvent { Id = "2", Source = "/service", Type = "com.example.object.updated", Time = DateTime.UtcNow, Data = "Another Data" };

        // await producer.SendEventAsync("Destination", cloudEvent1);

        // await producer.SendEventAsync("Destination", cloudEvent2);

​

        // Step 5: Use the consumer to process messages

        // Example:

        // await consumer.StartConsumingAsync("Source");

​

        // Expected output:

        // Sending CloudEvent: CloudEvent(Id=1, Source=/service, Type=com.example.object.created, Time=2024-01-01, Data=Sample Data)

        // Sending CloudEvent: CloudEvent(Id=2, Source=/service, Type=com.example.object.updated, Time=2024-01-01, Data=Another Data)

        // Processing CloudEvent: CloudEvent(Id=1, Source=/service, Type=com.example.object.created, Time=2024-01-01, Data=Sample Data)

        // Processing CloudEvent: CloudEvent(Id=2, Source=/service, Type=com.example.object.updated, Time=2024-01-01, Data=Another Data)

    }

}

​