// 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.Collections.Generic;
using System.Collections.Immutable;
using Microsoft.CodeAnalysis.Remote.Testing;
using Microsoft.CodeAnalysis.Test.Utilities;
using Xunit;
 
namespace Microsoft.CodeAnalysis.UnitTests
{
    internal static class SolutionTestHelpers
    {
        public static Workspace CreateWorkspace(Type[]? additionalParts = null, TestHost testHost = TestHost.InProcess)
            => new AdhocWorkspace(FeaturesTestCompositions.Features.AddParts(additionalParts).WithTestHostParts(testHost).GetHostServices());
 
        public static Workspace CreateWorkspaceWithPartialSemantics(TestHost testHost = TestHost.InProcess)
            => WorkspaceTestUtilities.CreateWorkspaceWithPartialSemantics(testHost: testHost);
 
#nullable disable
 
        public static void TestProperty<T, TValue>(T instance, Func<T, TValue, T> factory, Func<T, TValue> getter, TValue validNonDefaultValue, bool defaultThrows = false)
            where T : class
        {
            Assert.NotEqual(getter(instance), validNonDefaultValue);
 
            var instanceWithValue = factory(instance, validNonDefaultValue);
            Assert.Equal(validNonDefaultValue, getter(instanceWithValue));
 
            // the factory returns the unchanged instance if the value is unchanged:
            var instanceWithValue2 = factory(instanceWithValue, validNonDefaultValue);
            Assert.Same(instanceWithValue2, instanceWithValue);
 
            if (defaultThrows)
            {
                Assert.Throws<ArgumentNullException>(() => factory(instance, default));
            }
            else
            {
                Assert.NotNull(factory(instance, default));
            }
        }
 
        public static void TestListProperty<T, TValue>(T instance, Func<T, IEnumerable<TValue>, T> factory, Func<T, IEnumerable<TValue>> getter, TValue item, bool allowDuplicates)
            where T : class
        {
            var boxedItems = (IEnumerable<TValue>)ImmutableArray.Create(item);
            TestProperty(instance, factory, getter, boxedItems, defaultThrows: false);
 
            var instanceWithNoItem = factory(instance, null);
            Assert.Empty(getter(instanceWithNoItem));
 
            var instanceWithItem = factory(instanceWithNoItem, boxedItems);
 
            // the factory preserves the identity of a boxed immutable array:
            Assert.Same(boxedItems, getter(instanceWithItem));
 
            Assert.Same(instanceWithNoItem, factory(instanceWithNoItem, null));
            Assert.Same(instanceWithNoItem, factory(instanceWithNoItem, []));
            Assert.Same(instanceWithNoItem, factory(instanceWithNoItem, []));
 
            // the factory makes an immutable copy if given a mutable list:
            var mutableItems = new[] { item };
            var instanceWithMutableItems = factory(instanceWithNoItem, mutableItems);
            var items = getter(instanceWithMutableItems);
            Assert.NotSame(mutableItems, items);
 
            // null item:
            Assert.Throws<ArgumentNullException>(() => factory(instanceWithNoItem, new TValue[] { item, default }));
 
            // duplicate item:
            if (allowDuplicates)
            {
                var boxedDupItems = (IEnumerable<TValue>)ImmutableArray.Create(item, item);
                Assert.Same(boxedDupItems, getter(factory(instanceWithNoItem, boxedDupItems)));
            }
            else
            {
                Assert.Throws<ArgumentException>(() => factory(instanceWithNoItem, new TValue[] { item, item }));
            }
        }
    }
}