using NUnit.Framework;
using System;
using Newtonsoft.Json.Linq;
using UVC.Data;
using UnityEngine;

namespace UVC.Tests.Data
{
    /// <summary>
    /// DataMapper 클래스의 테스트를 위한 테스트 클래스입니다.
    /// </summary>
    [TestFixture]
    public class DataMapperTests
    {

        /// <summary>
        /// 모든 테스트 메서드를 실행하는 메서드입니다.
        /// </summary>
        /// <remarks>
        /// 이 메서드는 클래스의 모든 테스트 메서드를 순차적으로 호출하고 
        /// 각 테스트의 성공 또는 실패 여부를 로그로 출력합니다.
        /// </remarks>
        public void TestAll()
        {
            Debug.Log("===== DataMapper 테스트 시작 =====");

            RunTest(nameof(Map_StringProperty_MapsCorrectly), Map_StringProperty_MapsCorrectly);
            RunTest(nameof(Map_IntProperty_MapsCorrectly), Map_IntProperty_MapsCorrectly);
            RunTest(nameof(Map_DoubleProperty_MapsCorrectly), Map_DoubleProperty_MapsCorrectly);
            RunTest(nameof(Map_BoolProperty_MapsCorrectly), Map_BoolProperty_MapsCorrectly);
            RunTest(nameof(Map_DateTimeProperty_MapsCorrectly), Map_DateTimeProperty_MapsCorrectly);
            RunTest(nameof(Map_DataValueMapperProperty_MapsCorrectly), Map_DataValueMapperProperty_MapsCorrectly);
            RunTest(nameof(Map_DataValueMapperWithUnmappedValue_ReturnsOriginal), Map_DataValueMapperWithUnmappedValue_ReturnsOriginal);
            RunTest(nameof(Map_EnumProperty_MapsCorrectly), Map_EnumProperty_MapsCorrectly);
            RunTest(nameof(Map_AdditionalProperty_AddsToResult), Map_AdditionalProperty_AddsToResult);
            RunTest(nameof(Map_InvalidDateTimeString_ReturnsNull), Map_InvalidDateTimeString_ReturnsNull);
            RunTest(nameof(Map_ComplexObject_MapsAllProperties), Map_ComplexObject_MapsAllProperties);
            RunTest(nameof(Map_NestedObject_MapsCorrectly), Map_NestedObject_MapsCorrectly);
            RunTest(nameof(Map_ArrayMapping_MapsCorrectly), Map_ArrayMapping_MapsCorrectly);
            RunTest(nameof(Map_EmptyGuideArray_CopiesSourceArray), Map_EmptyGuideArray_CopiesSourceArray);
            RunTest(nameof(Map_ComplexNestedStructure_MapsCorrectly), Map_ComplexNestedStructure_MapsCorrectly);
            RunTest(nameof(Map_MixedArrayTypes_HandlesCorrectly), Map_MixedArrayTypes_HandlesCorrectly);

            Debug.Log("===== DataMapper 테스트 완료 =====");
        }

        /// <summary>
        /// 단일 테스트 메서드를 실행하고 결과를 로그로 출력합니다.
        /// </summary>
        /// <param name="testName">테스트 메서드 이름</param>
        /// <param name="testAction">실행할 테스트 메서드</param>
        private void RunTest(string testName, Action testAction)
        {
            try
            {
                Debug.Log($"테스트 시작: {testName}");
                testAction();
                Debug.Log($"테스트 성공: {testName}");
            }
            catch (Exception ex)
            {
                Debug.LogError($"테스트 실패: {testName}\n{ex.Message}\n{ex.StackTrace}");
            }
        }

        /// <summary>
        /// 문자열 타입 매핑 테스트
        /// </summary>
        [Test]
        public void Map_StringProperty_MapsCorrectly()
        {
            // Arrange
            var guide = new JObject();
            guide["Name"] = "홍길동";

            var source = JObject.Parse(@"{ ""Name"": ""김철수"" }");

            var mapper = new DataMapper(source, guide);

            // Act
            var result = mapper.Map();

            // Assert
            Assert.IsTrue(result.ContainsKey("Name"));
            Assert.AreEqual("김철수", result["Name"].ToString());
        }

        /// <summary>
        /// 정수 타입 매핑 테스트
        /// </summary>
        [Test]
        public void Map_IntProperty_MapsCorrectly()
        {
            // Arrange
            var guide = new JObject();
            guide["Age"] = 25;

            var source = JObject.Parse(@"{ ""Age"": 30 }");

            var mapper = new DataMapper(source, guide);

            // Act
            var result = mapper.Map();

            // Assert
            Assert.IsTrue(result.ContainsKey("Age"));
            Assert.AreEqual(30, result["Age"].ToObject<int>());
        }

        /// <summary>
        /// 부동소수점 타입 매핑 테스트
        /// </summary>
        [Test]
        public void Map_DoubleProperty_MapsCorrectly()
        {
            // Arrange
            var guide = new JObject();
            guide["Height"] = 175.5;

            var source = JObject.Parse(@"{ ""Height"": 180.5 }");

            var mapper = new DataMapper(source, guide);

            // Act
            var result = mapper.Map();

            // Assert
            Assert.IsTrue(result.ContainsKey("Height"));
            Assert.AreEqual(180.5, result["Height"].ToObject<double>());
        }

        /// <summary>
        /// Boolean 타입 매핑 테스트
        /// </summary>
        [Test]
        public void Map_BoolProperty_MapsCorrectly()
        {
            // Arrange
            var guide = new JObject();
            guide["IsActive"] = false;

            var source = JObject.Parse(@"{ ""IsActive"": true }");

            var mapper = new DataMapper(source, guide);

            // Act
            var result = mapper.Map();

            // Assert
            Assert.IsTrue(result.ContainsKey("IsActive"));
            Assert.IsTrue(result["IsActive"].ToObject<bool>());
        }

        /// <summary>
        /// DateTime 타입 매핑 테스트
        /// </summary>
        [Test]
        public void Map_DateTimeProperty_MapsCorrectly()
        {
            // Arrange
            var guide = new JObject();
            guide["BirthDate"] = JToken.FromObject(DateTime.Now);

            var expectedDate = new DateTime(1990, 1, 1);
            var source = JObject.Parse(@"{ ""BirthDate"": ""1990-01-01T00:00:00.000"" }");

            var mapper = new DataMapper(source, guide);

            // Act
            var result = mapper.Map();

            // Assert
            Assert.IsTrue(result.ContainsKey("BirthDate"));
            Assert.AreEqual(expectedDate, result["BirthDate"].ToObject<DateTime>());
        }

        /// <summary>
        /// DataValueMapper 타입 매핑 테스트
        /// </summary>
        [Test]
        public void Map_DataValueMapperProperty_MapsCorrectly()
        {
            // Arrange
            var guide = new JObject();
            var valueMapper = new DataValueMapper();
            valueMapper["ON"] = "활성화";
            valueMapper["OFF"] = "비활성화";
            guide["Status"] = JToken.FromObject(valueMapper);

            var source = JObject.Parse(@"{ ""Status"": ""ON"" }");

            var mapper = new DataMapper(source, guide);

            // Act
            var result = mapper.Map();

            // Assert
            Assert.IsTrue(result.ContainsKey("Status"));
            Assert.AreEqual("활성화", result["Status"].ToString());
        }

        /// <summary>
        /// DataValueMapper에 매핑되지 않는 값 처리 테스트
        /// </summary>
        [Test]
        public void Map_DataValueMapperWithUnmappedValue_ReturnsOriginal()
        {
            // Arrange
            var guide = new JObject();
            var valueMapper = new DataValueMapper();
            valueMapper["ON"] = "활성화";
            valueMapper["OFF"] = "비활성화";
            guide["Status"] = JToken.FromObject(valueMapper);

            var source = JObject.Parse(@"{ ""Status"": ""UNKNOWN"" }");

            var mapper = new DataMapper(source, guide);

            // Act
            var result = mapper.Map();

            // Assert
            Assert.IsTrue(result.ContainsKey("Status"));
            Assert.AreEqual("UNKNOWN", result["Status"].ToString());
        }

        /// <summary>
        /// 열거형 타입 매핑 테스트
        /// </summary>
        [Test]
        public void Map_EnumProperty_MapsCorrectly()
        {
            // Arrange
            var guide = new JObject();
            guide["Status"] = JToken.FromObject(UserStatus.Inactive);

            var source = JObject.Parse(@"{ ""Status"": ""Active"" }");

            var mapper = new DataMapper(source, guide);

            // Act
            var result = mapper.Map();

            // Assert
            Assert.IsTrue(result.ContainsKey("Status"));
            Assert.AreEqual(UserStatus.Active, result["Status"].ToObject<UserStatus>());
        }

        /// <summary>
        /// 타겟에 없는 추가 속성 매핑 테스트
        /// </summary>
        [Test]
        public void Map_AdditionalProperty_AddsToResult()
        {
            // Arrange
            var guide = new JObject();
            guide["Name"] = "홍길동";

            var source = JObject.Parse(@"{ ""Name"": ""김철수"", ""Email"": ""kim@example.com"" }");

            var mapper = new DataMapper(source, guide);

            // Act
            var result = mapper.Map();

            // Assert
            Assert.IsTrue(result.ContainsKey("Email"));
            Assert.AreEqual("kim@example.com", result["Email"].ToString());
        }

        /// <summary>
        /// 유효하지 않은 DateTime 문자열 매핑 테스트
        /// </summary>
        [Test]
        public void Map_InvalidDateTimeString_ReturnsNull()
        {
            // Arrange
            var guide = new JObject();
            guide["BirthDate"] = JToken.FromObject(DateTime.Now);

            var source = JObject.Parse(@"{ ""BirthDate"": ""InvalidDateTime"" }");

            var mapper = new DataMapper(source, guide);

            // Act
            var result = mapper.Map();

            // Assert
            Assert.IsTrue(result.ContainsKey("BirthDate"));
            Assert.AreEqual(JTokenType.Null, result["BirthDate"].Type);
        }

        /// <summary>
        /// 복합 객체 매핑 테스트
        /// </summary>
        [Test]
        public void Map_ComplexObject_MapsAllProperties()
        {
            // Arrange
            var guide = new JObject();
            guide["Id"] = 1;
            guide["Name"] = "홍길동";
            guide["IsActive"] = false;
            guide["JoinDate"] = JToken.FromObject(DateTime.Now);
            guide["Height"] = 175.5;
            guide["Status"] = JToken.FromObject(UserStatus.Inactive);

            string json = @"{
                ""Id"": 100,
                ""Name"": ""김철수"",
                ""IsActive"": true,
                ""JoinDate"": ""2023-01-01T00:00:00"",
                ""Height"": 180.0,
                ""Status"": ""Active"",
                ""Email"": ""kim@example.com""
            }";

            var source = JObject.Parse(json);
            var mapper = new DataMapper(source, guide);

            // Act
            var result = mapper.Map();

            // Assert
            Assert.AreEqual(7, result.Count);
            Assert.AreEqual(100, result["Id"].ToObject<int>());
            Assert.AreEqual("김철수", result["Name"].ToString());
            Assert.IsTrue(result["IsActive"].ToObject<bool>());
            Assert.AreEqual(new DateTime(2023, 1, 1), result["JoinDate"].ToObject<DateTime>());
            Assert.AreEqual(180.0, result["Height"].ToObject<double>());
            Assert.AreEqual(UserStatus.Active, result["Status"].ToObject<UserStatus>());
            Assert.AreEqual("kim@example.com", result["Email"].ToString());
        }

        /// <summary>
        /// 중첩된 객체 매핑 테스트 - 새로 추가
        /// </summary>
        [Test]
        public void Map_NestedObject_MapsCorrectly()
        {
            // Arrange
            var guide = new JObject
            {
                ["User"] = new JObject
                {
                    ["Name"] = "홍길동",
                    ["Address"] = new JObject
                    {
                        ["City"] = "서울",
                        ["ZipCode"] = "12345"
                    }
                }
            };

            var source = JObject.Parse(@"{
                ""User"": {
                    ""Name"": ""김철수"",
                    ""Address"": {
                        ""City"": ""부산"",
                        ""ZipCode"": ""67890"",
                        ""Country"": ""대한민국""
                    }
                }
            }");

            var mapper = new DataMapper(source, guide);

            // Act
            var result = mapper.Map();

            // Assert
            Assert.IsTrue(result.ContainsKey("User"));
            var user = result["User"] as JObject;
            Assert.IsNotNull(user);
            Assert.AreEqual("김철수", user["Name"].ToString());

            var address = user["Address"] as JObject;
            Assert.IsNotNull(address);
            Assert.AreEqual("부산", address["City"].ToString());
            Assert.AreEqual("67890", address["ZipCode"].ToString());
            Assert.AreEqual("대한민국", address["Country"].ToString());
        }

        /// <summary>
        /// 배열 매핑 테스트 - 새로 추가
        /// </summary>
        [Test]
        public void Map_ArrayMapping_MapsCorrectly()
        {
            // Arrange
            var guide = new JObject
            {
                ["Contacts"] = new JArray
                {
                    new JObject
                    {
                        ["Type"] = "mobile",
                        ["Number"] = "010-0000-0000"
                    }
                }
            };

            var source = JObject.Parse(@"{
                ""Contacts"": [
                    { ""Type"": ""mobile"", ""Number"": ""010-1234-5678"" },
                    { ""Type"": ""home"", ""Number"": ""02-123-4567"", ""Extension"": ""123"" }
                ]
            }");

            var mapper = new DataMapper(source, guide);

            // Act
            var result = mapper.Map();

            // Assert
            Assert.IsTrue(result.ContainsKey("Contacts"));
            var contacts = result["Contacts"] as JArray;
            Assert.IsNotNull(contacts);
            Assert.AreEqual(2, contacts.Count);

            var contact1 = contacts[0] as JObject;
            Assert.IsNotNull(contact1);
            Assert.AreEqual("mobile", contact1["Type"].ToString());
            Assert.AreEqual("010-1234-5678", contact1["Number"].ToString());

            var contact2 = contacts[1] as JObject;
            Assert.IsNotNull(contact2);
            Assert.AreEqual("home", contact2["Type"].ToString());
            Assert.AreEqual("02-123-4567", contact2["Number"].ToString());
            Assert.AreEqual("123", contact2["Extension"].ToString());
        }

        /// <summary>
        /// 빈 가이드 배열 테스트 - 새로 추가
        /// </summary>
        [Test]
        public void Map_EmptyGuideArray_CopiesSourceArray()
        {
            // Arrange
            var guide = new JObject
            {
                ["Tags"] = new JArray()
            };

            var source = JObject.Parse(@"{
                ""Tags"": [""개발"", ""테스트"", ""배포""]
            }");

            var mapper = new DataMapper(source, guide);

            // Act
            var result = mapper.Map();

            // Assert
            Assert.IsTrue(result.ContainsKey("Tags"));
            var tags = result["Tags"] as JArray;
            Assert.IsNotNull(tags);
            Assert.AreEqual(3, tags.Count);
            Assert.AreEqual("개발", tags[0].ToString());
            Assert.AreEqual("테스트", tags[1].ToString());
            Assert.AreEqual("배포", tags[2].ToString());
        }

        /// <summary>
        /// 복잡한 중첩 구조 매핑 테스트 - 새로 추가
        /// </summary>
        [Test]
        public void Map_ComplexNestedStructure_MapsCorrectly()
        {
            // Arrange
            var guide = new JObject
            {
                ["Company"] = new JObject
                {
                    ["Name"] = "회사명",
                    ["Founded"] = JToken.FromObject(DateTime.Now),
                    ["Departments"] = new JArray
                    {
                        new JObject
                        {
                            ["Name"] = "부서명",
                            ["Employees"] = new JArray
                            {
                                new JObject
                                {
                                    ["Name"] = "직원명",
                                    ["Age"] = 30,
                                    ["Status"] = JToken.FromObject(UserStatus.Active)
                                }
                            }
                        }
                    }
                }
            };

            var source = JObject.Parse(@"{
                ""Company"": {
                    ""Name"": ""XYZ 주식회사"",
                    ""Founded"": ""2000-01-01T00:00:00"",
                    ""Departments"": [
                        {
                            ""Name"": ""개발부"",
                            ""Employees"": [
                                { ""Name"": ""김개발"", ""Age"": 35, ""Status"": ""Active"" },
                                { ""Name"": ""이테스트"", ""Age"": 28, ""Status"": ""Inactive"" }
                            ]
                        },
                        {
                            ""Name"": ""마케팅부"",
                            ""Employees"": [
                                { ""Name"": ""박마케팅"", ""Age"": 32, ""Status"": ""Active"" }
                            ],
                            ""Budget"": 500000
                        }
                    ],
                    ""Address"": ""서울시 강남구""
                }
            }");

            var mapper = new DataMapper(source, guide);

            // Act
            var result = mapper.Map();

            // Assert
            var company = result["Company"] as JObject;
            Assert.IsNotNull(company);
            Assert.AreEqual("XYZ 주식회사", company["Name"].ToString());
            Assert.AreEqual(new DateTime(2000, 1, 1), company["Founded"].ToObject<DateTime>());
            Assert.AreEqual("서울시 강남구", company["Address"].ToString());

            var departments = company["Departments"] as JArray;
            Assert.IsNotNull(departments);
            Assert.AreEqual(2, departments.Count);

            var devDept = departments[0] as JObject;
            Assert.AreEqual("개발부", devDept["Name"].ToString());
            var devEmployees = devDept["Employees"] as JArray;
            Assert.AreEqual(2, devEmployees.Count);
            Assert.AreEqual("김개발", devEmployees[0]["Name"].ToString());
            Assert.AreEqual(35, devEmployees[0]["Age"].ToObject<int>());
            Assert.AreEqual(UserStatus.Active, devEmployees[0]["Status"].ToObject<UserStatus>());
            Assert.AreEqual("이테스트", devEmployees[1]["Name"].ToString());
            Assert.AreEqual(UserStatus.Inactive, devEmployees[1]["Status"].ToObject<UserStatus>());

            var marketingDept = departments[1] as JObject;
            Assert.AreEqual("마케팅부", marketingDept["Name"].ToString());
            Assert.AreEqual(500000, marketingDept["Budget"].ToObject<int>());
            var marketingEmployees = marketingDept["Employees"] as JArray;
            Assert.AreEqual(1, marketingEmployees.Count);
            Assert.AreEqual("박마케팅", marketingEmployees[0]["Name"].ToString());
        }

        /// <summary>
        /// 다양한 형식의 배열 테스트 - 새로 추가
        /// </summary>
        [Test]
        public void Map_MixedArrayTypes_HandlesCorrectly()
        {
            // Arrange
            var guide = new JObject
            {
                ["MixedArray"] = new JArray
                {
                    "문자열",
                    123,
                    true,
                    new JObject { ["Key"] = "Value" }
                }
            };

            var source = JObject.Parse(@"{
                ""MixedArray"": [
                    ""테스트"",
                    456,
                    false,
                    { ""Key"": ""NewValue"", ""Extra"": ""ExtraValue"" },
                    [1, 2, 3]
                ]
            }");

            var mapper = new DataMapper(source, guide);

            // Act
            var result = mapper.Map();

            // Assert
            var mixedArray = result["MixedArray"] as JArray;
            Assert.IsNotNull(mixedArray);
            Assert.AreEqual(5, mixedArray.Count);
            Assert.AreEqual("테스트", mixedArray[0].ToString());
            Assert.AreEqual(456, mixedArray[1].ToObject<int>());
            Assert.AreEqual(false, mixedArray[2].ToObject<bool>());

            var objInArray = mixedArray[3] as JObject;
            Assert.IsNotNull(objInArray);
            Assert.AreEqual("NewValue", objInArray["Key"].ToString());
            Assert.AreEqual("ExtraValue", objInArray["Extra"].ToString());

            var nestedArray = mixedArray[4] as JArray;
            Assert.IsNotNull(nestedArray);
            Assert.AreEqual(3, nestedArray.Count);
        }
    }

    /// <summary>
    /// 테스트에 사용할 샘플 열거형
    /// </summary>
    public enum UserStatus
    {
        Active,
        Inactive,
        Suspended
    }
}