// Copyright (c) Six Labors.
// Licensed under the Apache License, Version 2.0.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using SixLabors.ImageSharp.Metadata;
using SixLabors.ImageSharp.Metadata.Profiles.Exif;
using SixLabors.ImageSharp.PixelFormats;

using Xunit;

namespace SixLabors.ImageSharp.Tests.Metadata.Profiles.Exif
{
    [Trait("Profile", "Exif")]
    public class ExifProfileTests
    {
        public enum TestImageWriteFormat
        {
            /// <summary>
            /// Writes a jpg file.
            /// </summary>
            Jpeg,

            /// <summary>
            /// Writes a png file.
            /// </summary>
            Png
        }

        private static readonly Dictionary<ExifTag, object> TestProfileValues = new Dictionary<ExifTag, object>
        {
            { ExifTag.Software, "Software" },
            { ExifTag.Copyright, "Copyright" },
            { ExifTag.Orientation, (ushort)5 },
            { ExifTag.ShutterSpeedValue, new SignedRational(75.55) },
            { ExifTag.ImageDescription, "ImageDescription" },
            { ExifTag.ExposureTime, new Rational(1.0 / 1600.0) },
            { ExifTag.Model, "Model" },
        };

        [Theory]
        [InlineData(TestImageWriteFormat.Jpeg)]
        [InlineData(TestImageWriteFormat.Png)]
        public void Constructor(TestImageWriteFormat imageFormat)
        {
            Image<Rgba32> image = TestFile.Create(TestImages.Jpeg.Baseline.Calliphora).CreateRgba32Image();

            Assert.Null(image.Metadata.ExifProfile);

            const string expected = "Dirk Lemstra";
            image.Metadata.ExifProfile = new ExifProfile();
            image.Metadata.ExifProfile.SetValue(ExifTag.Copyright, expected);

            image = WriteAndRead(image, imageFormat);

            Assert.NotNull(image.Metadata.ExifProfile);
            Assert.Equal(1, image.Metadata.ExifProfile.Values.Count);

            IExifValue<string> value = image.Metadata.ExifProfile.GetValue(ExifTag.Copyright);

            Assert.NotNull(value);
            Assert.Equal(expected, value.Value);
            image.Dispose();
        }

        [Fact]
        public void ConstructorEmpty()
        {
            new ExifProfile(null);
            new ExifProfile(Array.Empty<byte>());
        }

        [Fact]
        public void ConstructorCopy()
        {
            Assert.Throws<NullReferenceException>(() => ((ExifProfile)null).DeepClone());

            ExifProfile profile = GetExifProfile();

            ExifProfile clone = profile.DeepClone();
            TestProfile(clone);

            profile.SetValue(ExifTag.ColorSpace, (ushort)2);

            clone = profile.DeepClone();
            TestProfile(clone);
        }

        [Theory]
        [InlineData(TestImageWriteFormat.Jpeg)]
        [InlineData(TestImageWriteFormat.Png)]
        public void WriteFraction(TestImageWriteFormat imageFormat)
        {
            using (var memStream = new MemoryStream())
            {
                double exposureTime = 1.0 / 1600;

                ExifProfile profile = GetExifProfile();

                profile.SetValue(ExifTag.ExposureTime, new Rational(exposureTime));

                var image = new Image<Rgba32>(1, 1);
                image.Metadata.ExifProfile = profile;

                image = WriteAndRead(image, imageFormat);

                profile = image.Metadata.ExifProfile;
                Assert.NotNull(profile);

                IExifValue<Rational> value = profile.GetValue(ExifTag.ExposureTime);
                Assert.NotNull(value);
                Assert.NotEqual(exposureTime, value.Value.ToDouble());

                memStream.Position = 0;
                profile = GetExifProfile();

                profile.SetValue(ExifTag.ExposureTime, new Rational(exposureTime, true));
                image.Metadata.ExifProfile = profile;

                image = WriteAndRead(image, imageFormat);

                profile = image.Metadata.ExifProfile;
                Assert.NotNull(profile);

                value = profile.GetValue(ExifTag.ExposureTime);
                Assert.Equal(exposureTime, value.Value.ToDouble());

                image.Dispose();
            }
        }

        [Theory]
        [InlineData(TestImageWriteFormat.Jpeg)]
        [InlineData(TestImageWriteFormat.Png)]
        public void ReadWriteInfinity(TestImageWriteFormat imageFormat)
        {
            Image<Rgba32> image = TestFile.Create(TestImages.Jpeg.Baseline.Floorplan).CreateRgba32Image();
            image.Metadata.ExifProfile.SetValue(ExifTag.ExposureBiasValue, new SignedRational(double.PositiveInfinity));

            image = WriteAndReadJpeg(image);
            IExifValue<SignedRational> value = image.Metadata.ExifProfile.GetValue(ExifTag.ExposureBiasValue);
            Assert.NotNull(value);
            Assert.Equal(new SignedRational(double.PositiveInfinity), value.Value);

            image.Metadata.ExifProfile.SetValue(ExifTag.ExposureBiasValue, new SignedRational(double.NegativeInfinity));

            image = WriteAndRead(image, imageFormat);
            value = image.Metadata.ExifProfile.GetValue(ExifTag.ExposureBiasValue);
            Assert.NotNull(value);
            Assert.Equal(new SignedRational(double.NegativeInfinity), value.Value);

            image.Metadata.ExifProfile.SetValue(ExifTag.FlashEnergy, new Rational(double.NegativeInfinity));

            image = WriteAndRead(image, imageFormat);
            IExifValue<Rational> value2 = image.Metadata.ExifProfile.GetValue(ExifTag.FlashEnergy);
            Assert.NotNull(value2);
            Assert.Equal(new Rational(double.PositiveInfinity), value2.Value);

            image.Dispose();
        }

        [Theory]
        /* The original exif profile has 19 values, the written profile should be 3 less.
         1 x due to setting of null "ReferenceBlackWhite" value.
         2 x due to use of non-standard padding tag 0xEA1C listed in EXIF Tool. We can read those values but adhere
         strictly to the 2.3.1 specification when writing. (TODO: Support 2.3.2)
         https://exiftool.org/TagNames/EXIF.html */
        [InlineData(TestImageWriteFormat.Jpeg, 16)]
        [InlineData(TestImageWriteFormat.Png, 16)]
        public void SetValue(TestImageWriteFormat imageFormat, int expectedProfileValueCount)
        {
            Image<Rgba32> image = TestFile.Create(TestImages.Jpeg.Baseline.Floorplan).CreateRgba32Image();
            image.Metadata.ExifProfile.SetValue(ExifTag.Software, "ImageSharp");

            IExifValue<string> software = image.Metadata.ExifProfile.GetValue(ExifTag.Software);
            Assert.Equal("ImageSharp", software.Value);

            // ExifString can set integer values.
            Assert.True(software.TrySetValue(15));
            Assert.False(software.TrySetValue(15F));

            image.Metadata.ExifProfile.SetValue(ExifTag.ShutterSpeedValue, new SignedRational(75.55));

            IExifValue<SignedRational> shutterSpeed = image.Metadata.ExifProfile.GetValue(ExifTag.ShutterSpeedValue);

            Assert.Equal(new SignedRational(7555, 100), shutterSpeed.Value);
            Assert.False(shutterSpeed.TrySetValue(75));

            image.Metadata.ExifProfile.SetValue(ExifTag.XResolution, new Rational(150.0));

            // We also need to change this value because this overrides XResolution when the image is written.
            image.Metadata.HorizontalResolution = 150.0;

            IExifValue<Rational> xResolution = image.Metadata.ExifProfile.GetValue(ExifTag.XResolution);
            Assert.Equal(new Rational(150, 1), xResolution.Value);

            Assert.False(xResolution.TrySetValue("ImageSharp"));

            image.Metadata.ExifProfile.SetValue(ExifTag.ReferenceBlackWhite, null);

            IExifValue<Rational[]> referenceBlackWhite = image.Metadata.ExifProfile.GetValue(ExifTag.ReferenceBlackWhite);
            Assert.Null(referenceBlackWhite.Value);

            var expectedLatitude = new Rational[] { new Rational(12.3), new Rational(4.56), new Rational(789.0) };
            image.Metadata.ExifProfile.SetValue(ExifTag.GPSLatitude, expectedLatitude);

            IExifValue<Rational[]> latitude = image.Metadata.ExifProfile.GetValue(ExifTag.GPSLatitude);
            Assert.Equal(expectedLatitude, latitude.Value);

            // todo: duplicate tags
            Assert.Equal(2, image.Metadata.ExifProfile.Values.Count(v => (ushort)v.Tag == 59932));

            image = WriteAndRead(image, imageFormat);

            Assert.NotNull(image.Metadata.ExifProfile);
            Assert.Equal(0, image.Metadata.ExifProfile.Values.Count(v => (ushort)v.Tag == 59932));

            Assert.Equal(expectedProfileValueCount, image.Metadata.ExifProfile.Values.Count);

            software = image.Metadata.ExifProfile.GetValue(ExifTag.Software);
            Assert.Equal("15", software.Value);

            shutterSpeed = image.Metadata.ExifProfile.GetValue(ExifTag.ShutterSpeedValue);
            Assert.Equal(new SignedRational(75.55), shutterSpeed.Value);

            xResolution = image.Metadata.ExifProfile.GetValue(ExifTag.XResolution);
            Assert.Equal(new Rational(150.0), xResolution.Value);

            referenceBlackWhite = image.Metadata.ExifProfile.GetValue(ExifTag.ReferenceBlackWhite);
            Assert.Null(referenceBlackWhite);

            latitude = image.Metadata.ExifProfile.GetValue(ExifTag.GPSLatitude);
            Assert.Equal(expectedLatitude, latitude.Value);

            image.Dispose();
        }

        [Theory]
        [InlineData(TestImageWriteFormat.Jpeg)]
        [InlineData(TestImageWriteFormat.Png)]
        public void WriteOnlyExifTags_Works(TestImageWriteFormat imageFormat)
        {
            // Arrange
            Image<Rgba32> image = TestFile.Create(TestImages.Jpeg.Baseline.Floorplan).CreateRgba32Image();
            image.Metadata.ExifProfile.Parts = ExifParts.ExifTags;

            // Act
            image = WriteAndRead(image, imageFormat);

            // Assert
            Assert.NotNull(image.Metadata.ExifProfile);
            Assert.Equal(7, image.Metadata.ExifProfile.Values.Count);
            foreach (IExifValue exifProfileValue in image.Metadata.ExifProfile.Values)
            {
                Assert.True(ExifTags.GetPart(exifProfileValue.Tag) == ExifParts.ExifTags);
            }

            image.Dispose();
        }

        [Fact]
        public void RemoveEntry_Works()
        {
            // Arrange
            using Image<Rgba32> image = TestFile.Create(TestImages.Jpeg.Baseline.Floorplan).CreateRgba32Image();
            int profileCount = image.Metadata.ExifProfile.Values.Count;

            // Assert
            Assert.NotNull(image.Metadata.ExifProfile.GetValue(ExifTag.ColorSpace));
            Assert.True(image.Metadata.ExifProfile.RemoveValue(ExifTag.ColorSpace));
            Assert.False(image.Metadata.ExifProfile.RemoveValue(ExifTag.ColorSpace));
            Assert.Null(image.Metadata.ExifProfile.GetValue(ExifTag.ColorSpace));
            Assert.Equal(profileCount - 1, image.Metadata.ExifProfile.Values.Count);
        }

        [Fact]
        public void Syncs()
        {
            var exifProfile = new ExifProfile();
            exifProfile.SetValue(ExifTag.XResolution, new Rational(200));
            exifProfile.SetValue(ExifTag.YResolution, new Rational(300));

            var metaData = new ImageMetadata
            {
                ExifProfile = exifProfile,
                HorizontalResolution = 200,
                VerticalResolution = 300
            };

            metaData.HorizontalResolution = 100;

            Assert.Equal(200, metaData.ExifProfile.GetValue(ExifTag.XResolution).Value.ToDouble());
            Assert.Equal(300, metaData.ExifProfile.GetValue(ExifTag.YResolution).Value.ToDouble());

            exifProfile.Sync(metaData);

            Assert.Equal(100, metaData.ExifProfile.GetValue(ExifTag.XResolution).Value.ToDouble());
            Assert.Equal(300, metaData.ExifProfile.GetValue(ExifTag.YResolution).Value.ToDouble());

            metaData.VerticalResolution = 150;

            Assert.Equal(100, metaData.ExifProfile.GetValue(ExifTag.XResolution).Value.ToDouble());
            Assert.Equal(300, metaData.ExifProfile.GetValue(ExifTag.YResolution).Value.ToDouble());

            exifProfile.Sync(metaData);

            Assert.Equal(100, metaData.ExifProfile.GetValue(ExifTag.XResolution).Value.ToDouble());
            Assert.Equal(150, metaData.ExifProfile.GetValue(ExifTag.YResolution).Value.ToDouble());
        }

        [Fact]
        public void Values()
        {
            ExifProfile profile = GetExifProfile();

            TestProfile(profile);

            using Image<Rgba32> thumbnail = profile.CreateThumbnail<Rgba32>();
            Assert.NotNull(thumbnail);
            Assert.Equal(256, thumbnail.Width);
            Assert.Equal(170, thumbnail.Height);
        }

        [Fact]
        public void ReadWriteLargeProfileJpg()
        {
            ExifTag<string>[] tags = new[] { ExifTag.Software, ExifTag.Copyright, ExifTag.Model, ExifTag.ImageDescription };
            foreach (ExifTag<string> tag in tags)
            {
                // Arrange
                var junk = new StringBuilder();
                for (int i = 0; i < 65600; i++)
                {
                    junk.Append('a');
                }

                var image = new Image<Rgba32>(100, 100);
                ExifProfile expectedProfile = CreateExifProfile();
                var expectedProfileTags = expectedProfile.Values.Select(x => x.Tag).ToList();
                expectedProfile.SetValue(tag, junk.ToString());
                image.Metadata.ExifProfile = expectedProfile;

                // Act
                using Image<Rgba32> reloadedImage = WriteAndRead(image, TestImageWriteFormat.Jpeg);

                // Assert
                ExifProfile actualProfile = reloadedImage.Metadata.ExifProfile;
                Assert.NotNull(actualProfile);

                foreach (ExifTag expectedProfileTag in expectedProfileTags)
                {
                    IExifValue actualProfileValue = actualProfile.GetValueInternal(expectedProfileTag);
                    IExifValue expectedProfileValue = expectedProfile.GetValueInternal(expectedProfileTag);
                    Assert.Equal(expectedProfileValue.GetValue(), actualProfileValue.GetValue());
                }

                IExifValue<string> expected = expectedProfile.GetValue(tag);
                IExifValue<string> actual = actualProfile.GetValue(tag);
                Assert.Equal(expected, actual);
            }
        }

        [Fact]
        public void ExifTypeUndefined()
        {
            // This image contains an 802 byte EXIF profile
            // It has a tag with an index offset of 18,481,152 bytes (overrunning the data)
            using Image<Rgba32> image = TestFile.Create(TestImages.Jpeg.Progressive.Bad.ExifUndefType).CreateRgba32Image();
            Assert.NotNull(image);

            ExifProfile profile = image.Metadata.ExifProfile;
            Assert.NotNull(profile);

            foreach (ExifValue value in profile.Values)
            {
                if (value.DataType == ExifDataType.Undefined)
                {
                    Assert.True(value.IsArray);
                    Assert.Equal(4U, 4 * ExifDataTypes.GetSize(value.DataType));
                }
            }
        }

        [Fact]
        public void TestArrayValueWithUnspecifiedSize()
        {
            // This images contains array in the exif profile that has zero components.
            using Image<Rgba32> image = TestFile.Create(TestImages.Jpeg.Issues.InvalidCast520).CreateRgba32Image();

            ExifProfile profile = image.Metadata.ExifProfile;
            Assert.NotNull(profile);

            // Force parsing of the profile.
            Assert.Equal(25, profile.Values.Count);

            // todo: duplicate tags (from root container and subIfd)
            Assert.Equal(2, profile.Values.Count(v => (ExifTagValue)(ushort)v.Tag == ExifTagValue.DateTime));

            byte[] bytes = profile.ToByteArray();
            Assert.Equal(525, bytes.Length);

            var profile2 = new ExifProfile(bytes);
            Assert.Equal(25, profile2.Values.Count);
        }

        [Theory]
        [InlineData(TestImageWriteFormat.Jpeg)]
        [InlineData(TestImageWriteFormat.Png)]
        public void WritingImagePreservesExifProfile(TestImageWriteFormat imageFormat)
        {
            // Arrange
            var image = new Image<Rgba32>(1, 1);
            image.Metadata.ExifProfile = CreateExifProfile();

            // Act
            using Image<Rgba32> reloadedImage = WriteAndRead(image, imageFormat);

            // Assert
            ExifProfile actual = reloadedImage.Metadata.ExifProfile;
            Assert.NotNull(actual);
            foreach (KeyValuePair<ExifTag, object> expectedProfileValue in TestProfileValues)
            {
                IExifValue actualProfileValue = actual.GetValueInternal(expectedProfileValue.Key);
                Assert.NotNull(actualProfileValue);
                Assert.Equal(expectedProfileValue.Value, actualProfileValue.GetValue());
            }
        }

        [Fact]
        public void ProfileToByteArray()
        {
            // Arrange
            byte[] exifBytesWithoutExifCode = ExifConstants.LittleEndianByteOrderMarker.ToArray();
            ExifProfile expectedProfile = CreateExifProfile();
            var expectedProfileTags = expectedProfile.Values.Select(x => x.Tag).ToList();

            // Act
            byte[] actualBytes = expectedProfile.ToByteArray();
            var actualProfile = new ExifProfile(actualBytes);

            // Assert
            Assert.NotNull(actualBytes);
            Assert.NotEmpty(actualBytes);
            Assert.Equal(exifBytesWithoutExifCode, actualBytes.Take(exifBytesWithoutExifCode.Length).ToArray());
            foreach (ExifTag expectedProfileTag in expectedProfileTags)
            {
                IExifValue actualProfileValue = actualProfile.GetValueInternal(expectedProfileTag);
                IExifValue expectedProfileValue = expectedProfile.GetValueInternal(expectedProfileTag);
                Assert.Equal(expectedProfileValue.GetValue(), actualProfileValue.GetValue());
            }
        }

        private static ExifProfile CreateExifProfile()
        {
            var profile = new ExifProfile();

            foreach (KeyValuePair<ExifTag, object> exifProfileValue in TestProfileValues)
            {
                profile.SetValueInternal(exifProfileValue.Key, exifProfileValue.Value);
            }

            return profile;
        }

        internal static ExifProfile GetExifProfile()
        {
            using Image<Rgba32> image = TestFile.Create(TestImages.Jpeg.Baseline.Floorplan).CreateRgba32Image();

            ExifProfile profile = image.Metadata.ExifProfile;
            Assert.NotNull(profile);

            return profile;
        }

        private static Image<Rgba32> WriteAndRead(Image<Rgba32> image, TestImageWriteFormat imageFormat)
        {
            switch (imageFormat)
            {
                case TestImageWriteFormat.Jpeg:
                    return WriteAndReadJpeg(image);
                case TestImageWriteFormat.Png:
                    return WriteAndReadPng(image);
                default:
                    throw new ArgumentException("Unexpected test image format, only Jpeg and Png are allowed");
            }
        }

        private static Image<Rgba32> WriteAndReadJpeg(Image<Rgba32> image)
        {
            using (var memStream = new MemoryStream())
            {
                image.SaveAsJpeg(memStream);
                image.Dispose();

                memStream.Position = 0;
                return Image.Load<Rgba32>(memStream);
            }
        }

        private static Image<Rgba32> WriteAndReadPng(Image<Rgba32> image)
        {
            using (var memStream = new MemoryStream())
            {
                image.SaveAsPng(memStream);
                image.Dispose();

                memStream.Position = 0;
                return Image.Load<Rgba32>(memStream);
            }
        }

        private static void TestProfile(ExifProfile profile)
        {
            Assert.NotNull(profile);

            // todo: duplicate tags
            Assert.Equal(2, profile.Values.Count(v => (ushort)v.Tag == 59932));

            Assert.Equal(16, profile.Values.Count);

            foreach (IExifValue value in profile.Values)
            {
                Assert.NotNull(value.GetValue());
            }

            IExifValue<string> software = profile.GetValue(ExifTag.Software);
            Assert.Equal("Windows Photo Editor 10.0.10011.16384", software.Value);

            IExifValue<Rational> xResolution = profile.GetValue(ExifTag.XResolution);
            Assert.Equal(new Rational(300.0), xResolution.Value);

            IExifValue<Number> xDimension = profile.GetValue(ExifTag.PixelXDimension);
            Assert.Equal(2338U, xDimension.Value);
        }
    }
}