// Copyright (c) Umbraco.
// See LICENSE for more details.

using System.Linq;
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;
using Newtonsoft.Json;
using NUnit.Framework;
using Umbraco.Cms.Core.Models;
using Umbraco.Cms.Core.Models.ContentEditing;
using Umbraco.Cms.Core.Services;
using Umbraco.Cms.Tests.Common.Builders;
using Umbraco.Cms.Tests.Common.Builders.Extensions;
using Umbraco.Cms.Tests.Integration.TestServerTest;
using Umbraco.Cms.Web.BackOffice.Controllers;
using Umbraco.Cms.Web.Common.Formatters;
using Umbraco.Extensions;
using Constants = Umbraco.Cms.Core.Constants;

namespace Umbraco.Cms.Tests.Integration.Umbraco.Web.BackOffice.Controllers
{
    [TestFixture]
    public class ContentControllerTests : UmbracoTestServerTestBase
    {
        private const string UsIso = "en-US";
        private const string DkIso = "da-DK";

        /// <summary>
        ///     Returns 404 if the content wasn't found based on the ID specified
        /// </summary>
        [Test]
        public async Task PostSave_Validate_Existing_Content()
        {
            ILocalizationService localizationService = GetRequiredService<ILocalizationService>();

            // Add another language
            localizationService.Save(new LanguageBuilder()
                .WithCultureInfo(DkIso)
                .WithIsDefault(false)
                .Build());

            string url = PrepareApiControllerUrl<ContentController>(x => x.PostSave(null));

            IContentService contentService = GetRequiredService<IContentService>();
            IContentTypeService contentTypeService = GetRequiredService<IContentTypeService>();

            IContentType contentType = new ContentTypeBuilder()
                .WithId(0)
                .AddPropertyType()
                .WithAlias("title")
                .WithValueStorageType(ValueStorageType.Integer)
                .WithPropertyEditorAlias(Constants.PropertyEditors.Aliases.TextBox)
                .WithName("Title")
                .Done()
                .WithContentVariation(ContentVariation.Nothing)
                .Build();

            contentTypeService.Save(contentType);

            Content content = new ContentBuilder()
                .WithId(0)
                .WithName("Invariant")
                .WithContentType(contentType)
                .AddPropertyData()
                .WithKeyValue("title", "Cool invariant title")
                .Done()
                .Build();
            contentService.SaveAndPublish(content);

            ContentItemSave model = new ContentItemSaveBuilder()
                .WithContent(content)
                .WithId(-1337) // HERE We overwrite the Id, so we don't expect to find it on the server
                .Build();

            // Act
            HttpResponseMessage response = await Client.PostAsync(url, new MultipartFormDataContent
            {
                { new StringContent(JsonConvert.SerializeObject(model)), "contentItem" }
            });

            // Assert
            Assert.AreEqual(HttpStatusCode.NotFound, response.StatusCode);
            //// Assert.AreEqual(")]}',\n{\"Message\":\"content was not found\"}", response.Item1.Content.ReadAsStringAsync().Result);
            ////
            ////             //var obj = JsonConvert.DeserializeObject<PagedResult<UserDisplay>>(response.Item2);
            ////             //Assert.AreEqual(0, obj.TotalItems);
        }

        [Test]
        public async Task PostSave_Validate_At_Least_One_Variant_Flagged_For_Saving()
        {
            ILocalizationService localizationService = GetRequiredService<ILocalizationService>();

            // Add another language
            localizationService.Save(new LanguageBuilder()
                .WithCultureInfo(DkIso)
                .WithIsDefault(false)
                .Build());

            string url = PrepareApiControllerUrl<ContentController>(x => x.PostSave(null));

            IContentTypeService contentTypeService = GetRequiredService<IContentTypeService>();

            IContentType contentType = new ContentTypeBuilder()
                .WithId(0)
                .AddPropertyType()
                .WithAlias("title")
                .WithValueStorageType(ValueStorageType.Integer)
                .WithPropertyEditorAlias(Constants.PropertyEditors.Aliases.TextBox)
                .WithName("Title")
                .Done()
                .WithContentVariation(ContentVariation.Nothing)
                .Build();

            contentTypeService.Save(contentType);

            IContentService contentService = GetRequiredService<IContentService>();
            Content content = new ContentBuilder()
                .WithId(0)
                .WithName("Invariant")
                .WithContentType(contentType)
                .AddPropertyData()
                .WithKeyValue("title", "Cool invariant title")
                .Done()
                .Build();
            contentService.SaveAndPublish(content);

            ContentItemSave model = new ContentItemSaveBuilder()
                .WithContent(content)
                .Build();

            // HERE we force the test to fail
            model.Variants = model.Variants.Select(x =>
            {
                x.Save = false;
                return x;
            });

            // Act
            HttpResponseMessage response = await Client.PostAsync(url, new MultipartFormDataContent
            {
                { new StringContent(JsonConvert.SerializeObject(model)), "contentItem" }
            });

            // Assert
            string body = await response.Content.ReadAsStringAsync();

            Assert.Multiple(() =>
            {
                Assert.AreEqual(HttpStatusCode.NotFound, response.StatusCode);
                Assert.AreEqual(AngularJsonMediaTypeFormatter.XsrfPrefix + "{\"Message\":\"No variants flagged for saving\"}", body);
            });
        }

        /// <summary>
        ///     Returns 404 if any of the posted properties dont actually exist
        /// </summary>
        [Test]
        public async Task PostSave_Validate_Properties_Exist()
        {
            ILocalizationService localizationService = GetRequiredService<ILocalizationService>();

            // Add another language
            localizationService.Save(new LanguageBuilder()
                .WithCultureInfo(DkIso)
                .WithIsDefault(false)
                .Build());

            string url = PrepareApiControllerUrl<ContentController>(x => x.PostSave(null));

            IContentService contentService = GetRequiredService<IContentService>();
            IContentTypeService contentTypeService = GetRequiredService<IContentTypeService>();

            IContentType contentType = new ContentTypeBuilder()
                .WithId(0)
                .AddPropertyType()
                .WithAlias("title")
                .WithValueStorageType(ValueStorageType.Integer)
                .WithPropertyEditorAlias(Constants.PropertyEditors.Aliases.TextBox)
                .WithName("Title")
                .Done()
                .WithContentVariation(ContentVariation.Nothing)
                .Build();

            contentTypeService.Save(contentType);

            Content content = new ContentBuilder()
                .WithId(0)
                .WithName("Invariant")
                .WithContentType(contentType)
                .AddPropertyData()
                .WithKeyValue("title", "Cool invariant title")
                .Done()
                .Build();
            contentService.SaveAndPublish(content);

            ContentItemSave model = new ContentItemSaveBuilder()
                .WithId(content.Id)
                .WithContentTypeAlias(content.ContentType.Alias)
                .AddVariant()
                    .AddProperty()
                        .WithId(2)
                        .WithAlias("doesntexists")
                        .WithValue("Whatever")
                        .Done()
                    .Done()
                .Build();

            // Act
            HttpResponseMessage response = await Client.PostAsync(url, new MultipartFormDataContent
            {
                { new StringContent(JsonConvert.SerializeObject(model)), "contentItem" }
            });

            // Assert
            string body = await response.Content.ReadAsStringAsync();

            body = body.TrimStart(AngularJsonMediaTypeFormatter.XsrfPrefix);

            Assert.AreEqual(HttpStatusCode.NotFound, response.StatusCode);
        }

        [Test]
        public async Task PostSave_Simple_Invariant()
        {
            ILocalizationService localizationService = GetRequiredService<ILocalizationService>();

            // Add another language
            localizationService.Save(new LanguageBuilder()
                .WithCultureInfo(DkIso)
                .WithIsDefault(false)
                .Build());

            string url = PrepareApiControllerUrl<ContentController>(x => x.PostSave(null));

            IContentService contentService = GetRequiredService<IContentService>();
            IContentTypeService contentTypeService = GetRequiredService<IContentTypeService>();

            IContentType contentType = new ContentTypeBuilder()
                .WithId(0)
                .AddPropertyType()
                .WithAlias("title")
                .WithValueStorageType(ValueStorageType.Integer)
                .WithPropertyEditorAlias(Constants.PropertyEditors.Aliases.TextBox)
                .WithName("Title")
                .Done()
                .WithContentVariation(ContentVariation.Nothing)
                .Build();

            contentTypeService.Save(contentType);

            Content content = new ContentBuilder()
                .WithId(0)
                .WithName("Invariant")
                .WithContentType(contentType)
                .AddPropertyData()
                .WithKeyValue("title", "Cool invariant title")
                .Done()
                .Build();
            contentService.SaveAndPublish(content);
            ContentItemSave model = new ContentItemSaveBuilder()
                .WithContent(content)
                .Build();

            // Act
            HttpResponseMessage response = await Client.PostAsync(url, new MultipartFormDataContent
            {
                { new StringContent(JsonConvert.SerializeObject(model)), "contentItem" }
            });

            // Assert
            string body = await response.Content.ReadAsStringAsync();

            body = body.TrimStart(AngularJsonMediaTypeFormatter.XsrfPrefix);

            Assert.Multiple(() =>
            {
                Assert.AreEqual(HttpStatusCode.OK, response.StatusCode, body);
                ContentItemDisplay display = JsonConvert.DeserializeObject<ContentItemDisplay>(body);
                Assert.AreEqual(1, display.Variants.Count());
            });
        }

        [Test]
        public async Task PostSave_Validate_Empty_Name()
        {
            ILocalizationService localizationService = GetRequiredService<ILocalizationService>();

            // Add another language
            localizationService.Save(new LanguageBuilder()
                .WithCultureInfo(DkIso)
                .WithIsDefault(false)
                .Build());

            string url = PrepareApiControllerUrl<ContentController>(x => x.PostSave(null));

            IContentService contentService = GetRequiredService<IContentService>();
            IContentTypeService contentTypeService = GetRequiredService<IContentTypeService>();

            IContentType contentType = new ContentTypeBuilder()
                .WithId(0)
                .AddPropertyType()
                .WithAlias("title")
                .WithValueStorageType(ValueStorageType.Integer)
                .WithPropertyEditorAlias(Constants.PropertyEditors.Aliases.TextBox)
                .WithName("Title")
                .Done()
                .WithContentVariation(ContentVariation.Nothing)
                .Build();

            contentTypeService.Save(contentType);

            Content content = new ContentBuilder()
                .WithId(0)
                .WithName("Invariant")
                .WithContentType(contentType)
                .AddPropertyData()
                .WithKeyValue("title", "Cool invariant title")
                .Done()
                .Build();
            contentService.SaveAndPublish(content);

            content.Name = null; // Removes the name of one of the variants to force an error
            ContentItemSave model = new ContentItemSaveBuilder()
                .WithContent(content)
                .Build();

            // Act
            HttpResponseMessage response = await Client.PostAsync(url, new MultipartFormDataContent
            {
                { new StringContent(JsonConvert.SerializeObject(model)), "contentItem" }
            });

            // Assert
            string body = await response.Content.ReadAsStringAsync();

            body = body.TrimStart(AngularJsonMediaTypeFormatter.XsrfPrefix);

            Assert.Multiple(() =>
            {
                Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
                ContentItemDisplay display = JsonConvert.DeserializeObject<ContentItemDisplay>(body);
                Assert.AreEqual(1, display.Errors.Count(), string.Join(",", display.Errors));
                CollectionAssert.Contains(display.Errors.Keys, "Variants[0].Name");
            });
        }

        [Test]
        public async Task PostSave_Validate_Variants_Empty_Name()
        {
            ILocalizationService localizationService = GetRequiredService<ILocalizationService>();

            // Add another language
            localizationService.Save(new LanguageBuilder()
                .WithCultureInfo(DkIso)
                .WithIsDefault(false)
                .Build());

            string url = PrepareApiControllerUrl<ContentController>(x => x.PostSave(null));

            IContentService contentService = GetRequiredService<IContentService>();
            IContentTypeService contentTypeService = GetRequiredService<IContentTypeService>();

            IContentType contentType = new ContentTypeBuilder()
                .WithId(0)
                .AddPropertyType()
                .WithAlias("title")
                .WithValueStorageType(ValueStorageType.Integer)
                .WithPropertyEditorAlias(Constants.PropertyEditors.Aliases.TextBox)
                .WithName("Title")
                .Done()
                .WithContentVariation(ContentVariation.Culture)
                .Build();

            contentTypeService.Save(contentType);

            Content content = new ContentBuilder()
                .WithId(0)
                .WithCultureName(UsIso, "English")
                .WithCultureName(DkIso, "Danish")
                .WithContentType(contentType)
                .AddPropertyData()
                .WithKeyValue("title", "Cool invariant title")
                .Done()
                .Build();
            contentService.SaveAndPublish(content);

            content.CultureInfos[0].Name = null; // Removes the name of one of the variants to force an error
            ContentItemSave model = new ContentItemSaveBuilder()
                .WithContent(content)
                .Build();

            // Act
            HttpResponseMessage response = await Client.PostAsync(url, new MultipartFormDataContent
            {
                { new StringContent(JsonConvert.SerializeObject(model)), "contentItem" }
            });

            // Assert
            string body = await response.Content.ReadAsStringAsync();
            body = body.TrimStart(AngularJsonMediaTypeFormatter.XsrfPrefix);
            Assert.Multiple(() =>
            {
                Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
                ContentItemDisplay display = JsonConvert.DeserializeObject<ContentItemDisplay>(body);
                Assert.AreEqual(2, display.Errors.Count());
                CollectionAssert.Contains(display.Errors.Keys, "Variants[0].Name");
                CollectionAssert.Contains(display.Errors.Keys, "_content_variant_en-US_null_");
            });
        }

        [Test]
        public async Task PostSave_Validates_Domains_Exist()
        {
            ILocalizationService localizationService = GetRequiredService<ILocalizationService>();
            localizationService.Save(new LanguageBuilder()
                .WithCultureInfo(DkIso)
                .WithIsDefault(false)
                .Build());

            IContentTypeService contentTypeService = GetRequiredService<IContentTypeService>();
            IContentType contentType = new ContentTypeBuilder().WithContentVariation(ContentVariation.Culture).Build();
            contentTypeService.Save(contentType);

            Content content = new ContentBuilder()
                .WithId(1)
                .WithContentType(contentType)
                .WithCultureName(UsIso, "Root")
                .WithCultureName(DkIso, "Rod")
                .Build();

            ContentItemSave model = new ContentItemSaveBuilder()
                .WithContent(content)
                .WithAction(ContentSaveAction.PublishNew)
                .Build();

            var url = PrepareApiControllerUrl<ContentController>(x => x.PostSave(null));

            HttpResponseMessage response = await Client.PostAsync(url, new MultipartFormDataContent
            {
                { new StringContent(JsonConvert.SerializeObject(model)), "contentItem" }
            });

            var body = await response.Content.ReadAsStringAsync();
            body = body.TrimStart(AngularJsonMediaTypeFormatter.XsrfPrefix);
            ContentItemDisplay display = JsonConvert.DeserializeObject<ContentItemDisplay>(body);

            ILocalizedTextService localizedTextService = GetRequiredService<ILocalizedTextService>();
            var expectedMessage = localizedTextService.Localize("speechBubbles", "publishWithNoDomains");

            Assert.Multiple(() =>
            {
                Assert.IsNotNull(display);
                Assert.AreEqual(1, display.Notifications.Count(x => x.NotificationType == NotificationStyle.Warning));
                Assert.AreEqual(expectedMessage, display.Notifications.FirstOrDefault(x => x.NotificationType == NotificationStyle.Warning)?.Message);
            });
        }

        [Test]
        public async Task PostSave_Validates_All_Ancestor_Cultures_Are_Considered()
        {
            var sweIso = "sv-SE";
            ILocalizationService localizationService = GetRequiredService<ILocalizationService>();
            //Create 2 new languages
            localizationService.Save(new LanguageBuilder()
                .WithCultureInfo(DkIso)
                .WithIsDefault(false)
                .Build());

            localizationService.Save(new LanguageBuilder()
                .WithCultureInfo(sweIso)
                .WithIsDefault(false)
                .Build());

            IContentTypeService contentTypeService = GetRequiredService<IContentTypeService>();
            IContentType contentType = new ContentTypeBuilder().WithContentVariation(ContentVariation.Culture).Build();
            contentTypeService.Save(contentType);

            Content content = new ContentBuilder()
                .WithoutIdentity()
                .WithContentType(contentType)
                .WithCultureName(UsIso, "Root")
                .Build();

            IContentService contentService = GetRequiredService<IContentService>();
            contentService.SaveAndPublish(content);

            Content childContent = new ContentBuilder()
                .WithoutIdentity()
                .WithContentType(contentType)
                .WithParent(content)
                .WithCultureName(DkIso, "Barn")
                .WithCultureName(UsIso, "Child")
                .Build();

            contentService.SaveAndPublish(childContent);

            Content grandChildContent = new ContentBuilder()
                .WithoutIdentity()
                .WithContentType(contentType)
                .WithParent(childContent)
                .WithCultureName(sweIso, "Bjarn")
                .Build();


            ContentItemSave model = new ContentItemSaveBuilder()
                .WithContent(grandChildContent)
                .WithParentId(childContent.Id)
                .WithAction(ContentSaveAction.PublishNew)
                .Build();

            ILanguage enLanguage = localizationService.GetLanguageByIsoCode(UsIso);
            IDomainService domainService = GetRequiredService<IDomainService>();
            var enDomain = new UmbracoDomain("/en")
            {
                RootContentId = content.Id,
                LanguageId = enLanguage.Id
            };
            domainService.Save(enDomain);

            ILanguage dkLanguage = localizationService.GetLanguageByIsoCode(DkIso);
            var dkDomain = new UmbracoDomain("/dk")
            {
                RootContentId = childContent.Id,
                LanguageId = dkLanguage.Id
            };
            domainService.Save(dkDomain);

            var url = PrepareApiControllerUrl<ContentController>(x => x.PostSave(null));

            HttpResponseMessage response = await Client.PostAsync(url, new MultipartFormDataContent
            {
                { new StringContent(JsonConvert.SerializeObject(model)), "contentItem" }
            });

            var body = await response.Content.ReadAsStringAsync();
            body = body.TrimStart(AngularJsonMediaTypeFormatter.XsrfPrefix);
            ContentItemDisplay display = JsonConvert.DeserializeObject<ContentItemDisplay>(body);


            ILocalizedTextService localizedTextService = GetRequiredService<ILocalizedTextService>();
            var expectedMessage = localizedTextService.Localize("speechBubbles", "publishWithMissingDomain", new []{"sv-SE"});

            Assert.Multiple(() =>
            {
                Assert.NotNull(display);
                Assert.AreEqual(1, display.Notifications.Count(x => x.NotificationType == NotificationStyle.Warning));
                Assert.AreEqual(expectedMessage, display.Notifications.FirstOrDefault(x => x.NotificationType == NotificationStyle.Warning)?.Message);
            });
        }

        [Test]
        public async Task PostSave_Validates_All_Cultures_Has_Domains()
        {
            ILocalizationService localizationService = GetRequiredService<ILocalizationService>();
            localizationService.Save(new LanguageBuilder()
                .WithCultureInfo(DkIso)
                .WithIsDefault(false)
                .Build());

            IContentTypeService contentTypeService = GetRequiredService<IContentTypeService>();
            IContentType contentType = new ContentTypeBuilder().WithContentVariation(ContentVariation.Culture).Build();
            contentTypeService.Save(contentType);

            Content content = new ContentBuilder()
                .WithoutIdentity()
                .WithContentType(contentType)
                .WithCultureName(UsIso, "Root")
                .WithCultureName(DkIso, "Rod")
                .Build();

            IContentService contentService = GetRequiredService<IContentService>();
            contentService.Save(content);

            ContentItemSave model = new ContentItemSaveBuilder()
                .WithContent(content)
                .WithAction(ContentSaveAction.Publish)
                .Build();

            ILanguage dkLanguage = localizationService.GetLanguageByIsoCode(DkIso);
            IDomainService domainService = GetRequiredService<IDomainService>();
            var dkDomain = new UmbracoDomain("/")
            {
                RootContentId = content.Id,
                LanguageId = dkLanguage.Id
            };
            domainService.Save(dkDomain);

            var url = PrepareApiControllerUrl<ContentController>(x => x.PostSave(null));

            HttpResponseMessage response = await Client.PostAsync(url, new MultipartFormDataContent
            {
                { new StringContent(JsonConvert.SerializeObject(model)), "contentItem" }
            });

            var body = await response.Content.ReadAsStringAsync();
            body = body.TrimStart(AngularJsonMediaTypeFormatter.XsrfPrefix);
            ContentItemDisplay display = JsonConvert.DeserializeObject<ContentItemDisplay>(body);


            ILocalizedTextService localizedTextService = GetRequiredService<ILocalizedTextService>();
            var expectedMessage = localizedTextService.Localize("speechBubbles", "publishWithMissingDomain", new []{UsIso});

            Assert.Multiple(() =>
            {
                Assert.NotNull(display);
                Assert.AreEqual(1, display.Notifications.Count(x => x.NotificationType == NotificationStyle.Warning));
                Assert.AreEqual(expectedMessage, display.Notifications.FirstOrDefault(x => x.NotificationType == NotificationStyle.Warning)?.Message);
            });
        }

        [Test]
        public async Task PostSave_Checks_Ancestors_For_Domains()
        {
            ILocalizationService localizationService = GetRequiredService<ILocalizationService>();
            localizationService.Save(new LanguageBuilder()
                .WithCultureInfo(DkIso)
                .WithIsDefault(false)
                .Build());

            IContentTypeService contentTypeService = GetRequiredService<IContentTypeService>();
            IContentType contentType = new ContentTypeBuilder().WithContentVariation(ContentVariation.Culture).Build();
            contentTypeService.Save(contentType);

            Content rootNode = new ContentBuilder()
                .WithoutIdentity()
                .WithContentType(contentType)
                .WithCultureName(UsIso, "Root")
                .WithCultureName(DkIso, "Rod")
                .Build();

            IContentService contentService = GetRequiredService<IContentService>();
            contentService.SaveAndPublish(rootNode);

            Content childNode = new ContentBuilder()
                .WithoutIdentity()
                .WithParent(rootNode)
                .WithContentType(contentType)
                .WithCultureName(DkIso, "Barn")
                .WithCultureName(UsIso, "Child")
                .Build();

            contentService.SaveAndPublish(childNode);

            Content grandChild = new ContentBuilder()
                .WithoutIdentity()
                .WithParent(childNode)
                .WithContentType(contentType)
                .WithCultureName(DkIso, "BarneBarn")
                .WithCultureName(UsIso, "GrandChild")
                .Build();

            contentService.Save(grandChild);

            ILanguage dkLanguage = localizationService.GetLanguageByIsoCode(DkIso);
            ILanguage usLanguage = localizationService.GetLanguageByIsoCode(UsIso);
            IDomainService domainService = GetRequiredService<IDomainService>();
            var dkDomain = new UmbracoDomain("/")
            {
                RootContentId = rootNode.Id,
                LanguageId = dkLanguage.Id
            };

            var usDomain = new UmbracoDomain("/en")
            {
                RootContentId = childNode.Id,
                LanguageId = usLanguage.Id
            };

            domainService.Save(dkDomain);
            domainService.Save(usDomain);

            var url = PrepareApiControllerUrl<ContentController>(x => x.PostSave(null));

            ContentItemSave model = new ContentItemSaveBuilder()
                .WithContent(grandChild)
                .WithAction(ContentSaveAction.Publish)
                .Build();

            HttpResponseMessage response = await Client.PostAsync(url, new MultipartFormDataContent
            {
                { new StringContent(JsonConvert.SerializeObject(model)), "contentItem" }
            });

            var body = await response.Content.ReadAsStringAsync();
            body = body.TrimStart(AngularJsonMediaTypeFormatter.XsrfPrefix);
            ContentItemDisplay display = JsonConvert.DeserializeObject<ContentItemDisplay>(body);

            Assert.Multiple(() =>
            {
                Assert.NotNull(display);
                // Assert all is good, a success notification for each culture published and no warnings.
                Assert.AreEqual(2, display.Notifications.Count(x => x.NotificationType == NotificationStyle.Success));
                Assert.AreEqual(0, display.Notifications.Count(x => x.NotificationType == NotificationStyle.Warning));
            });
        }
    }
}