using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using NUnit.Framework;
using UnityEditorInternal;
using UnityEngine;
using UnityEngine.TestTools;
using UnityEngine.Tilemaps;
using Object = UnityEngine.Object;

namespace UnityEditor.Tilemaps.Tests
{
    internal class PaletteTest
    {
        const float paletteHeaderHeight = 24f;
        const string defaultPalettePath = "Packages/com.unity.2d.tilemap/Tests/Palettes/Default.prefab";
        const string defaultTemporaryPalettePath = "Assets/Temp/Default.prefab";
        const string path = "Assets";
        const string path2 = "Assets";
        const string name = "Palette1";
        const string name2 = "Palette2";
        const string temporaryPalettePath = "Assets/Temp/TempPalette.prefab";
        const string temporaryAssetPath = "Assets/Temp/MyBrushGenerated.asset";
        const string temporaryTilePath = "Assets/Temp/temp_tile.asset";
        const string tilePath = "Packages/com.unity.2d.tilemap/Tests/Tiles/blue_spritesheet_0.asset";
        const string bigTilePath = "Packages/com.unity.2d.tilemap/Tests/Tiles/big_blue_spritesheet_0.asset";
        const string emptyColumnRowTexturePath = "Packages/com.unity.2d.tilemap/Tests/Sprites/1103034.png";
        const string square0000TexturePath = "Packages/com.unity.2d.tilemap/Tests/Sprites/Square0000.png";
        const string square1111TexturePath = "Packages/com.unity.2d.tilemap/Tests/Sprites/Square1111.png";
        const string square1222TexturePath = "Packages/com.unity.2d.tilemap/Tests/Sprites/Square1222.png";

        // MyBrush validates game object name with the exact invalid name
        const string validMyBrushTargetName = MyBrushEditor.invalidName + "IsActuallyValidNow";
        const string invalidMyBrushTargetName = MyBrushEditor.invalidName;

        private GridPaintPaletteWindow m_Window;

        [SetUp]
        public void SetUp()
        {
            AssetDatabase.CreateFolder("Assets", "Temp");

            AssetDatabase.CopyAsset(defaultPalettePath, defaultTemporaryPalettePath);
            AssetDatabase.Refresh();

            var gridPalette = AssetDatabase.LoadAssetAtPath(defaultTemporaryPalettePath, typeof(GridPalette));
            if (gridPalette == null)
            {
                GridPalette palette = GridPalette.CreateInstance<GridPalette>();
                palette.name = "Palette Settings";
                palette.cellSizing = GridPalette.CellSizing.Automatic;
                AssetDatabase.AddObjectToAsset(palette, defaultTemporaryPalettePath);
                AssetDatabase.ForceReserializeAssets(new string[] {defaultTemporaryPalettePath});
            }

            AssetDatabase.Refresh();

            SessionState.EraseInt(GridPaletteBrushes.s_SessionStateLastUsedBrush);
            GridPaintingState.gridBrush = GridPaletteBrushes.brushes[0];
        }

        [TearDown]
        public void TearDown()
        {
            SessionState.EraseInt(GridPaletteBrushes.s_SessionStateLastUsedBrush);
            GridPaintingState.gridBrush = GridPaletteBrushes.brushes[0];

            GridPaintActiveTargetsPreferences.restoreEditModeSelection = true;

            if (AssetDatabase.GetAllAssetPaths().Contains(path + "/" + name + ".prefab"))
            {
                AssetDatabase.DeleteAsset(path + "/" + name + ".prefab");
            }

            if (AssetDatabase.GetAllAssetPaths().Contains(path2 + "/" + name2 + ".prefab"))
            {
                AssetDatabase.DeleteAsset(path2 + "/" + name2 + ".prefab");
            }

            if (AssetDatabase.LoadAllAssetsAtPath(defaultTemporaryPalettePath).Length > 0)
            {
                AssetDatabase.DeleteAsset(defaultTemporaryPalettePath);
            }

            if (AssetDatabase.LoadAllAssetsAtPath(temporaryPalettePath).Length > 0)
            {
                AssetDatabase.DeleteAsset(temporaryPalettePath);
            }

            if (AssetDatabase.LoadAllAssetsAtPath(temporaryAssetPath).Length > 0)
            {
                AssetDatabase.DeleteAsset(temporaryAssetPath);
            }

            if (AssetDatabase.LoadAllAssetsAtPath(temporaryTilePath).Length > 0)
            {
                AssetDatabase.DeleteAsset(temporaryTilePath);
            }

            if (AssetDatabase.IsValidFolder("Assets/Temp"))
            {
                FileUtil.DeleteFileOrDirectory("Assets/Temp");
                FileUtil.DeleteFileOrDirectory("Assets/Temp.meta");
                AssetDatabase.Refresh();
            }

            GridPaletteBrushes.FlushCache();
            GridPalettes.CleanCache();

            if (m_Window != null)
            {
                m_Window.Close();
                m_Window = null;
            }
        }

        private GameObject CreateTilemapGameObjectWithName(string name)
        {
            var gameObject = new GameObject();
            gameObject.name = name;
            gameObject.AddComponent<Grid>();
            gameObject.AddComponent<Tilemap>();
            return gameObject;
        }

        private GridPaintPaletteWindow CreatePaletteWindow()
        {
            var w = EditorWindow.GetWindow<GridPaintPaletteWindow>();
            w.position = new Rect(40f, 10f, 400f, 300f);
            m_Window = w;
            return w;
        }

        [Test]
        public void CreatePaletteWindow_ReturnsValidPaletteWindow()
        {
            var w = CreatePaletteWindow();
            Assert.NotNull(w);
        }

        [Test]
        public void CreatePaletteWindow_DefaultActiveBrushIsGridBrush()
        {
            CreatePaletteWindow();
            Assert.NotNull(GridPaintingState.gridBrush);
            Assert.AreEqual(typeof(GridBrush), GridPaintingState.gridBrush.GetType());
        }

        [Test]
        public void CreatePaletteWindow_CanLoadDefaultPalette()
        {
            var w = CreatePaletteWindow();
            var defaultPalette = AssetDatabase.LoadAssetAtPath<GameObject>(defaultTemporaryPalettePath);
            Assert.NotNull(w.palette);
            Assert.AreEqual(defaultPalette, w.palette);
        }

        [Test]
        [TestCase(Grid.CellLayout.Rectangle, GridLayout.CellSwizzle.XYZ)]
        [TestCase(Grid.CellLayout.Hexagon, GridLayout.CellSwizzle.XYZ)]
        [TestCase(Grid.CellLayout.Hexagon, GridLayout.CellSwizzle.YXZ)]
        public void CreatePalette_ReturnsValidPalettesWithGridAndChildTilemap(Grid.CellLayout layout,
            GridLayout.CellSwizzle swizzle)
        {
            int paletteCount = GridPalettes.palettes.Count;

            GameObject palette1 = GridPaletteUtility.CreateNewPalette(path, name, layout,
                GridPalette.CellSizing.Automatic, Vector3.one, swizzle);
            GameObject palette2 = GridPaletteUtility.CreateNewPalette(path2, name2, layout,
                GridPalette.CellSizing.Automatic, Vector3.one, swizzle);

            GridPalettes.CleanCache();
            Assert.AreEqual(paletteCount + 2, GridPalettes.palettes.Count);

            Assert.NotNull(palette1.GetComponent<Grid>());
            Assert.NotNull(palette1.GetComponentInChildren<Tilemap>());
            Assert.NotNull(palette2.GetComponent<Grid>());
            Assert.NotNull(palette2.GetComponentInChildren<Tilemap>());
        }

        [Test]
        public void ChangeActiveGridBrush_DoesNotChangeActivePaintTargetIfStillValid()
        {
            var invalidGO = CreateTilemapGameObjectWithName(invalidMyBrushTargetName);
            var validGO = CreateTilemapGameObjectWithName(validMyBrushTargetName);

            CreatePaletteWindow();
            GridPaintingState.scenePaintTarget = validGO;
            Assert.AreEqual(validGO, GridPaintingState.scenePaintTarget);

            Assert.IsTrue(GridPaletteBrushes.brushes[2] is MyBrush);
            GridPaintingState.gridBrush = GridPaletteBrushes.brushes[2];
            Assert.AreEqual(GridPaletteBrushes.brushes[2], GridPaintingState.gridBrush);
            Assert.AreEqual(validGO, GridPaintingState.scenePaintTarget);

            Object.DestroyImmediate(invalidGO);
            Object.DestroyImmediate(validGO);
        }

        [Test]
        public void ChangeActiveGridBrush_ChangesActivePaintTargetIfNotValid()
        {
            var invalidGO = CreateTilemapGameObjectWithName(invalidMyBrushTargetName);
            var validGO = CreateTilemapGameObjectWithName(validMyBrushTargetName);

            CreatePaletteWindow();
            GridPaintingState.scenePaintTarget = invalidGO;
            Assert.AreEqual(invalidGO, GridPaintingState.scenePaintTarget);

            Assert.IsTrue(GridPaletteBrushes.brushes[2] is MyBrush);
            GridPaintingState.gridBrush = GridPaletteBrushes.brushes[2];
            Assert.AreEqual(GridPaletteBrushes.brushes[2], GridPaintingState.gridBrush);
            Assert.AreEqual(validGO, GridPaintingState.scenePaintTarget);

            Object.DestroyImmediate(invalidGO);
            Object.DestroyImmediate(validGO);
        }

        [Test]
        public void PickFromPalette_DefaultGridBrushSelectsWithCorrectSize()
        {
            var w = CreatePaletteWindow();
            w.palette = AssetDatabase.LoadAssetAtPath<GameObject>(defaultTemporaryPalettePath);
            Event ev = new Event();

            Vector2 startDrag = new Vector2(w.clipboardView.guiRect.width * 0.25f,
                w.clipboardView.guiRect.height * 0.25f);
            Vector2 endDrag = new Vector2(w.clipboardView.guiRect.width * 0.75f,
                w.clipboardView.guiRect.height * 0.75f);

            Grid grid = w.clipboardView.paletteInstance.GetComponent<Grid>();
            Vector3Int startCell = grid.LocalToCell(w.clipboardView.ScreenToLocal(startDrag));
            Vector3Int endCell = grid.LocalToCell(w.clipboardView.ScreenToLocal(endDrag));
            Vector3Int size = new Vector3Int(endCell.x - startCell.x + 1, startCell.y - endCell.y + 1, 1);

            startDrag += new Vector2(0f, paletteHeaderHeight);
            endDrag += new Vector2(0f, paletteHeaderHeight);

            ev.mousePosition = startDrag;
            ev.type = EventType.MouseMove;
            w.SendEvent(ev);
            ev.type = EventType.MouseDown;
            w.SendEvent(ev);
            ev.type = EventType.MouseDrag;
            w.SendEvent(ev);
            ev.type = EventType.MouseDrag;
            ev.mousePosition = endDrag;
            w.SendEvent(ev);
            ev.type = EventType.MouseUp;
            w.SendEvent(ev);

            Assert.NotNull(GridPaintingState.defaultBrush);
            Assert.AreEqual(size, GridPaintingState.defaultBrush.size);
        }

        [Test]
        public void PickAndDragOutsidePalette_CancelsPickAction()
        {
            var w = CreatePaletteWindow();
            w.palette = AssetDatabase.LoadAssetAtPath<GameObject>(defaultTemporaryPalettePath);
            Event ev = new Event();
            Assert.GreaterOrEqual(GridPaletteBrushes.brushes.Count, 1);
            GridPaintingState.defaultBrush.Init(new Vector3Int(1, 1, 1));
            GridPaintingState.defaultBrush.SetTile(Vector3Int.zero, null);

            Vector2 startDrag = new Vector2(w.clipboardView.guiRect.width * 0.25f,
                w.clipboardView.guiRect.height * 0.25f);
            Vector2 endDrag = new Vector2(w.clipboardView.guiRect.width * 0.75f,
                w.clipboardView.guiRect.height * 0.75f);

            Grid grid = w.clipboardView.paletteInstance.GetComponent<Grid>();
            Vector3Int startCell = grid.LocalToCell(w.clipboardView.ScreenToLocal(startDrag));
            Vector3Int endCell = grid.LocalToCell(w.clipboardView.ScreenToLocal(endDrag));
            Vector3Int size = new Vector3Int(endCell.x - startCell.x + 1, startCell.y - endCell.y + 1, 1);

            startDrag += new Vector2(0f, paletteHeaderHeight);
            endDrag += new Vector2(0f, paletteHeaderHeight);

            ev.mousePosition = startDrag;
            ev.type = EventType.MouseMove;
            w.SendEvent(ev);
            ev.type = EventType.MouseDown;
            w.SendEvent(ev);
            ev.type = EventType.MouseDrag;
            w.SendEvent(ev);
            ev.type = EventType.MouseDrag;
            ev.mousePosition =
                new Vector2(-10, -10); // MousePosition is relative to window, negative values are outside of window
            w.SendEvent(ev);
            ev.type = EventType.MouseUp;
            w.SendEvent(ev);

            Assert.AreNotEqual(size, GridPaintingState.defaultBrush.size);
            Assert.IsNull(GridPaintingState.defaultBrush.cells[0].tile);
        }

        [Test]
        public void PickAndDragOutsideAndBackInsideOfPalette_DoesPickAction()
        {
            var w = CreatePaletteWindow();
            w.palette = AssetDatabase.LoadAssetAtPath<GameObject>(defaultTemporaryPalettePath);
            Event ev = new Event();
            Assert.GreaterOrEqual(GridPaletteBrushes.brushes.Count, 1);
            GridPaintingState.defaultBrush.Init(new Vector3Int(1, 1, 1));
            GridPaintingState.defaultBrush.SetTile(Vector3Int.zero, null);

            Vector2 startDrag = new Vector2(w.clipboardView.guiRect.width * 0.25f,
                w.clipboardView.guiRect.height * 0.25f);
            Vector2 endDrag = new Vector2(w.clipboardView.guiRect.width * 0.75f,
                w.clipboardView.guiRect.height * 0.75f);

            Grid grid = w.clipboardView.paletteInstance.GetComponent<Grid>();
            Vector3Int startCell = grid.LocalToCell(w.clipboardView.ScreenToLocal(startDrag));
            Vector3Int endCell = grid.LocalToCell(w.clipboardView.ScreenToLocal(endDrag));
            Vector3Int size = new Vector3Int(endCell.x - startCell.x + 1, startCell.y - endCell.y + 1, 1);

            startDrag += new Vector2(0f, paletteHeaderHeight);
            endDrag += new Vector2(0f, paletteHeaderHeight);

            ev.mousePosition = startDrag;
            ev.type = EventType.MouseMove;
            w.SendEvent(ev);
            ev.type = EventType.MouseDown;
            w.SendEvent(ev);
            ev.type = EventType.MouseDrag;
            w.SendEvent(ev);
            ev.type = EventType.MouseDrag;
            ev.mousePosition =
                new Vector2(-10, -10); // MousePosition is relative to window, negative values are outside of window
            w.SendEvent(ev);
            ev.type = EventType.MouseDrag;
            ev.mousePosition = endDrag;
            w.SendEvent(ev);
            ev.type = EventType.MouseUp;
            w.SendEvent(ev);

            Assert.AreEqual(size, GridPaintingState.defaultBrush.size);
        }

        [Test]
        public void PaintAndEraseOnPalette_SetsAndRemovesTileFromPalette()
        {
            var w = CreatePaletteWindow();
            Assert.True(AssetDatabase.CopyAsset(defaultTemporaryPalettePath, temporaryPalettePath),
                "Unable to create temporary palette");
            w.palette = AssetDatabase.LoadAssetAtPath<GameObject>(temporaryPalettePath);
            var tile = AssetDatabase.LoadAssetAtPath<Tile>(tilePath);

            Assert.GreaterOrEqual(GridPaletteBrushes.brushes.Count, 1);
            GridPaintingState.defaultBrush.Init(new Vector3Int(1, 1, 1));
            GridPaintingState.defaultBrush.SetTile(Vector3Int.zero, tile);
            w.clipboardView.unlocked = true;
            TilemapEditorTool.SetActiveEditorTool(typeof(PaintTool));

            Event ev = new Event();
            ev.mousePosition = w.clipboardView.GridToScreen(new Vector2(2.5f, -2.5f)) +
                new Vector2(0, paletteHeaderHeight);
            ev.type = EventType.MouseMove;
            w.SendEvent(ev);
            ev.type = EventType.MouseDown;
            w.SendEvent(ev);
            ev.type = EventType.MouseUp;
            w.SendEvent(ev);
            w.clipboardView.unlocked = false;

            Grid grid = w.clipboardView.paletteInstance.GetComponent<Grid>();
            Vector3 local = w.clipboardView.ScreenToLocal(ev.mousePosition - new Vector2(0, paletteHeaderHeight));
            Vector3Int pos3 = grid.LocalToCell(local);
            Vector2Int pos = new Vector2Int(pos3.x, pos3.y);
            Tilemap tilemap = AssetDatabase.LoadAssetAtPath<GameObject>(temporaryPalettePath)
                .GetComponentInChildren<Tilemap>();
            Assert.AreEqual(tile, tilemap.GetTile(new Vector3Int(pos.x, pos.y, 0)));

            w.clipboardView.unlocked = true;
            ev.shift = true;
            ev.mousePosition = w.clipboardView.GridToScreen(new Vector2(2.5f, -2.5f)) +
                new Vector2(0, paletteHeaderHeight);
            ev.type = EventType.MouseMove;
            w.SendEvent(ev);
            ev.type = EventType.MouseDown;
            w.SendEvent(ev);
            ev.type = EventType.MouseUp;
            w.SendEvent(ev);
            w.clipboardView.unlocked = false;

            tilemap = AssetDatabase.LoadAssetAtPath<GameObject>(temporaryPalettePath).GetComponentInChildren<Tilemap>();
            Assert.AreEqual(null, tilemap.GetTile(new Vector3Int(pos.x, pos.y, 0)));
        }

        [Test]
        public void EraseOnUneditablePalette_SwitchesToPaint()
        {
            var w = CreatePaletteWindow();
            Assert.True(AssetDatabase.CopyAsset(defaultTemporaryPalettePath, temporaryPalettePath),
                "Unable to create temporary palette");
            w.palette = AssetDatabase.LoadAssetAtPath<GameObject>(temporaryPalettePath);
            var tile = AssetDatabase.LoadAssetAtPath<Tile>(tilePath);

            Assert.GreaterOrEqual(GridPaletteBrushes.brushes.Count, 1);
            GridPaintingState.defaultBrush.Init(new Vector3Int(1, 1, 1));
            GridPaintingState.defaultBrush.SetTile(Vector3Int.zero, tile);
            TilemapEditorTool.SetActiveEditorTool(typeof(EraseTool));
            w.clipboardView.unlocked = false;

            Event ev = new Event();
            ev.mousePosition = w.clipboardView.GridToScreen(new Vector2(2.5f, -2.5f)) +
                new Vector2(0, paletteHeaderHeight);
            ev.type = EventType.MouseMove;
            w.SendEvent(ev);
            ev.type = EventType.MouseDown;
            w.SendEvent(ev);
            ev.type = EventType.MouseUp;
            w.SendEvent(ev);

            Assert.AreEqual(typeof(PaintTool), EditorTools.EditorTools.activeToolType);
        }

        [Test]
        public void PaintOnPalette_EraseAndCreateNewTileAsset_RemovesTileFromPalette()
        {
            var w = CreatePaletteWindow();
            Assert.True(AssetDatabase.CopyAsset(defaultTemporaryPalettePath, temporaryPalettePath),
                "Unable to create temporary palette");
            w.palette = AssetDatabase.LoadAssetAtPath<GameObject>(temporaryPalettePath);
            var tile = AssetDatabase.LoadAssetAtPath<Tile>(tilePath);

            Assert.GreaterOrEqual(GridPaletteBrushes.brushes.Count, 1);
            GridPaintingState.defaultBrush.Init(new Vector3Int(1, 1, 1));
            GridPaintingState.defaultBrush.SetTile(Vector3Int.zero, tile);
            w.clipboardView.unlocked = true;
            TilemapEditorTool.SetActiveEditorTool(typeof(PaintTool));

            Event ev = new Event();
            ev.mousePosition = w.clipboardView.GridToScreen(new Vector2(2.5f, -2.5f)) +
                new Vector2(0, paletteHeaderHeight);
            ev.type = EventType.MouseMove;
            w.SendEvent(ev);
            ev.type = EventType.MouseDown;
            w.SendEvent(ev);
            ev.type = EventType.MouseUp;
            w.SendEvent(ev);
            w.clipboardView.unlocked = false;

            Grid grid = w.clipboardView.paletteInstance.GetComponent<Grid>();
            Vector3 local = w.clipboardView.ScreenToLocal(ev.mousePosition - new Vector2(0, paletteHeaderHeight));
            Vector3Int pos3 = grid.LocalToCell(local);
            Vector2Int pos = new Vector2Int(pos3.x, pos3.y);
            Tilemap tilemap = AssetDatabase.LoadAssetAtPath<GameObject>(temporaryPalettePath)
                .GetComponentInChildren<Tilemap>();
            Assert.AreEqual(tile, tilemap.GetTile(new Vector3Int(pos.x, pos.y, 0)));

            w.clipboardView.unlocked = true;
            ev.shift = true;
            ev.mousePosition = w.clipboardView.GridToScreen(new Vector2(2.5f, -2.5f)) +
                new Vector2(0, paletteHeaderHeight);
            ev.type = EventType.MouseMove;
            w.SendEvent(ev);
            ev.type = EventType.MouseDown;
            w.SendEvent(ev);
            ev.type = EventType.MouseUp;
            w.SendEvent(ev);

            var temporaryTile = ScriptableObject.CreateInstance<Tile>();
            AssetDatabase.CreateAsset(temporaryTile, temporaryTilePath);

            tilemap = AssetDatabase.LoadAssetAtPath<GameObject>(temporaryPalettePath).GetComponentInChildren<Tilemap>();
            Assert.AreEqual(null, tilemap.GetTile(new Vector3Int(pos.x, pos.y, 0)));
        }

        [Test]
        [TestCase(Grid.CellLayout.Rectangle, GridLayout.CellSwizzle.XYZ, 3, -3, 2, 2)]
        [TestCase(Grid.CellLayout.Hexagon, GridLayout.CellSwizzle.XYZ, 3, -3, 2, 2)]
        [TestCase(Grid.CellLayout.Hexagon, GridLayout.CellSwizzle.YXZ, -3, 3, 2, 2)]
        public void PaintDifferentSizedTilesOnAutomaticCellSizePalette_UpdatesPaletteCellSize(Grid.CellLayout layout,
            GridLayout.CellSwizzle swizzle, int tileX, int tileY, float expectedCellXSize, float expectedCellYSize)
        {
            var smallTile = AssetDatabase.LoadAssetAtPath<Tile>(tilePath);
            var bigTile = AssetDatabase.LoadAssetAtPath<Tile>(bigTilePath);

            var newPalette = GridPaletteUtility.CreateNewPalette(path, name, layout, GridPalette.CellSizing.Automatic,
                Vector3.one, swizzle);
            var tilemap = newPalette.GetComponentInChildren<Tilemap>();
            tilemap.SetTile(new Vector3Int(tileX, tileY, 0), bigTile);

            var w = CreatePaletteWindow();
            w.palette = newPalette;
            w.clipboardView.previewUtility.camera.orthographicSize = 1000;
            w.clipboardView.ClampZoomAndPan();
            Assert.GreaterOrEqual(GridPaletteBrushes.brushes.Count, 1);
            GridPaintingState.defaultBrush.Init(new Vector3Int(1, 1, 1));
            GridPaintingState.defaultBrush.SetTile(Vector3Int.zero, smallTile);
            w.clipboardView.unlocked = true;
            TilemapEditorTool.SetActiveEditorTool(typeof(PaintTool));

            Event ev = new Event();
            ev.mousePosition = w.clipboardView.GridToScreen(new Vector2(tileX + 1.5f, tileY + 1.5f)) +
                new Vector2(0, paletteHeaderHeight);
            ev.type = EventType.MouseMove;
            w.SendEvent(ev);
            ev.type = EventType.MouseDown;
            w.SendEvent(ev);
            ev.type = EventType.MouseUp;
            w.SendEvent(ev);
            w.clipboardView.unlocked = false;

            var grid = w.palette.GetComponent<Grid>();
            Assert.AreEqual(expectedCellXSize, grid.cellSize.x);
            Assert.AreEqual(expectedCellYSize, grid.cellSize.y);
        }

        [Test,
         Description(
             "Case 947462: Deleting a tilemap in a grid prefab and saving back that prefab creates a duplicate in scene")]
        [TestCase(Grid.CellLayout.Rectangle, GridLayout.CellSwizzle.XYZ)]
        [TestCase(Grid.CellLayout.Hexagon, GridLayout.CellSwizzle.XYZ)]
        [TestCase(Grid.CellLayout.Hexagon, GridLayout.CellSwizzle.YXZ)]
        public void PalettePrefabIsUpdated_DoesNotCreateAnInstanceInScene(Grid.CellLayout layout,
            GridLayout.CellSwizzle swizzle)
        {
            var palettePrefab = GridPaletteUtility.CreateNewPalette(path, name, layout,
                GridPalette.CellSizing.Automatic, Vector3.one, swizzle);

            var w = CreatePaletteWindow();
            w.palette = palettePrefab;

            Object[] objs = GameObject.FindObjectsOfType<Grid>();
            Assert.AreEqual(0, objs.Length,
                "There should be 0 Grids in this test as Palette instances have HideAndDontSave hide flags");

            var sceneGameObject = (GameObject)PrefabUtility.InstantiatePrefab(palettePrefab);
            var grid = sceneGameObject.GetComponent<Grid>();

            Object[] objsAfterInstantiatePrefab = GameObject.FindObjectsOfType<Grid>();
            Assert.AreEqual(1, objsAfterInstantiatePrefab.Length,
                "There should be 1 Grid in this test which is the instantiated prefab.");
            Assert.AreEqual(objsAfterInstantiatePrefab[0], grid,
                "The Grid found should be the Grid instantiated from the prefab.");

            grid.cellGap = new Vector3(2.0f, 2.0f, 0.0f);

            PrefabUtility.SaveAsPrefabAssetAndConnect(sceneGameObject, AssetDatabase.GetAssetPath(palettePrefab),
                InteractionMode.AutomatedAction);

            Object[] objsAfterReplacePrefab = GameObject.FindObjectsOfType<Grid>();
            Assert.AreEqual(1, objsAfterReplacePrefab.Length,
                "There should be 1 Grid in this test which is the instantiated prefab after replacing the prefab.");
            Assert.AreEqual(objsAfterReplacePrefab[0], grid,
                "The Grid found should be the Grid instantiated from the prefab after replacing the prefab.");

            // Clean up
            Object.DestroyImmediate(sceneGameObject);
        }

        [Test]
        public void SelectAndDragOutsideofPalette_CancelsSelectAction()
        {
            var w = CreatePaletteWindow();
            w.palette = AssetDatabase.LoadAssetAtPath<GameObject>(defaultTemporaryPalettePath);
            Selection.activeObject = null;
            TilemapEditorTool.SetActiveEditorTool(typeof(SelectTool));

            Event ev = new Event();
            ev.mousePosition = w.clipboardView.GridToScreen(new Vector2(2.5f, -2.5f)) +
                new Vector2(0, paletteHeaderHeight);
            ev.type = EventType.MouseDown;
            w.SendEvent(ev);
            ev.type = EventType.MouseDrag;
            ev.mousePosition =
                new Vector2(-10, -10); // MousePosition is relative to window, negative values are outside of window
            w.SendEvent(ev);
            ev.type = EventType.MouseUp;
            w.SendEvent(ev);

            Assert.IsNull(Selection.activeObject);
        }

        [Test]
        public void SelectAndDragOutsideAndBackInsideOfPalette_DoesSelectAction()
        {
            var w = CreatePaletteWindow();
            w.palette = AssetDatabase.LoadAssetAtPath<GameObject>(defaultTemporaryPalettePath);
            Selection.activeObject = null;
            TilemapEditorTool.SetActiveEditorTool(typeof(SelectTool));

            Event ev = new Event();
            ev.mousePosition = w.clipboardView.GridToScreen(new Vector2(2.5f, -2.5f)) +
                new Vector2(0, paletteHeaderHeight);
            ev.type = EventType.MouseDown;
            w.SendEvent(ev);
            ev.type = EventType.MouseDrag;
            ev.mousePosition =
                new Vector2(-10, -10); // MousePosition is relative to window, negative values are outside of window
            w.SendEvent(ev);
            ev.type = EventType.MouseDrag;
            ev.mousePosition = w.clipboardView.GridToScreen(new Vector2(2.5f, -2.5f)) +
                new Vector2(0, paletteHeaderHeight);                // Drag back inside Palette
            w.SendEvent(ev);
            ev.type = EventType.MouseUp;
            w.SendEvent(ev);

            Assert.NotNull(Selection.activeObject);
            Assert.AreEqual(typeof(GridSelection), Selection.activeObject.GetType());
        }

        [Test]
        public void BrushCache_LoadsAllAvailableGridBrushesInProject()
        {
            Assert.AreEqual(GridPaletteBrushes.brushes.Count, 3);
            Assert.IsTrue(GridPaletteBrushes.brushes[0] is GridBrush);
            Assert.IsTrue(GridPaletteBrushes.brushes[1] is MyBrush);
            Assert.IsTrue(GridPaletteBrushes.brushes[2] is MyBrush);
        }

        [Test]
        public void BrushCache_RefreshesWhenNewGridBrushIsAddedToProject()
        {
            AssetDatabase.CreateAsset(ScriptableObject.CreateInstance<MyBrush>(), temporaryAssetPath);
            Assert.AreEqual(GridPaletteBrushes.brushes.Count, 4);
            Assert.IsTrue(GridPaletteBrushes.brushes[3] is MyBrush);
        }

        [Test]
        public void GridPaintingState_NoActiveTargets_HasNoScenePaintTarget()
        {
            var tilemapGO1 = CreateTilemapGameObjectWithName(validMyBrushTargetName);
            var tilemapGO2 = CreateTilemapGameObjectWithName(validMyBrushTargetName);

            CreatePaletteWindow();

            GridPaintingState.AutoSelectPaintTarget();
            Assert.IsNotNull(GridPaintingState.scenePaintTarget);

            tilemapGO2.SetActive(false);
            GridPaintingState.FlushCache();
            GridPaintingState.AutoSelectPaintTarget();
            Assert.IsTrue(GridPaintingState.scenePaintTarget == tilemapGO1);

            tilemapGO1.SetActive(false);
            GridPaintingState.FlushCache();
            GridPaintingState.AutoSelectPaintTarget();
            Assert.IsTrue(GridPaintingState.scenePaintTarget == null);

            Object.DestroyImmediate(tilemapGO1);
            Object.DestroyImmediate(tilemapGO2);
        }

        public struct TileDragAndDropTestCase
        {
            public string assetPath;
            public Vector2Int pixel;
            public Vector2Int offset;
            public Vector2Int padding;

            public override String ToString()
            {
                return Path.GetFileName(assetPath);
            }
        }

        private static IEnumerable<TileDragAndDropTestCase> TileDragAndDropTestCases()
        {
            yield return new TileDragAndDropTestCase()
            { assetPath = emptyColumnRowTexturePath, pixel = new Vector2Int(16, 16), offset = new Vector2Int(16, 0), padding = new Vector2Int(0, 0) };
            yield return new TileDragAndDropTestCase
            { assetPath = square0000TexturePath, pixel = new Vector2Int(32, 32), offset = new Vector2Int(0, 0), padding = new Vector2Int(0, 0) };
            yield return new TileDragAndDropTestCase
            { assetPath = square1111TexturePath, pixel = new Vector2Int(32, 32), offset = new Vector2Int(1, 1), padding = new Vector2Int(1, 1) };
            yield return new TileDragAndDropTestCase
            { assetPath = square1222TexturePath, pixel = new Vector2Int(32, 32), offset = new Vector2Int(1, 2), padding = new Vector2Int(2, 2) };
        }

        [Test, Description("case 1103034: Missing Tiles when dragging a Spritesheet with empty column and row onto a Tile Palette")]
        public void TileDragAndDrop_SpritesheetTexture_HasCorrectEstimatedGridPixelOffsetPadding([ValueSource("TileDragAndDropTestCases")] TileDragAndDropTestCase testCase)
        {
            var sprites = AssetDatabase.LoadAllAssetsAtPath(testCase.assetPath).Where(x => x is Sprite)
                .Cast<Sprite>().ToList();
            Assert.IsTrue(sprites.Count > 0);
            var gridPixelSize = TileDragAndDrop.EstimateGridPixelSize(sprites);
            var gridOffsetSize = TileDragAndDrop.EstimateGridOffsetSize(sprites);
            var gridPaddingSize = TileDragAndDrop.EstimateGridPaddingSize(sprites, gridPixelSize, gridOffsetSize);
            Assert.AreEqual(testCase.pixel, gridPixelSize);
            Assert.AreEqual(testCase.offset, gridOffsetSize);
            Assert.AreEqual(testCase.padding, gridPaddingSize);
        }
    }
}