using System;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
using Windows.ApplicationModel.AppService;
using Windows.Foundation.Collections;
using Wino.Core.Domain.Interfaces;
using Wino.Core.Domain.Models.Server;
using Wino.Messaging;

namespace Wino.Server.Core
{
    public abstract class ServerMessageHandlerBase
    {
        public string HandlingRequestType { get; }

        public abstract Task ExecuteAsync(IClientMessage message, AppServiceRequest request = null, CancellationToken cancellationToken = default);
    }

    public abstract class ServerMessageHandler<TClientMessage, TResponse> : ServerMessageHandlerBase where TClientMessage : IClientMessage
    {
        /// <summary>
        /// Response to return when server encounters and exception while executing code.
        /// </summary>
        /// <param name="ex">Exception that target threw.</param>
        /// <returns>Default response on failure object.</returns>
        public abstract WinoServerResponse<TResponse> FailureDefaultResponse(Exception ex);


        /// <summary>
        /// Safely executes the handler code and returns the response.
        /// This call will never crash the server. Exceptions encountered will be handled and returned as response.
        /// </summary>
        /// <param name="message">IClientMessage that client asked the response for from the server.</param>
        /// <param name="request">optional AppServiceRequest to return response for.</param>
        /// <param name="cancellationToken">Cancellation token.</param>
        /// <returns>Response object that server executes for the given method.</returns>
        public override async Task ExecuteAsync(IClientMessage message, AppServiceRequest request = null, CancellationToken cancellationToken = default)
        {
            WinoServerResponse<TResponse> response = default;

            try
            {
                response = await HandleAsync((TClientMessage)message, cancellationToken).ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                response = FailureDefaultResponse(ex);
            }
            finally
            {
                // No need to send response if request is null.
                // Handler might've been called directly from the server itself.
                if (request != null)
                {
                    var valueSet = new ValueSet()
                    {
                        { MessageConstants.MessageDataKey, JsonSerializer.Serialize(response) }
                    };

                    await request.SendResponseAsync(valueSet);
                }
            }
        }

        /// <summary>
        /// Code that will be executed directly on the server.
        /// All handlers must implement this method.
        /// Response is wrapped with WinoServerResponse.
        /// </summary>
        /// <param name="message">IClientMessage that client asked the response for from the server.</param>
        /// <param name="cancellationToken">Cancellation token.</param>
        protected abstract Task<WinoServerResponse<TResponse>> HandleAsync(TClientMessage message, CancellationToken cancellationToken = default);
    }
}