// <copyright file="JsonCommaDelimitedCollectionTests.cs" company="PlaceholderCompany">
// Copyright (c) PlaceholderCompany. All rights reserved.
// </copyright>

#pragma warning disable CA1707 // Identifiers should not contain underscores - xUnit test naming convention
#pragma warning disable CA1861 // Avoid constant arrays as arguments - required for xUnit theory test data

namespace Jellyfin.Extensions.Tests.Json.Converters
{
    using System;
    using System.Collections.Generic;
    using System.Collections.Immutable;
    using System.Text.Json;
    using System.Text.Json.Serialization;
    using Jellyfin.Extensions.Tests.Json.Models;
    using MediaBrowser.Model.Session;
    using Xunit;

    /// <summary>
    /// Tests for JSON comma delimited collection converter.
    /// </summary>
    public class JsonCommaDelimitedCollectionTests
    {
        private readonly JsonSerializerOptions jsonOptions = new()
        {
            Converters =
            {
                new JsonStringEnumConverter(),
            },
        };

        /// <summary>
        /// Tests that deserializing null string value succeeds.
        /// </summary>
        [Fact]
        public void Deserialize_String_Null_Success()
        {
            GenericBodyArrayModel<string>? value = JsonSerializer.Deserialize<GenericBodyArrayModel<string>>(@"{ ""Value"": null }", this.jsonOptions);
            Assert.Null(value?.Value);
        }

        /// <summary>
        /// Tests that deserializing empty string succeeds.
        /// </summary>
        [Fact]
        public void Deserialize_Empty_Success()
        {
            GenericBodyArrayModel<string> desiredValue = new()
            {
                Value = [],
            };

            GenericBodyArrayModel<string>? value = JsonSerializer.Deserialize<GenericBodyArrayModel<string>>(@"{ ""Value"": """" }", this.jsonOptions);
            Assert.Equal(desiredValue.Value, value?.Value);
        }

        /// <summary>
        /// Tests that deserializing empty string to list throws exception.
        /// </summary>
        [Fact]
        public void Deserialize_EmptyList_Success()
        {
            GenericBodyListModel<string> desiredValue = new()
            {
                Value = [],
            };

            _ = Assert.Throws<InvalidOperationException>(() => JsonSerializer.Deserialize<GenericBodyListModel<string>>(@"{ ""Value"": """" }", this.jsonOptions));
        }

        /// <summary>
        /// Tests that deserializing empty string to IReadOnlyList succeeds.
        /// </summary>
        [Fact]
        public void Deserialize_EmptyIReadOnlyList_Success()
        {
            GenericBodyIReadOnlyListModel<string> desiredValue = new()
            {
                Value = [],
            };

            GenericBodyIReadOnlyListModel<string>? value = JsonSerializer.Deserialize<GenericBodyIReadOnlyListModel<string>>(@"{ ""Value"": """" }", this.jsonOptions);
            Assert.Equal(desiredValue.Value, value?.Value);
        }

        /// <summary>
        /// Tests that deserializing comma-delimited string succeeds.
        /// </summary>
        [Fact]
        public void Deserialize_String_Valid_Success()
        {
            GenericBodyArrayModel<string> desiredValue = new()
            {
                Value = ["a", "b", "c"],
            };

            GenericBodyArrayModel<string>? value = JsonSerializer.Deserialize<GenericBodyArrayModel<string>>(@"{ ""Value"": ""a,b,c"" }", this.jsonOptions);
            Assert.Equal(desiredValue.Value, value?.Value);
        }

        /// <summary>
        /// Tests that deserializing comma-delimited string to list throws exception.
        /// </summary>
        [Fact]
        public void Deserialize_StringList_Valid_Success()
        {
            GenericBodyListModel<string> desiredValue = new()
            {
                Value = ["a", "b", "c"],
            };

            _ = Assert.Throws<InvalidOperationException>(() => JsonSerializer.Deserialize<GenericBodyListModel<string>>(@"{ ""Value"": ""a,b,c"" }", this.jsonOptions));
        }

        /// <summary>
        /// Tests that deserializing comma-delimited string with spaces succeeds.
        /// </summary>
        [Fact]
        public void Deserialize_String_Space_Valid_Success()
        {
            GenericBodyArrayModel<string> desiredValue = new()
            {
                Value = ["a", "b", "c"],
            };

            GenericBodyArrayModel<string>? value = JsonSerializer.Deserialize<GenericBodyArrayModel<string>>(@"{ ""Value"": ""a, b, c"" }", this.jsonOptions);
            Assert.Equal(desiredValue.Value, value?.Value);
        }

        /// <summary>
        /// Tests that deserializing comma-delimited enum string succeeds.
        /// </summary>
        [Fact]
        public void Deserialize_GenericCommandType_Valid_Success()
        {
            GenericBodyArrayModel<GeneralCommandType> desiredValue = new()
            {
                Value = [GeneralCommandType.MoveUp, GeneralCommandType.MoveDown],
            };

            GenericBodyArrayModel<GeneralCommandType>? value = JsonSerializer.Deserialize<GenericBodyArrayModel<GeneralCommandType>>(@"{ ""Value"": ""MoveUp,MoveDown"" }", this.jsonOptions);
            Assert.Equal(desiredValue.Value, value?.Value);
        }

        /// <summary>
        /// Tests that deserializing comma-delimited enum string with empty entry succeeds.
        /// </summary>
        [Fact]
        public void Deserialize_GenericCommandType_EmptyEntry_Success()
        {
            GenericBodyArrayModel<GeneralCommandType> desiredValue = new()
            {
                Value = [GeneralCommandType.MoveUp, GeneralCommandType.MoveDown],
            };

            GenericBodyArrayModel<GeneralCommandType>? value = JsonSerializer.Deserialize<GenericBodyArrayModel<GeneralCommandType>>(@"{ ""Value"": ""MoveUp,,MoveDown"" }", this.jsonOptions);
            Assert.Equal(desiredValue.Value, value?.Value);
        }

        /// <summary>
        /// Tests that deserializing comma-delimited enum string with invalid value succeeds.
        /// </summary>
        [Fact]
        public void Deserialize_GenericCommandType_Invalid_Success()
        {
            GenericBodyArrayModel<GeneralCommandType> desiredValue = new()
            {
                Value = [GeneralCommandType.MoveUp, GeneralCommandType.MoveDown],
            };

            GenericBodyArrayModel<GeneralCommandType>? value = JsonSerializer.Deserialize<GenericBodyArrayModel<GeneralCommandType>>(@"{ ""Value"": ""MoveUp,TotallyNotAValidCommand,MoveDown"" }", this.jsonOptions);
            Assert.Equal(desiredValue.Value, value?.Value);
        }

        /// <summary>
        /// Tests that deserializing comma-delimited enum string with spaces succeeds.
        /// </summary>
        [Fact]
        public void Deserialize_GenericCommandType_Space_Valid_Success()
        {
            GenericBodyArrayModel<GeneralCommandType> desiredValue = new()
            {
                Value = [GeneralCommandType.MoveUp, GeneralCommandType.MoveDown],
            };

            GenericBodyArrayModel<GeneralCommandType>? value = JsonSerializer.Deserialize<GenericBodyArrayModel<GeneralCommandType>>(@"{ ""Value"": ""MoveUp, MoveDown"" }", this.jsonOptions);
            Assert.Equal(desiredValue.Value, value?.Value);
        }

        /// <summary>
        /// Tests that deserializing JSON array of strings succeeds.
        /// </summary>
        [Fact]
        public void Deserialize_String_Array_Valid_Success()
        {
            GenericBodyArrayModel<string> desiredValue = new()
            {
                Value = ["a", "b", "c"],
            };

            GenericBodyArrayModel<string>? value = JsonSerializer.Deserialize<GenericBodyArrayModel<string>>(@"{ ""Value"": [""a"",""b"",""c""] }", this.jsonOptions);
            Assert.Equal(desiredValue.Value, value?.Value);
        }

        /// <summary>
        /// Tests that deserializing JSON array of enums succeeds.
        /// </summary>
        [Fact]
        public void Deserialize_GenericCommandType_Array_Valid_Success()
        {
            GenericBodyArrayModel<GeneralCommandType> desiredValue = new()
            {
                Value = [GeneralCommandType.MoveUp, GeneralCommandType.MoveDown],
            };

            GenericBodyArrayModel<GeneralCommandType>? value = JsonSerializer.Deserialize<GenericBodyArrayModel<GeneralCommandType>>(@"{ ""Value"": [""MoveUp"", ""MoveDown""] }", this.jsonOptions);
            Assert.Equal(desiredValue.Value, value?.Value);
        }

        /// <summary>
        /// Tests that serializing readonly collection succeeds.
        /// </summary>
        [Fact]
        public void Serialize_GenericCommandType_ReadOnlyArray_Valid_Success()
        {
            GenericBodyIReadOnlyCollectionModel<GeneralCommandType> valueToSerialize = new()
            {
                Value = new[] { GeneralCommandType.MoveUp, GeneralCommandType.MoveDown }.AsReadOnly(),
            };

            string value = JsonSerializer.Serialize<GenericBodyIReadOnlyCollectionModel<GeneralCommandType>>(valueToSerialize, this.jsonOptions);
            Assert.Equal(@"{""Value"":[""MoveUp"",""MoveDown""]}", value);
        }

        /// <summary>
        /// Tests that serializing immutable array succeeds.
        /// </summary>
        [Fact]
        public void Serialize_GenericCommandType_ImmutableArrayArray_Valid_Success()
        {
            GenericBodyIReadOnlyCollectionModel<GeneralCommandType> valueToSerialize = new()
            {
                Value = ImmutableArray.Create([GeneralCommandType.MoveUp, GeneralCommandType.MoveDown]),
            };

            string value = JsonSerializer.Serialize<GenericBodyIReadOnlyCollectionModel<GeneralCommandType>>(valueToSerialize, this.jsonOptions);
            Assert.Equal(@"{""Value"":[""MoveUp"",""MoveDown""]}", value);
        }

        /// <summary>
        /// Tests that serializing list succeeds.
        /// </summary>
        [Fact]
        public void Serialize_GenericCommandType_List_Valid_Success()
        {
            GenericBodyIReadOnlyListModel<GeneralCommandType> valueToSerialize = new()
            {
                Value = [GeneralCommandType.MoveUp, GeneralCommandType.MoveDown],
            };

            string value = JsonSerializer.Serialize<GenericBodyIReadOnlyListModel<GeneralCommandType>>(valueToSerialize, this.jsonOptions);
            Assert.Equal(@"{""Value"":[""MoveUp"",""MoveDown""]}", value);
        }
    }
}

#pragma warning restore CA1707
#pragma warning restore CA1861
