using System;
using System.Reflection;
using System.Runtime.Serialization;
using UnitTestSharp;

namespace Vellum.UnitTests
{
    public class FieldWriterTests : TestFixture
    {
        public static T Blank<T>()
        {
            return (T)FormatterServices.GetUninitializedObject(typeof(T));
        }

        public class CtorTests : TestFixture
        {
            public void NullName_Throws()
            {
                CheckThrow(typeof(ArgumentNullException));
                new FieldWriter<Bucket, string>(null);
            }

            public void NamesNothingUntilItIsUsed()
            {
                var writer = new FieldWriter<Bucket, string>("NoSuchMember");

                CheckEqual("NoSuchMember", writer.MemberName);
            }
        }

        public class SetTests : TestFixture
        {
            public void PlainField_IsWritten()
            {
                var bucket = new Bucket("s", 1);
                new FieldWriter<Bucket, string>(nameof(Bucket.Plain)).Set(bucket, "written");

                CheckEqual("written", bucket.Plain);
            }

            public void ReadonlyField_IsWritten()
            {
                var spouse = new Spouse("ann", null);
                new FieldWriter<Spouse, string>(nameof(Spouse.Name)).Set(spouse, "changed");

                CheckEqual("changed", spouse.Name);
            }

            public void PrivateReadonlyField_IsWritten()
            {
                var bucket = new Bucket("before", 1);
                new FieldWriter<Bucket, string>("secret").Set(bucket, "after");

                CheckEqual("after", bucket.Secret);
            }

            public void AutoPropertyWithOnlyAGetter_HasItsHiddenFieldWritten()
            {
                var bucket = new Bucket("s", 1);
                new FieldWriter<Bucket, int>(nameof(Bucket.Size)).Set(bucket, 42);

                CheckEqual(42, bucket.Size);
            }

            public void ObjectWhoseConstructorNeverRan_IsWritten()
            {
                var spouse = Blank<Spouse>();
                new FieldWriter<Spouse, string>(nameof(Spouse.Name)).Set(spouse, "blank");

                CheckEqual("blank", spouse.Name);
                CheckEqual(0, spouse.PairedLength);
            }

            public void SecondUse_WritesAgain()
            {
                var bucket = new Bucket("s", 1);
                var writer = new FieldWriter<Bucket, string>(nameof(Bucket.Plain));
                writer.Set(bucket, "first");
                writer.Set(bucket, "second");

                CheckEqual("second", bucket.Plain);
            }

            public void NullValue_IsWritten()
            {
                var bucket = new Bucket("s", 1) { Plain = "set" };
                new FieldWriter<Bucket, string>(nameof(Bucket.Plain)).Set(bucket, null);

                CheckNull(bucket.Plain);
            }

            public void ValueOfATypeDerivedFromTheFieldsType_IsWritten()
            {
                var bucket = new Bucket("s", 1);
                new FieldWriter<Bucket, string>(nameof(Bucket.Anything)).Set(bucket, "text");

                CheckEqual("text", bucket.Anything);
            }

            public void ValueOfATypeTheFieldCantHold_Throws()
            {
                CheckThrow(typeof(ArgumentException));
                new FieldWriter<Bucket, object>(nameof(Bucket.Plain)).Set(new Bucket("s", 1), "text");
            }

            public void MemberThatDoesntExist_Throws()
            {
                CheckThrow(typeof(ArgumentException));
                new FieldWriter<Bucket, string>("NoSuchMember").Set(new Bucket("s", 1), "text");
            }

            public void NullInstance_Throws()
            {
                CheckThrow(typeof(ArgumentNullException));
                new FieldWriter<Bucket, string>(nameof(Bucket.Plain)).Set(null, "text");
            }
        }

        public class WriteByReflectionTests : TestFixture
        {
            private static FieldInfo FieldOf<OwnerType>(string name)
            {
                return typeof(OwnerType).GetField(name,
                    BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
            }

            public void PlainField_IsWritten()
            {
                var bucket = new Bucket("s", 1);

                FieldWriter<Bucket, string>.WriteByReflection(FieldOf<Bucket>(nameof(Bucket.Plain)))(bucket, "set");

                CheckEqual("set", bucket.Plain);
            }

            public void ReadonlyField_IsWritten()
            {
                var spouse = new Spouse("ann", null);

                FieldWriter<Spouse, string>.WriteByReflection(FieldOf<Spouse>(nameof(Spouse.Name)))(spouse, "changed");

                CheckEqual("changed", spouse.Name);
            }

            public void PrivateReadonlyField_IsWritten()
            {
                var bucket = new Bucket("before", 1);

                FieldWriter<Bucket, string>.WriteByReflection(FieldOf<Bucket>("secret"))(bucket, "after");

                CheckEqual("after", bucket.Secret);
            }

            public void AutoPropertysHiddenField_IsWritten()
            {
                var bucket = new Bucket("s", 1);

                FieldWriter<Bucket, int>.WriteByReflection(FieldOf<Bucket>("<Size>k__BackingField"))(bucket, 42);

                CheckEqual(42, bucket.Size);
            }

            public void ObjectWhoseConstructorNeverRan_IsWritten()
            {
                var spouse = Blank<Spouse>();

                FieldWriter<Spouse, string>.WriteByReflection(FieldOf<Spouse>(nameof(Spouse.Name)))(spouse, "blank");

                CheckEqual("blank", spouse.Name);
            }

            public void NullValue_IsWritten()
            {
                var bucket = new Bucket("s", 1) { Plain = "set" };

                FieldWriter<Bucket, string>.WriteByReflection(FieldOf<Bucket>(nameof(Bucket.Plain)))(bucket, null);

                CheckNull(bucket.Plain);
            }
        }
    }
}