// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Globalization;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc.Abstractions;
using Microsoft.AspNetCore.Mvc.ModelBinding;
using Xunit;

namespace Microsoft.AspNetCore.Mvc.IntegrationTests
{
    public class HeaderModelBinderIntegrationTest
    {
        private class Person
        {
            public Address Address { get; set; }
        }

        private class Address
        {
            [FromHeader(Name = "Header")]
            [Required]
            public string Street { get; set; }
        }

        [Fact]
        public async Task BindPropertyFromHeader_NoData_UsesFullPathAsKeyForModelStateErrors()
        {
            // Arrange
            var parameter = new ParameterDescriptor()
            {
                Name = "Parameter1",
                BindingInfo = new BindingInfo()
                {
                    BinderModelName = "CustomParameter",
                },
                ParameterType = typeof(Person)
            };

            // Do not add any headers.
            var testContext = GetModelBindingTestContext();
            var parameterBinder = ModelBindingTestHelper.GetParameterBinder(testContext.HttpContext.RequestServices);
            var modelState = testContext.ModelState;

            // Act
            var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);

            // Assert

            // ModelBindingResult
            Assert.True(modelBindingResult.IsModelSet);

            // Model
            var boundPerson = Assert.IsType<Person>(modelBindingResult.Model);
            Assert.NotNull(boundPerson);

            // ModelState
            Assert.False(modelState.IsValid);
            var key = Assert.Single(modelState.Keys);
            Assert.Equal("CustomParameter.Address.Header", key);
            var error = Assert.Single(modelState[key].Errors);
            Assert.Equal(ValidationAttributeUtil.GetRequiredErrorMessage("Street"), error.ErrorMessage);
        }

        [Fact]
        public async Task BindPropertyFromHeader_WithPrefix_GetsBound()
        {
            // Arrange
            var parameter = new ParameterDescriptor()
            {
                Name = "Parameter1",
                BindingInfo = new BindingInfo()
                {
                    BinderModelName = "prefix",
                },
                ParameterType = typeof(Person)
            };

            var testContext = GetModelBindingTestContext(
                request => request.Headers.Add("Header", new[] { "someValue" }));
            var parameterBinder = ModelBindingTestHelper.GetParameterBinder(testContext.HttpContext.RequestServices);
            var modelState = testContext.ModelState;

            // Act
            var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);

            // Assert

            // ModelBindingResult
            Assert.True(modelBindingResult.IsModelSet);

            // Model
            var boundPerson = Assert.IsType<Person>(modelBindingResult.Model);
            Assert.NotNull(boundPerson);
            Assert.NotNull(boundPerson.Address);
            Assert.Equal("someValue", boundPerson.Address.Street);

            // ModelState
            Assert.True(modelState.IsValid);
            var entry = Assert.Single(modelState);
            Assert.Equal("prefix.Address.Header", entry.Key);
            Assert.Empty(entry.Value.Errors);
            Assert.Equal(ModelValidationState.Valid, entry.Value.ValidationState);
            Assert.Equal("someValue", entry.Value.AttemptedValue);
            Assert.Equal("someValue", entry.Value.RawValue);
        }

        // The scenario is interesting as we to bind the top level model we fallback to empty prefix,
        // and hence the model state keys have an empty prefix.
        [Fact]
        public async Task BindPropertyFromHeader_WithData_WithEmptyPrefix_GetsBound()
        {
            // Arrange
            var parameter = new ParameterDescriptor()
            {
                Name = "Parameter1",
                BindingInfo = new BindingInfo(),
                ParameterType = typeof(Person)
            };

            var testContext = GetModelBindingTestContext(
                request => request.Headers.Add("Header", new[] { "someValue" }));
            var parameterBinder = ModelBindingTestHelper.GetParameterBinder(testContext.HttpContext.RequestServices);
            var modelState = testContext.ModelState;

            // Act
            var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);

            // Assert

            // ModelBindingResult
            Assert.True(modelBindingResult.IsModelSet);

            // Model
            var boundPerson = Assert.IsType<Person>(modelBindingResult.Model);
            Assert.NotNull(boundPerson);
            Assert.NotNull(boundPerson.Address);
            Assert.Equal("someValue", boundPerson.Address.Street);

            // ModelState
            Assert.True(modelState.IsValid);
            var entry = Assert.Single(modelState);
            Assert.Equal("Address.Header", entry.Key);
            Assert.Empty(entry.Value.Errors);
            Assert.Equal(ModelValidationState.Valid, entry.Value.ValidationState);
            Assert.Equal("someValue", entry.Value.AttemptedValue);
            Assert.Equal("someValue", entry.Value.RawValue);
        }

        private class ListContainer1
        {
            [FromHeader(Name = "Header")]
            public List<string> ListProperty { get; set; }
        }

        [Fact]
        public async Task BindCollectionPropertyFromHeader_WithData_IsBound()
        {
            // Arrange
            var parameter = new ParameterDescriptor
            {
                Name = "Parameter1",
                BindingInfo = new BindingInfo(),
                ParameterType = typeof(ListContainer1),
            };

            var testContext = GetModelBindingTestContext(
                request => request.Headers.Add("Header", new[] { "someValue" }));
            var parameterBinder = ModelBindingTestHelper.GetParameterBinder(testContext.HttpContext.RequestServices);
            var modelState = testContext.ModelState;

            // Act
            var result = await parameterBinder.BindModelAsync(parameter, testContext);

            // Assert
            Assert.True(result.IsModelSet);

            // Model
            var boundContainer = Assert.IsType<ListContainer1>(result.Model);
            Assert.NotNull(boundContainer);
            Assert.NotNull(boundContainer.ListProperty);
            var entry = Assert.Single(boundContainer.ListProperty);
            Assert.Equal("someValue", entry);

            // ModelState
            Assert.True(modelState.IsValid);
            var kvp = Assert.Single(modelState);
            Assert.Equal("Header", kvp.Key);
            var modelStateEntry = kvp.Value;
            Assert.NotNull(modelStateEntry);
            Assert.Empty(modelStateEntry.Errors);
            Assert.Equal(ModelValidationState.Valid, modelStateEntry.ValidationState);
            Assert.Equal("someValue", modelStateEntry.AttemptedValue);
            Assert.Equal("someValue", modelStateEntry.RawValue);
        }

        private class ListContainer2
        {
            [FromHeader(Name = "Header")]
            public List<string> ListProperty { get; } = new List<string> { "One", "Two", "Three" };
        }

        [Fact]
        public async Task BindReadOnlyCollectionPropertyFromHeader_WithData_IsBound()
        {
            // Arrange
            var parameter = new ParameterDescriptor
            {
                Name = "Parameter1",
                BindingInfo = new BindingInfo(),
                ParameterType = typeof(ListContainer2),
            };

            var testContext = GetModelBindingTestContext(
                request => request.Headers.Add("Header", new[] { "someValue" }));
            var parameterBinder = ModelBindingTestHelper.GetParameterBinder(testContext.HttpContext.RequestServices);
            var modelState = testContext.ModelState;

            // Act
            var result = await parameterBinder.BindModelAsync(parameter, testContext);

            // Assert
            Assert.True(result.IsModelSet);

            // Model
            var boundContainer = Assert.IsType<ListContainer2>(result.Model);
            Assert.NotNull(boundContainer);
            Assert.NotNull(boundContainer.ListProperty);
            var entry = Assert.Single(boundContainer.ListProperty);
            Assert.Equal("someValue", entry);

            // ModelState
            Assert.True(modelState.IsValid);
            var kvp = Assert.Single(modelState);
            Assert.Equal("Header", kvp.Key);
            var modelStateEntry = kvp.Value;
            Assert.NotNull(modelStateEntry);
            Assert.Empty(modelStateEntry.Errors);
            Assert.Equal(ModelValidationState.Valid, modelStateEntry.ValidationState);
            Assert.Equal("someValue", modelStateEntry.AttemptedValue);
            Assert.Equal("someValue", modelStateEntry.RawValue);
        }

        [Theory]
        [InlineData(typeof(string[]), "value1, value2, value3")]
        [InlineData(typeof(string), "value")]
        public async Task BindParameterFromHeader_WithData_WithPrefix_ModelGetsBound(Type modelType, string value)
        {
            // Arrange
            string expectedAttemptedValue;
            object expectedRawValue;
            if (modelType == typeof(string))
            {
                expectedAttemptedValue = value;
                expectedRawValue = value;
            }
            else
            {
                expectedAttemptedValue = value.Replace(" ", "");
                expectedRawValue = value.Split(',').Select(v => v.Trim()).ToArray();
            }

            var parameter = new ParameterDescriptor
            {
                Name = "Parameter1",
                BindingInfo = new BindingInfo
                {
                    BinderModelName = "CustomParameter",
                    BindingSource = BindingSource.Header
                },
                ParameterType = modelType
            };

            Action<HttpRequest> action = r => r.Headers.Add("CustomParameter", new[] { expectedAttemptedValue });
            var testContext = GetModelBindingTestContext(action);
            var parameterBinder = ModelBindingTestHelper.GetParameterBinder(testContext.HttpContext.RequestServices);

            // Do not add any headers.
            var httpContext = testContext.HttpContext;
            var modelState = testContext.ModelState;

            // Act
            var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);

            // Assert

            // ModelBindingResult
            Assert.True(modelBindingResult.IsModelSet);

            // Model
            Assert.NotNull(modelBindingResult.Model);
            Assert.IsType(modelType, modelBindingResult.Model);

            // ModelState
            Assert.True(modelState.IsValid);
            var entry = Assert.Single(modelState);
            Assert.Equal("CustomParameter", entry.Key);
            Assert.Empty(entry.Value.Errors);
            Assert.Equal(ModelValidationState.Valid, entry.Value.ValidationState);
            Assert.Equal(expectedAttemptedValue, entry.Value.AttemptedValue);
            Assert.Equal(expectedRawValue, entry.Value.RawValue);
        }

        [Fact]
        public async Task BindPropertyFromHeader_WithPrefix_GetsBound_ForSimpleTypes()
        {
            // Arrange
            var parameter = new ParameterDescriptor()
            {
                Name = "Parameter1",
                BindingInfo = new BindingInfo()
                {
                    BinderModelName = "prefix",
                },
                ParameterType = typeof(Product)
            };

            var testContext = GetModelBindingTestContext(
                request =>
                {
                    request.Headers.Add("NoCommaString", "someValue");
                    request.Headers.Add("OneCommaSeparatedString", "one, two, three");
                    request.Headers.Add("IntProperty", "10");
                    request.Headers.Add("NullableIntProperty", "300");
                    request.Headers.Add("ArrayOfString", "first, second");
                    request.Headers.Add("EnumerableOfDouble", "10.51, 45.44");
                    request.Headers.Add("ListOfEnum", "Sedan, Coupe");
                    request.Headers.Add("ListOfOrderWithTypeConverter", "10");
                });
            var parameterBinder = ModelBindingTestHelper.GetParameterBinder(testContext.HttpContext.RequestServices);
            var modelState = testContext.ModelState;

            // Act
            var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);

            // Assert

            // ModelBindingResult
            Assert.True(modelBindingResult.IsModelSet);

            // Model
            var product = Assert.IsType<Product>(modelBindingResult.Model);
            Assert.NotNull(product);
            Assert.NotNull(product.Manufacturer);
            Assert.Equal("someValue", product.Manufacturer.NoCommaString);
            Assert.Equal("one, two, three", product.Manufacturer.OneCommaSeparatedStringProperty);
            Assert.Equal(10, product.Manufacturer.IntProperty);
            Assert.Equal(300, product.Manufacturer.NullableIntProperty);
            Assert.Null(product.Manufacturer.NullableLongProperty);
            Assert.Equal(new[] { "first", "second" }, product.Manufacturer.ArrayOfString);
            Assert.Equal(new double[] { 10.51, 45.44 }, product.Manufacturer.EnumerableOfDoubleProperty);
            Assert.Equal(new CarType[] { CarType.Sedan, CarType.Coupe }, product.Manufacturer.ListOfEnum);
            var orderWithTypeConverter = Assert.Single(product.Manufacturer.ListOfOrderWithTypeConverterProperty);
            Assert.Equal(10, orderWithTypeConverter.Id);

            // ModelState
            Assert.True(modelState.IsValid);
            Assert.Collection(
                modelState.OrderBy(kvp => kvp.Key),
                kvp =>
                {
                    Assert.Equal("prefix.Manufacturer.ArrayOfString", kvp.Key);
                    var entry = kvp.Value;
                    Assert.Empty(entry.Errors);
                    Assert.Equal(ModelValidationState.Valid, entry.ValidationState);
                    Assert.Equal("first,second", entry.AttemptedValue);
                    Assert.Equal(new[] { "first", "second" }, entry.RawValue);
                },
                kvp =>
                {
                    Assert.Equal("prefix.Manufacturer.EnumerableOfDouble", kvp.Key);
                    var entry = kvp.Value;
                    Assert.Empty(entry.Errors);
                    Assert.Equal(ModelValidationState.Valid, entry.ValidationState);
                    Assert.Equal("10.51,45.44", entry.AttemptedValue);
                    Assert.Equal(new[] { "10.51", "45.44" }, entry.RawValue);
                },
                kvp =>
                {
                    Assert.Equal("prefix.Manufacturer.IntProperty", kvp.Key);
                    var entry = kvp.Value;
                    Assert.Empty(entry.Errors);
                    Assert.Equal(ModelValidationState.Valid, entry.ValidationState);
                    Assert.Equal("10", entry.AttemptedValue);
                    Assert.Equal("10", entry.RawValue);
                },
                kvp =>
                {
                    Assert.Equal("prefix.Manufacturer.ListOfEnum", kvp.Key);
                    var entry = kvp.Value;
                    Assert.Empty(entry.Errors);
                    Assert.Equal(ModelValidationState.Valid, entry.ValidationState);
                    Assert.Equal("Sedan,Coupe", entry.AttemptedValue);
                    Assert.Equal(new[] { "Sedan", "Coupe" }, entry.RawValue);
                },
                kvp =>
                {
                    Assert.Equal("prefix.Manufacturer.ListOfOrderWithTypeConverter", kvp.Key);
                    var entry = kvp.Value;
                    Assert.Empty(entry.Errors);
                    Assert.Equal(ModelValidationState.Valid, entry.ValidationState);
                    Assert.Equal("10", entry.AttemptedValue);
                    Assert.Equal("10", entry.RawValue);
                },
                kvp =>
                {
                    Assert.Equal("prefix.Manufacturer.NoCommaString", kvp.Key);
                    var entry = kvp.Value;
                    Assert.Empty(entry.Errors);
                    Assert.Equal(ModelValidationState.Valid, entry.ValidationState);
                    Assert.Equal("someValue", entry.AttemptedValue);
                    Assert.Equal("someValue", entry.RawValue);
                },
                kvp =>
                {
                    Assert.Equal("prefix.Manufacturer.NullableIntProperty", kvp.Key);
                    var entry = kvp.Value;
                    Assert.Empty(entry.Errors);
                    Assert.Equal(ModelValidationState.Valid, entry.ValidationState);
                    Assert.Equal("300", entry.AttemptedValue);
                    Assert.Equal("300", entry.RawValue);
                },
                kvp =>
                {
                    Assert.Equal("prefix.Manufacturer.OneCommaSeparatedString", kvp.Key);
                    var entry = kvp.Value;
                    Assert.Empty(entry.Errors);
                    Assert.Equal(ModelValidationState.Valid, entry.ValidationState);
                    Assert.Equal("one, two, three", entry.AttemptedValue);
                    Assert.Equal("one, two, three", entry.RawValue);
                });
        }

        private ModelBindingTestContext GetModelBindingTestContext(
            Action<HttpRequest> updateRequest = null,
            Action<MvcOptions> updateOptions = null)
        {
            return ModelBindingTestHelper.GetTestContext(updateRequest, updateOptions);
        }

        private class Product
        {
            public Manufacturer Manufacturer { get; set; }
        }

        private class Manufacturer
        {
            [FromHeader]
            public string NoCommaString { get; set; }

            [FromHeader(Name = "OneCommaSeparatedString")]
            public string OneCommaSeparatedStringProperty { get; set; }

            [FromHeader]
            public int IntProperty { get; set; }

            [FromHeader]
            public int? NullableIntProperty { get; set; }

            [FromHeader]
            public long? NullableLongProperty { get; set; }

            [FromHeader]
            public string[] ArrayOfString { get; set; }

            [FromHeader(Name = "EnumerableOfDouble")]
            public IEnumerable<double> EnumerableOfDoubleProperty { get; set; }

            [FromHeader]
            public List<CarType> ListOfEnum { get; set; }

            [FromHeader(Name = "ListOfOrderWithTypeConverter")]
            public List<OrderWithTypeConverter> ListOfOrderWithTypeConverterProperty { get; set; }
        }

        private enum CarType
        {
            Coupe,
            Sedan
        }

        [TypeConverter(typeof(CanConvertFromStringConverter))]
        private class OrderWithTypeConverter : IEquatable<OrderWithTypeConverter>
        {
            public int Id { get; set; }

            public int ItemCount { get; set; }

            public bool Equals(OrderWithTypeConverter other)
            {
                return Id == other.Id;
            }
        }

        private class CanConvertFromStringConverter : TypeConverter
        {
            public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
            {
                return sourceType == typeof(string);
            }

            public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
            {
                var id = value.ToString();
                return new OrderWithTypeConverter() { Id = int.Parse(id) };
            }
        }
    }
}