using System;
using System.Collections.Generic;
using System.Reflection;
using Blacklight.Core;

namespace Glass.Blacklight.UnitTests
{
    public class SpriteSheetRendererTests : UnitTestSharp.TestFixture
    {
        public const string EmbeddedSheet = "Glass.Blacklight.UnitTests.SampleSheet.png";

        [SpriteSheet(spriteSizeX: 8, spriteSizeY: 4, borderSize: 2, EmbeddedSheet)]
        public class SheetHolder
        {
        }

        public static SpriteSheetAttribute Attribute()
        {
            return typeof(SheetHolder).GetCustomAttribute<SpriteSheetAttribute>();
        }

        /// <summary>
        /// BlacklightRenderer keys its registry by the attribute, and reflection hands out a fresh instance per
        /// call, so registering and looking one up only ever meet through Attribute's field-value equality.
        /// </summary>
        public class RegistryKeyingTests : UnitTestSharp.TestFixture
        {
            public void TwoLookupsOfOneDeclaration_AreDistinctInstances()
            {
                CheckFalse(ReferenceEquals(Attribute(), Attribute()));
            }

            public void ARegisteredAttribute_IsFoundByAFreshOne()
            {
                var registry = new Dictionary<SpriteSheetAttribute, string>();
                registry.Add(Attribute(), "renderer");

                CheckTrue(registry.ContainsKey(Attribute()));
            }
        }

        public class LoadSpriteSheetTests : UnitTestSharp.TestFixture
        {
            public void FromTheLibraryHoldingTheArt_LoadsIt()
            {
                SpriteSheet sheet = SpriteSheetRenderer.LoadSpriteSheet(
                    Attribute(), typeof(SheetHolder), new NullWindowHandle());

                CheckNotNull(sheet);
            }

            public void FromTheLibraryHoldingTheArt_CarriesTheAttributesMetrics()
            {
                SpriteSheet sheet = SpriteSheetRenderer.LoadSpriteSheet(
                    Attribute(), typeof(SheetHolder), new NullWindowHandle());

                CheckEqual(new System.Drawing.Size(8, 4), sheet.SpriteSize);
                CheckEqual(2, sheet.BorderSize);
            }

            public void FromALibraryWithoutTheArt_IsNull()
            {
                SpriteSheet sheet = SpriteSheetRenderer.LoadSpriteSheet(
                    Attribute(), typeof(SpriteSheetAttribute), new NullWindowHandle());

                CheckNull(sheet);
            }
        }

        public class SpriteSheetBuilderTests : UnitTestSharp.TestFixture
        {
            public void LooksForTheArtBesideTheTypeDeclaringIt()
            {
                SpriteSheetRenderer renderer = SpriteSheetRenderer.SpriteSheetBuilder(
                    typeof(SheetHolder), new NullWindowHandle(), Attribute());

                CheckNotNull(renderer.SpriteSheet);
            }

            public void ATypeFromAnAssemblyWithoutTheArt_Throws()
            {
                CheckThrow(typeof(System.ArgumentException));
                SpriteSheetRenderer.SpriteSheetBuilder(
                    typeof(SpriteSheetAttribute), new NullWindowHandle(), Attribute());
            }
        }
    }
}