// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
 
using System;
using System.ServiceModel;
using System.ServiceModel.Description;
using System.ServiceModel.Channels;
using Infrastructure.Common;
using Xunit;
using System.Threading.Tasks;
 
public static partial class ClientBaseTest
{
    [WcfFact]
    public static void ClientBaseCloseMethodClosesCorrectly()
    {
        // *** SETUP *** \\
        BasicHttpBinding binding = new BasicHttpBinding();
        MyClientBase client = new MyClientBase(binding, new EndpointAddress("http://myendpoint"));
 
        // *** VALIDATE *** \\
        Assert.Equal(CommunicationState.Created, client.State);
        client.Open();
        Assert.Equal(CommunicationState.Opened, client.State);
        client.Close();
        Assert.Equal(CommunicationState.Closed, client.State);
    }
 
    [WcfFact]
    public static void ClientBaseChannelFactoryDefaultCachingBindingEndpointAddress()
    {
        Assert.Equal(CacheSetting.Default, MyClientBase.CacheSetting);
        BasicHttpBinding binding = new BasicHttpBinding();
        EndpointAddress endpointAddress = new EndpointAddress("http://myendpoint");
        MyClientBase client1 = new MyClientBase(binding, endpointAddress);
        client1.Open();
        MyClientBase client2 = new MyClientBase(binding, endpointAddress);
        client2.Open();
        Assert.NotEqual(client1.ChannelFactory, client2.ChannelFactory);
        client1.Close();
        client2.Close();
        // Validate setting to same value doesn't throw
        MyClientBase.CacheSetting = CacheSetting.Default;
        // Validate instantiated caching throws when changing setting
        Assert.Throws<InvalidOperationException>(() => MyClientBase.CacheSetting = CacheSetting.AlwaysOn);
    }
 
    [WcfFact]
    public static void ClientBaseChannelFactoryDefaultCachingServiceEndpoint()
    {
        Assert.Equal(CacheSetting.Default, MyClientBase.CacheSetting);
        BasicHttpBinding binding = new BasicHttpBinding();
        EndpointAddress endpointAddress = new EndpointAddress("http://myendpoint");
        ChannelFactory<ITestService> tempFactory = new ChannelFactory<ITestService>(binding, endpointAddress);
        ServiceEndpoint serviceEndpoint = tempFactory.Endpoint;
        MyClientBase client1 = new MyClientBase(serviceEndpoint);
        client1.Open();
        MyClientBase client2 = new MyClientBase(serviceEndpoint);
        client2.Open();
        Assert.NotEqual(client1.ChannelFactory, client2.ChannelFactory);
        client1.Close();
        client2.Close();
        // Validate setting to same value doesn't throw
        MyClientBase.CacheSetting = CacheSetting.Default;
        // Validate instantiated caching throws when changing setting
        Assert.Throws<InvalidOperationException>(() => MyClientBase.CacheSetting = CacheSetting.AlwaysOn);
    }
 
    [WcfFact]
    public static void ClientBaseChannelFactoryAlwaysOnCachingBindingEndpointAddress()
    {
        MyClientBase2.CacheSetting = CacheSetting.AlwaysOn;
        BasicHttpBinding binding = new BasicHttpBinding();
        EndpointAddress endpointAddress = new EndpointAddress("http://myendpoint");
        MyClientBase2 client1 = new MyClientBase2(binding, endpointAddress);
        client1.Open();
        MyClientBase2 client2 = new MyClientBase2(binding, endpointAddress);
        client2.Open();
        // Validate using the same ChannelFactory when constructor args are the same
        Assert.Equal(client1.ChannelFactory, client2.ChannelFactory);
        MyClientBase2 client3 = new MyClientBase2(binding, new EndpointAddress("http://myendpoint"));
        client3.Open();
        // Validate using the same ChannelFactory when constructor args are equivalent
        Assert.Equal(client1.ChannelFactory, client3.ChannelFactory);
        MyClientBase2 client4 = new MyClientBase2(binding, new EndpointAddress("http://myotherendpoint"));
        // Validate using different ChannelFactory when constructor args are not equivalent
        Assert.NotEqual(client1.ChannelFactory, client4.ChannelFactory);
        client1.Close();
        client2.Close();
        client3.Close();
        client4.Close();
        // Validate setting to same value doesn't throw
        MyClientBase2.CacheSetting = CacheSetting.AlwaysOn;
        // Validate instantiated caching throws when changing setting
        Assert.Throws<InvalidOperationException>(() => MyClientBase2.CacheSetting = CacheSetting.Default);
    }
 
    [WcfFact]
    public static void ClientBaseChannelFactoryAlwaysOnServiceEndpoint()
    {
        MyClientBase2.CacheSetting = CacheSetting.AlwaysOn;
        BasicHttpBinding binding = new BasicHttpBinding();
        EndpointAddress endpointAddress = new EndpointAddress("http://myendpoint");
        ChannelFactory<ITestService2> tempFactory = new ChannelFactory<ITestService2>(binding, endpointAddress);
        ServiceEndpoint serviceEndpoint = tempFactory.Endpoint;
        MyClientBase2 client1 = new MyClientBase2(serviceEndpoint);
        client1.Open();
        MyClientBase2 client2 = new MyClientBase2(serviceEndpoint);
        client2.Open();
        // Validate using the same ChannelFactory when constructor args are the same
        Assert.Equal(client1.ChannelFactory, client2.ChannelFactory);
        tempFactory = new ChannelFactory<ITestService2>(binding, endpointAddress);
        ServiceEndpoint serviceEndpoint2 = tempFactory.Endpoint;
        MyClientBase2 client3 = new MyClientBase2(serviceEndpoint2);
        client3.Open();
        // Validate using different ChannelFactory when constructor args are not the same
        Assert.NotEqual(client1.ChannelFactory, client3.ChannelFactory);
        var existingChannelFactory = client1.ChannelFactory;
        client1.Close();
        client2.Close();
        client3.Close();
        // Validate that ChannelFactory is replaced if existing one is closed
        existingChannelFactory.Close();
        Assert.Equal(CommunicationState.Closed, existingChannelFactory.State);
        MyClientBase2 client4 = new MyClientBase2(serviceEndpoint);
        client4.Open();
        Assert.NotEqual(existingChannelFactory, client4.ChannelFactory);
        // Validate setting to same value doesn't throw
        MyClientBase2.CacheSetting = CacheSetting.AlwaysOn;
        // Validate instantiated caching throws when changing setting
        Assert.Throws<InvalidOperationException>(() => MyClientBase2.CacheSetting = CacheSetting.Default);
    }
 
 
    [WcfFact]
    public static void ClientBaseChannelFactoryAlwaysOffCachingBindingEndpointAddress()
    {
        MyClientBase3.CacheSetting = CacheSetting.AlwaysOff;
        BasicHttpBinding binding = new BasicHttpBinding();
        EndpointAddress endpointAddress = new EndpointAddress("http://myendpoint");
        MyClientBase3 client1 = new MyClientBase3(binding, endpointAddress);
        client1.Open();
        MyClientBase3 client2 = new MyClientBase3(binding, endpointAddress);
        client2.Open();
        Assert.NotEqual(client1.ChannelFactory, client2.ChannelFactory);
        client1.Close();
        client2.Close();
        // Validate setting to same value doesn't throw
        MyClientBase3.CacheSetting = CacheSetting.AlwaysOff;
        // Validate instantiated caching throws when changing setting
        Assert.Throws<InvalidOperationException>(() => MyClientBase.CacheSetting = CacheSetting.AlwaysOn);
    }
 
    [WcfFact]
    public static void ClientBaseChannelFactoryAlwaysOffCachingServiceEndpoint()
    {
        MyClientBase3.CacheSetting = CacheSetting.AlwaysOff;
        BasicHttpBinding binding = new BasicHttpBinding();
        EndpointAddress endpointAddress = new EndpointAddress("http://myendpoint");
        ChannelFactory<ITestService3> tempFactory = new ChannelFactory<ITestService3>(binding, endpointAddress);
        ServiceEndpoint serviceEndpoint = tempFactory.Endpoint;
        MyClientBase3 client1 = new MyClientBase3(serviceEndpoint);
        client1.Open();
        MyClientBase3 client2 = new MyClientBase3(serviceEndpoint);
        client2.Open();
        Assert.NotEqual(client1.ChannelFactory, client2.ChannelFactory);
        client1.Close();
        client2.Close();
        // Validate setting to same value doesn't throw
        MyClientBase3.CacheSetting = CacheSetting.AlwaysOff;
        // Validate instantiated caching throws when changing setting
        Assert.Throws<InvalidOperationException>(() => MyClientBase.CacheSetting = CacheSetting.AlwaysOn);
    }
 
    [WcfFact]
    public static async Task ClientBaseDisposeAsyncMethodClosesCorrectly()
    {
        // *** SETUP *** \\
        BasicHttpBinding binding = new BasicHttpBinding();
        MyClientBase client = new MyClientBase(binding, new EndpointAddress("http://myendpoint"));
 
        // *** VALIDATE *** \\
        Assert.Equal(CommunicationState.Created, client.State);
        client.Open();
        Assert.Equal(CommunicationState.Opened, client.State);
        await((IAsyncDisposable)client).DisposeAsync();
        Assert.Equal(CommunicationState.Closed, client.State);
    }
 
    [WcfTheory]
    [InlineData(true)]
    [InlineData(false)]
    public static async Task ClientBaseDisposeAsyncNoThrow(bool channelThrows)
    {
        // *** SETUP *** \\
        BasicHttpBinding binding = new BasicHttpBinding();
        var customBinding = new CustomBinding(binding);
        customBinding.Elements.Insert(0, new ThrowingOnCloseBindingElement(new CommunicationException(nameof(ClientBaseDisposeAsyncNoThrow)), channelThrows));
        MyClientBase client = new MyClientBase(customBinding, new EndpointAddress("http://myendpoint"));
        // *** VALIDATE *** \\
        Assert.Equal(CommunicationState.Created, client.State);
        client.Open();
        Assert.Equal(CommunicationState.Opened, client.State);
        await ((IAsyncDisposable)client).DisposeAsync();
        Assert.Equal(CommunicationState.Closed, client.State);
    }
 
    public class MyClientBase : ClientBase<ITestService>
    {
        public MyClientBase(Binding binding, EndpointAddress endpointAddress)
            : base(binding, endpointAddress)
        {
        }
 
        public MyClientBase(ServiceEndpoint serviceEndpoint)
            : base(serviceEndpoint)
        {
        }
 
        public ITestService Proxy
        {
            get { return base.Channel; }
        }
    }
 
    // 3 ClientBase types are needed as once you set the CacheSetting and instantiated a ClientBase<T>,
    // you can't modify the CacheSetting. We have tests which require a CacheSetting different from default
    // so need a 3 different types to test the 3 CacheSettings modes.
    public class MyClientBase2 : ClientBase<ITestService2>
    {
        public MyClientBase2(Binding binding, EndpointAddress endpointAddress)
            : base(binding, endpointAddress)
        {
        }
 
        public MyClientBase2(ServiceEndpoint serviceEndpoint)
            : base(serviceEndpoint)
        {
        }
    }
 
    public class MyClientBase3 : ClientBase<ITestService3>
    {
        public MyClientBase3(Binding binding, EndpointAddress endpointAddress)
            : base(binding, endpointAddress)
        {
        }
 
        public MyClientBase3(ServiceEndpoint serviceEndpoint)
            : base(serviceEndpoint)
        {
        }
    }
 
    [ServiceContract]
    public interface ITestService
    {
        [OperationContract]
        string Echo(string message);
    }
 
    [ServiceContract]
    public interface ITestService2 : ITestService
    {
    }
 
    [ServiceContract]
    public interface ITestService3 : ITestService
    {
    }
}