[AppService("MyAppService")]
public interface IMyAppService
{
    Task<int> SumNumbersAsync(int x, int y);
}

public sealed partial class MyAppService : IMyAppService
{
    public async Task<int> SumNumbersAsync(int x, int y)
    {
        return x + y;
    }
}

int result = await App.Services.GetRequiredService<IMyAppService>().SumNumbersAsync(40, 2); // 42

namespace CommunityToolkit.AppServices;

[AttributeUsage(AttributeTargets.Interface, AllowMultiple = false, Inherited = false)]
public sealed class AppServiceAttribute : Attribute
{
    public AppServiceAttribute(string appServiceName);

    public string AppServiceName { get; }
}

[AttributeUsage(AttributeTargets.ReturnValue | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
public sealed class ValueSetSerializerAttribute : Attribute
{
    public ValueSetSerializerAttribute(Type valueSetSerializerType);

    public Type ValueSetSerializerType { get; }
}

public interface IValueSetSerializer<T>
{
    [return: NotNullIfNotNull("value")]
    ValueSet? Serialize(T? value);
    
    [return: NotNullIfNotNull("valueSet")]
    T? Deserialize(ValueSet? valueSet);
}

public enum AppServiceStatus
{
    Ok,
    Error,
    ActionNotFound,
    NoResponse,
    InvalidRequest,
    InvalidResponse,
    MismatchedResponseType,
    SerializationError,
    CantSend,
    AppServiceNotCompatible,
    Timeout,
    Canceled,
    CantStart
}

public sealed class AppServiceException : Exception
{
    public AppServiceStatus Status { get; }
}

public abstract class AppServiceHost
{
    protected AppServiceHost(string appServiceName);

    public bool OnBackgroundActivated(BackgroundActivatedEventArgs args);

    protected AppServiceRequest CreateAppServiceRequest([CallerMemberName] string? requestName = null);

    protected sealed class AppServiceRequest
    {
        public AppServiceRequest(AppServiceHost host, string requestName);

        public AppServiceRequest WithParameter<T>(T parameter, [CallerArgumentExpression("parameter")] string? parameterName = null);
        public AppServiceRequest WithParameter<TSerializer, TParameter>(TSerializer serializer, TParameter? parameter, [CallerArgumentExpression("parameter")] string? parameterName = null) where TSerializer : IValueSetSerializer<TParameter>;
        public AppServiceRequest WithProgress<T>(IProgress<T> progress);
        public AppServiceRequest WithProgress<TSerializer, TResult>(TSerializer serializer, IProgress<TResult?> progress) where TSerializer : IValueSetSerializer<TResult>;
        public AppServiceRequest WithCancellationToken(CancellationToken cancellationToken);

        public Task SendAndWaitForResultAsync();
        public Task<T> SendAndWaitForResultAsync<T>();
        public Task<TResult?> SendAndWaitForResultAsync<TSerializer, TResult>(TSerializer serializer) where TSerializer : IValueSetSerializer<TResult>;
        public Task SendAndWaitForResultAsync(TimeSpan timeout);
        public Task<T> SendAndWaitForResultAsync<T>(TimeSpan timeout);
        public Task<TResult?> SendAndWaitForResultAsync<TSerializer, TResult>(TSerializer serializer, TimeSpan timeout) where TSerializer : IValueSetSerializer<TResult>;
    }
}

public abstract class AppServiceComponent : IDisposable
{
    public event EventHandler? ConnectionFailed;
    public event EventHandler? ConnectionClosed;

    protected AppServiceComponent(string appServiceName);

    public async Task InitializeAppService();

    public void Dispose();

    protected void RegisterEndpoint(Action endpoint, [CallerArgumentExpression("endpoint")] string? endpointName = null);
    protected void RegisterEndpoint<T>(Func<T> endpoint, [CallerArgumentExpression("endpoint")] string? endpointName = null);
    protected void RegisterEndpoint<TSerializer, TResult>(TSerializer serializer, Func<TResult?> endpoint, [CallerArgumentExpression("endpoint")] string? endpointName = null) where TSerializer : IValueSetSerializer<TResult>;
    protected void RegisterEndpoint(Action<AppServiceParameters> endpoint, [CallerArgumentExpression("endpoint")] string? endpointName = null);
    protected void RegisterEndpoint<T>(Func<AppServiceParameters, T> endpoint, [CallerArgumentExpression("endpoint")] string? endpointName = null);
    protected void RegisterEndpoint<TSerializer, TResult>(TSerializer serializer, Func<AppServiceParameters, TResult?> endpoint, [CallerArgumentExpression("endpoint")] string? endpointName = null) where TSerializer : IValueSetSerializer<TResult>;
    protected void RegisterEndpoint(Func<Task> endpoint, [CallerArgumentExpression("endpoint")] string? endpointName = null);
    protected void RegisterEndpoint<T>(Func<Task<T>> endpoint, [CallerArgumentExpression("endpoint")] string? endpointName = null);
    protected void RegisterEndpoint<TSerializer, TResult>(TSerializer serializer, Func<Task<TResult?>> endpoint, [CallerArgumentExpression("endpoint")] string? endpointName = null) where TSerializer : IValueSetSerializer<TResult>; 
    protected void RegisterEndpoint(Func<AppServiceParameters, Task> endpoint, [CallerArgumentExpression("endpoint")] string? endpointName = null);    
    protected void RegisterEndpoint<T>(Func<AppServiceParameters, Task<T>> endpoint, [CallerArgumentExpression("endpoint")] string? endpointName = null);    
    protected void RegisterEndpoint<TSerializer, TResult>(TSerializer serializer, Func<AppServiceParameters, Task<TResult?>> endpoint, [CallerArgumentExpression("endpoint")] string? endpointName = null) where TSerializer : IValueSetSerializer<TResult>;

    protected readonly struct AppServiceParameters
    {
        public AppServiceParameters(AppServiceComponent component, AppServiceConnection connection, ValueSet valueSet);

        public void GetParameter<T>(out T parameter, [CallerArgumentExpression("parameter")] string? parameterName = null);
        public void GetParameter<TSerializer, TParameter>(TSerializer serializer, out TParameter? parameter, [CallerArgumentExpression("parameter")] string? parameterName = null) where TSerializer: IValueSetSerializer<TParameter>;
        
        public void GetProgress<T>(out IProgress<T> progress);
        public void GetProgress<TSerializer, TResult>(TSerializer serializer, out IProgress<TResult?> progress) where TSerializer : IValueSetSerializer<TResult>;            
        
        public void GetCancellationToken(out CancellationToken cancellationToken);
    }
}