#if UNITY_EDITOR
using UnityEditor;
using FIMSpace.FEditor;
#endif

using UnityEngine;
using System.Collections.Generic;
using System;

namespace FIMSpace.Generating
{
    [AddComponentMenu("FImpossible Creations/PGG/Work In Progress/Flexible Painter", 9)]
    public class FlexiblePainter : PGGFlexibleGeneratorBase
    {

        #region Add Header Options

#if UNITY_EDITOR

        [MenuItem("CONTEXT/FlexibleGenerator/Clear whole Grid and Instructions")]
        private static void ClearWholeGrid(MenuCommand menuCommand)
        {
            FlexiblePainter painter = menuCommand.context as FlexiblePainter;
            if (painter) painter.Cells.ClearAll();
        }

#endif

        #endregion


        #region Painting Related

        public enum EPaintMode { Cells, Instructions }
        [HideInInspector] [SerializeField] public int PaintingID = -1;
        public bool Painting
        {
            get { return _Editor_Paint; }
            set { _Editor_Paint = value; }
        }

        #endregion


        [HideInInspector]
        [PGG_SingleLineTwoProperties("AllowOverlapInstructions", 0, 0, 10, 0, 3)]
        [Tooltip("If adding instructions on certain positions should automatically add cell to grid in same position. Useful for inject painting.")]
        public bool AddCellsOnInstructions = false;
        [Tooltip("If you want to add two instructions into single cell with painting")]
        [HideInInspector] public bool AllowOverlapInstructions = false;

        public enum EDebug { None, DrawGrid, DrawGridDetails }
        //[PGG_SingleLineTwoProperties("Transprent", 60, 70, 10, -45, 3)]
        public EDebug Debug = EDebug.DrawGrid;
        [HideInInspector] [Tooltip("Just making cell data rectanles transparent on gizmos")] public bool Transprent = true;

        #region Editor Related

        [HideInInspector] public bool _EditorGUI_DrawExtra = false;
        [HideInInspector] public bool _EditorGUI_DrawIgnoring = false;
        [HideInInspector] public bool _EditorGUI_DrawVars = false;
        [HideInInspector] public bool _EditorGUI_DrawPackVars = false;
        [HideInInspector] public bool _ModifyVars = false;
        [HideInInspector] public bool _ModifyPackVars = false;
        [HideInInspector] public int _EditorGUI_SelectedId = -1;

        [HideInInspector] public bool _Editor_Paint = false;
        [HideInInspector] public int _Editor_RadiusY = 1;
        [HideInInspector] public int _Editor_PaintRadius = 1;
        [HideInInspector] public int _Editor_YLevel = 0;
        [HideInInspector] public int _Editor_CommandsPage = 0;

        [HideInInspector] public GridPainter.EPaintSpaceMode _Editor_PaintSpaceMode = GridPainter.EPaintSpaceMode.XZ;
        public bool IsPainting2D { get { return _Editor_PaintSpaceMode == GridPainter.EPaintSpaceMode.XY_2D; } }
        [HideInInspector] public string _Editor_Instruction = "0";
        [HideInInspector] public bool _Editor_RotOrMovTool = false;
        [HideInInspector] public bool _Editor_ContinousMode = false;

        #endregion


        public override void GenerateObjects()
        {
            Prepare();

            // Run rules
            Cells.Generate(true);

            // Post events
            base.GenerateObjects();
        }


        public void PaintPosition(Vector3Int pos, bool erase = false, bool generate = false)
        {
            if (erase == false)
                Cells.AddCell(pos);
            else
                Cells.RemoveCell(pos);

            if (generate) GenerateObjects();
        }

        public override void ClearGenerated(bool destroy = true)
        {
            if (destroy) InstantiatedInfo.Clear(true);
            Cells.ClearPhantomSpawnsInAllCells();
            Cells.SetAllDirty();
        }

        public void HardClear(bool destroy)
        {
            base.ClearGenerated(destroy);
        }


        #region Debugging Help Gizmos

#if UNITY_EDITOR


        private void OnDrawGizmosSelected()
        {
            if (FieldSetup == null) return;
            if (DataSetup != null) DataSetup.RefreshReferences(this);

            Cells.CheckIfGridPrepared();
            var grid = Cells.Grid;

            // Preparation for drawing
            Color preColor = GUI.color;
            Gizmos.matrix = Matrix4x4.TRS(transform.position, transform.rotation, Vector3.one);
            Handles.matrix = Gizmos.matrix;
            Gizmos.color = new Color(1f, 1f, 1f, 0.1f);

            Vector3 cSize = FieldSetup.GetCellUnitSize();
            bool is2D = _Editor_PaintSpaceMode == GridPainter.EPaintSpaceMode.XY_2D;

            // Below just drawing debug grid, instructions, draw position - no events or paint triggers - it's done in OnSceneGUI in editor script component

            #region Drawing grid

            if (Debug != EDebug.None)
                for (int i = 0; i < grid.AllApprovedCells.Count; i++)
                {
                    var cell = grid.AllApprovedCells[i];
                    Vector3 genPosition = cell.WorldPos(cSize);

                    if ((!is2D && cell.Pos.y == _Editor_YLevel) || (is2D && cell.Pos.z == _Editor_YLevel))
                    {
                        if (is2D)
                            Gizmos.DrawWireCube(genPosition + new Vector3(0, cSize.y * 0.5f, 0), new Vector3(cSize.x, cSize.y, cSize.z * 0.2f));
                        else
                            Gizmos.DrawWireCube(genPosition, new Vector3(cSize.x, cSize.y * 0.2f, cSize.z));

                        //if (cell.InTargetGridArea) Gizmos.DrawCube(genPosition, new Vector3(cSize.x, cSize.y * 0.2f, cSize.z) * 0.5f);

                        //Color preC = Gizmos.color;
                        //Gizmos.color = Color.white;
                        //if (GenController.GridCellsSave.Contains(cell)) Gizmos.DrawCube(genPosition + Vector3.right * cSize.x * 0.25f, new Vector3(cSize.x, cSize.y * 0.2f, cSize.z) * 0.3f);
                        //Gizmos.color = preC;

                        if (Debug == EDebug.DrawGridDetails)
                        {
                            Handles.Label(genPosition, new GUIContent(cell.Pos.x + ", " + cell.Pos.z + "\nSpawns: " + cell.GetJustCellSpawnCount()), EditorStyles.centeredGreyMiniLabel);

                            if (FGenerators.CheckIfExist_NOTNULL(cell.ParentCell))
                            {
                                Handles.color = Color.cyan;
                                Handles.DrawLine(genPosition, genPosition + Vector3.up * cSize.y * 0.25f);
                                Handles.DrawLine(genPosition, cell.ParentCell.WorldPos(cSize));
                                Handles.color = Color.white;
                            }
                        }
                    }
                    else
                    {
                        Gizmos.color = new Color(1f, 1f, 1f, 0.05f);

                        if (is2D)
                            Gizmos.DrawWireCube(genPosition + new Vector3(0, cSize.y * 0.5f, 0), new Vector3(cSize.x * 0.9f, cSize.y * 0.9f, cSize.z * 0.05f));
                        else
                            Gizmos.DrawWireCube(genPosition, new Vector3(cSize.x * 0.9f, cSize.y * 0.05f, cSize.z * 0.9f));

                        Gizmos.color = new Color(1f, 1f, 1f, 0.1f);
                    }
                }

            #endregion


            #region Drawing cell instructions

            var instr = Preparation.CellInstructions;
            if (instr != null)
                for (int i = 0; i < instr.Count; i++)
                {
                    Color nCol = Color.HSVToRGB((float)instr[i].HelperID * 0.1f % 1f, 0.7f, 0.8f);
                    nCol.a = Transprent ? 0.185f : 1f;
                    Gizmos.color = nCol;
                    Vector3 pos = FieldSetup.TransformCellPosition((Vector3)instr[i].gridPosition);
                    Gizmos.DrawCube(pos, new Vector3(cSize.x, cSize.y * 0.2f, cSize.z));
                }

            #endregion


            #region Drawing Entered Cells when painting + radius

            Gizmos.color = new Color(1f, 1f, 1f, 0.1f);

            if (Painting)
            {
                if (FieldSetup != null)
                {
                    if (SceneView.currentDrawingSceneView != null)
                        if (SceneView.currentDrawingSceneView.camera != null)
                        {
                            if (PaintingID == -1) Gizmos.color = Color.white;
                            else Gizmos.color = Color.yellow;

                            if (is2D == false)
                            {
                                // Line Guide
                                Vector3 mousePos = transform.InverseTransformPoint(GridVisualize.GetMouseWorldPosition(transform.up, Event.current, SceneView.currentDrawingSceneView.camera, _Editor_YLevel, cSize.y, transform.position.y * Vector3.up));
                                Gizmos.DrawLine(mousePos, mousePos + Vector3.up * 1);

                                // Cell Guide
                                Vector3 gridPos = FVectorMethods.FlattenVector(mousePos, cSize);
                                Gizmos.DrawWireCube(gridPos, new Vector3(cSize.x, cSize.y * 0.2f, cSize.z));

                                // Cells Radius
                                if (_Editor_PaintRadius > 1 || _Editor_RadiusY > 1)
                                {
                                    int rad = Mathf.RoundToInt((float)_Editor_PaintRadius * 0.7f);

                                    for (int x = -rad; x < rad; x++)
                                        for (int ry = 0; ry < _Editor_RadiusY; ry++)
                                            for (int z = -rad; z < rad; z++)
                                            {
                                                if (x == 0 && ry == 0 && z == 0) continue; // Ignore zero cell (drawn in lines above)
                                                Gizmos.DrawWireCube(gridPos + new Vector3(cSize.x * x, cSize.y * ry, cSize.z * z), new Vector3(cSize.x, cSize.y * 0.2f, cSize.z));
                                            }
                                }
                            }
                            else // 2D
                            {
                                // Line Guide
                                Vector3 mousePos = transform.InverseTransformPoint(GridVisualize.GetMouseWorldPosition2D(-transform.forward, Event.current, SceneView.currentDrawingSceneView.camera, _Editor_YLevel, cSize.y, transform.position.z * Vector3.forward));
                                Gizmos.DrawLine(mousePos, mousePos + Vector3.back * 1);

                                // Cell Guide
                                Vector3 gridPos = FVectorMethods.FlattenVector(mousePos - new Vector3(0f, cSize.y * 0.5f, 0f), cSize);
                                Gizmos.DrawWireCube(gridPos + new Vector3(0, cSize.y * 0.5f, 0f), new Vector3(cSize.x, cSize.y, cSize.z * 0.2f));

                                // Cells Radius
                                if (_Editor_PaintRadius > 1 || _Editor_RadiusY > 1)
                                {
                                    int rad = Mathf.RoundToInt((float)_Editor_PaintRadius * 0.7f);

                                    for (int x = -rad; x < rad; x++)
                                        for (int ry = -rad; ry < rad; ry++)
                                            for (int z = 0; z < _Editor_RadiusY; z++)
                                            {
                                                if (x == 0 && ry == 0 && z == 0) continue; // Ignore zero cell (drawn in lines above)
                                                Gizmos.DrawWireCube(gridPos + new Vector3(0f, cSize.y * 0.5f, 0) + new Vector3(cSize.x * x, cSize.y * ry, cSize.z * z), new Vector3(cSize.x, cSize.y, cSize.z * 0.2f));
                                            }
                                }
                            }
                        } // If field exist and scene view END
                }
            } // If painting END

            #endregion


            // Restore Gizmos
            Gizmos.color = preColor;
            Gizmos.matrix = Matrix4x4.identity;
            Handles.matrix = Matrix4x4.identity;

        }

#endif

        #endregion


        public void OnChange()
        {
            if (AutoRefresh) GenerateObjects();
        }


        #region Grid related

        /// <summary>
        /// World Position to Grid Cell number Position
        /// </summary>
        public Vector3Int WorldToGridCellPosition(Vector3 worldPosition, bool is2D = false, Camera camera = null)
        {
            if (FieldSetup == null) return Vector3Int.zero;

            Vector3 cSize = FieldSetup.GetCellUnitSize();

            if (is2D == false) // Flat top down
            {
                Vector3 mousePos = transform.InverseTransformPoint(worldPosition);
                Vector3 gridPos = FVectorMethods.FlattenVector(mousePos, cSize);
                return (gridPos).V3toV3Int();
            }
            else // 2D - Flat Side
            {
                Vector3 mousePos = transform.InverseTransformPoint(GridVisualize.GetMouseWorldPosition2D(-transform.forward, Event.current, camera, _Editor_YLevel, cSize.y, transform.position.z * Vector3.forward));
                Vector3 gridPos = FVectorMethods.FlattenVector(mousePos - new Vector3(0f, cSize.y * 0.5f, 0f), cSize);
                return (gridPos).V3toV3Int();
            }
        }

        /// <summary>
        /// From grid cell position to world position
        /// </summary>
        public Vector3 GridCellToWorldPosition(Vector3Int gridCell)
        {
            Vector3 cSize = FieldSetup.GetCellUnitSize();
            return transform.TransformPoint(Vector3.Scale(gridCell, cSize));
        }

        /// <summary>
        /// From world position to cell position in world
        /// </summary>
        public Vector3 GetWorldPositionOfCellAt(Vector3 worldPosition, bool is2D = false)
        {
            return GridCellToWorldPosition(WorldToGridCellPosition(worldPosition, is2D));
        }

        public static List<SpawnInstruction> CellInstructionsToSpawnInstructions(List<SpawnInstructionGuide> guides, FieldSetup setup, Transform generator)
        {
            List<SpawnInstruction> spwns = new List<SpawnInstruction>();
            
            for (int i = 0; i < guides.Count; i++)
            {
                var guide = guides[i];
                SpawnInstruction instr = new SpawnInstruction();


                Vector3 dir;

                if (guide.WorldRot)
                    dir = (Quaternion.Inverse(generator.rotation) * guide.rot) * Vector3.forward;
                else
                    dir = guide.rot * Vector3.forward;

                instr.desiredDirection = new Vector3Int(Mathf.RoundToInt(dir.x), 0, Mathf.RoundToInt(dir.z));
                instr.gridPosition = new Vector3Int(guide.pos.x, guide.pos.y, guide.pos.z);
                instr.useDirection = guide.UseDirection;

                if (guide.CustomDefinition == null)
                {
                    if (guide.Id < setup.CellsInstructions.Count)
                    {
                        instr.definition = setup.CellsInstructions[guide.Id];
                    }
                }
                else
                {
                    if (guide.CustomDefinition.InstructionType != InstructionDefinition.EInstruction.None)
                        instr.definition = guide.CustomDefinition;
                    else
                        if (guide.Id < setup.CellsInstructions.Count)
                        instr.definition = setup.CellsInstructions[guide.Id];
                }
                
                spwns.Add(instr);
            }

            return spwns;
        }

        #endregion

    }




#if UNITY_EDITOR

    [UnityEditor.CanEditMultipleObjects]
    [UnityEditor.CustomEditor(typeof(FlexiblePainter))]
    public class FlexiblePainterEditor : PGGFlexibleGeneratorBaseEditor
    {
        public FlexiblePainter Get { get { if (_get == null) _get = (FlexiblePainter)target; return _get; } }
        private FlexiblePainter _get;

        public override bool RequiresConstantRepaint()
        {
            return Get.Painting;
        }

        protected override void OnEnable()
        {
            base.OnEnable();
            _editor_drawRandomNumber = false;
            Get.Seed = 0;
        }

        protected override void DrawGUIFooter()
        {
            DrawGeneratingButtons(false, true);
            GUILayout.Space(3);
        }


        protected override void DrawGeneratingButtons(bool drawPreview = true, bool drawClear = true)
        {
            GUILayout.Space(3);
            EditorGUILayout.BeginHorizontal();

            if (GUILayout.Button("Generate")) Get.GenerateObjects();

            if (bGet)
                if (bGet.DataSetup.CellsController != null)
                    if (bGet.DataSetup.CellsController.InstantiatedInfo != null)
                        if (bGet.DataSetup.CellsController.InstantiatedInfo.Instantiated != null)
                            if (bGet.DataSetup.CellsController.InstantiatedInfo.Instantiated.Count > 0)
                                if (GUILayout.Button("Clear", GUILayout.Width(50)))
                                    Get.ClearGenerated(true);

            if (GUILayout.Button("Erase Grid", GUILayout.Width(70)))
            {
                Get.HardClear(true);
            }

            EditorGUILayout.EndHorizontal();
        }


        #region Scene GUI

        private void OnSceneGUI()
        {
            if (SceneView.currentDrawingSceneView == null) return;
            if (SceneView.currentDrawingSceneView.camera == null) return;
            if (Selection.activeGameObject != Get.gameObject) return;
            if (Get.FieldSetup == null) return;

            Get.Cells.CheckIfGridPrepared();
            var grid = Get.Cells.Grid;

            Undo.RecordObject(Get, "PGGGridP");

            Vector3 cSize = Get.FieldSetup.GetCellUnitSize();
            Color preH = Handles.color;


            {
                //if (grid != null)

                //    if (Get._Editor_Paint == false)
                //        if (Get.GetAllPainterCells.Count > 0)
                //        {
                //            Handles.color = new Color(0.2f, 1f, 0.2f, 0.8f);

                //            for (int i = Get.CellsInstructions.Count - 1; i >= 0; i--)
                //            {
                //                if (Get.CellsInstructions[i] == null)
                //                {
                //                    Get.CellsInstructions.RemoveAt(i);
                //                    continue;
                //                }

                //                var instr = Get.CellsInstructions[i];
                //                float size = cSize.x;
                //                Vector3 genPosition = Get.transform.TransformPoint(Get.FieldPreset.TransformCellPosition((Vector3)instr.pos));
                //                //Vector3 genPosition = Get.transform.TransformPoint((Vector3)instr.pos * size);

                //                if (Handles.Button(genPosition, Quaternion.identity, size * 0.2f, size * 0.2f, Handles.SphereHandleCap))
                //                {
                //                    if (Get.Selected == instr) Get.Selected = null; else Get.Selected = instr;
                //                }

                //                if (Get.Selected == instr)
                //                {
                //                    if (DrawButton(EditorGUIUtility.IconContent(Get._Editor_RotOrMovTool ? "MoveTool" : "RotateTool"), genPosition - Get.transform.forward * size * 0.4f - Get.transform.right * size * 0.4f, size * 0.9f))
                //                    {
                //                        Get._Editor_RotOrMovTool = !Get._Editor_RotOrMovTool;
                //                    }

                //                    if (Get._Editor_RotOrMovTool)
                //                    {
                //                        Handles.Label(genPosition - Get.transform.forward * size * 0.44f - Get.transform.right * size * 0.57f, new GUIContent(FGUI_Resources.Tex_Info, "Switch back to cell rotation tool if you want to use directional mode. If you leave this guide in movement mode then rotation will not be used!"));
                //                    }

                //                    instr.UseDirection = !Get._Editor_RotOrMovTool;

                //                    //if (Get.CellsInstructions.Count > 1)
                //                    //{
                //                    //    if (DrawButton(new GUIContent(instr.Id.ToString()), genPosition + Get.transform.forward * size * 0.4f , size * 0.9f)) instr.Id += 1;
                //                    //    if (DrawButton(new GUIContent("+"), genPosition + Get.transform.forward * size * 0.4f + Get.transform.right * size * 0.4f, size * 0.9f)) instr.Id += 1;
                //                    //    if (DrawButton(new GUIContent("-"), genPosition + Get.transform.forward * size * 0.3f + Get.transform.right * size * 0.5f, size * 0.9f)) instr.Id -= 1;
                //                    //    if (instr.Id < 0) instr.Id = Get.CellsInstructions.Count - 1;
                //                    //    if (instr.Id > Get.CellsInstructions.Count - 1) instr.Id = 0;
                //                    //}

                //                    if (Get._Editor_RotOrMovTool == false)
                //                    {
                //                        Get.Selected.rot = FEditor_TransformHandles.RotationHandle(Get.Selected.rot, genPosition, size * 0.75f);
                //                        Get.Selected.rot = FVectorMethods.FlattenRotation(Get.Selected.rot, 45f);
                //                    }
                //                    else
                //                    {
                //                        Get.Selected.pos = PGGUtils.V3toV3Int(Get.transform.InverseTransformPoint(FEditor_TransformHandles.PositionHandle(genPosition, Get.transform.rotation * instr.rot, size * 0.75f)) / size);
                //                        //Get.Selected.pos = FVectorMethods.FlattenVector(Get.Selected.pos, Get.RoomPreset.CellSize);
                //                    }

                //                    Quaternion r = Get.transform.rotation * Get.Selected.rot;
                //                    FGUI_Handles.DrawArrow(genPosition, Quaternion.Euler(r.eulerAngles), 0.5f, 0f, 1f);

                //                    if (instr != null)
                //                    {
                //                        if (instr.CustomDefinition.InstructionType != InstructionDefinition.EInstruction.None)
                //                            Handles.Label(genPosition + Get.transform.forward * size * 0.3f, new GUIContent(instr.CustomDefinition.Title));
                //                        else
                //                            Handles.Label(genPosition + Get.transform.forward * size * 0.3f, new GUIContent(Get.FieldPreset.CellsInstructions[instr.Id].Title));
                //                    }
                //                }
                //            }

                //        }
            }


            Handles.color = preH;
            Handles.BeginGUI();

            float dpiH = FGenerators.EditorUIScale;
            int hOffset = (int)(Screen.height / dpiH);


            #region Scene View GUI Buttons

            GridVisualize.DrawPaintGUI(ref Get._Editor_Paint, hOffset);

            if (Get._Editor_Paint)
            {
                //if (Get._Editor_PaintSpaceMode == GridPainter.EPaintSpaceMode.XZ)
                {
                    Rect radRect = new Rect(15, hOffset - 140, 140, 20);
                    Get._Editor_PaintRadius = Mathf.RoundToInt(GUI.HorizontalSlider(radRect, Get._Editor_PaintRadius, 1, 4));
                    radRect = new Rect(radRect);
                    radRect.y -= 18;
                    GUI.Label(radRect, new GUIContent("Radius"));

                    radRect = new Rect(15, hOffset - 179, 140, 20);
                    Get._Editor_RadiusY = Mathf.RoundToInt(GUI.HorizontalSlider(radRect, Get._Editor_RadiusY, 1, 4));
                    radRect = new Rect(radRect);
                    radRect.y -= 18;
                    GUI.Label(radRect, new GUIContent("Radius Y"));
                }

                Rect refreshRect = new Rect(160, hOffset - 75, 120, 20);
                Get.AutoRefresh = GUI.Toggle(refreshRect, Get.AutoRefresh, "Auto Refresh");

                if (!Get.AutoRefresh)
                {
                    refreshRect.position += new Vector2(116, 0);

                    if (GUI.Button(refreshRect, "Generate"))
                    {
                        Get.GenerateObjects();
                    }
                }
            }
            else
            {
                Rect refreshRect = new Rect(160, hOffset - 75, 120, 20);
                if (GUI.Button(refreshRect, "Generate"))
                {
                    //Get.ClearGenerated();
                    Get.GenerateObjects();
                }
            }


            Color preC = GUI.backgroundColor;
            Rect bRect;

            int x = 160;
            int y = (int)(22 * dpiH);
            bRect = new Rect(x, y, 160, 40);

            string focusTxt = Get._Editor_PaintSpaceMode == GridPainter.EPaintSpaceMode.XZ ? "Focus On Y Level: " : "Focus On Z Depth: ";

            GUI.Label(bRect, focusTxt + Get._Editor_YLevel, FGUI_Resources.HeaderStyle);
            bRect = new Rect(x + 150, y, 20, 20);
            if (GUI.Button(bRect, "▲")) Get._Editor_YLevel++;


            if (Get._Editor_Paint)
            {
                bRect = new Rect(x + 185, y, 55, 20);
                GUI.Label(bRect, "shift + A", FGUI_Resources.HeaderStyle);
            }

            bRect = new Rect(x + 150, y + 22 * dpiH, 20, 20);
            if (GUI.Button(bRect, "▼")) Get._Editor_YLevel--;

            if (Get._Editor_Paint)
            {
                bRect = new Rect(x + 185, y + 21 * dpiH, 55, 20);
                GUI.Label(bRect, "shift + Z", FGUI_Resources.HeaderStyle);
            }

            bRect = new Rect(x + 20 * dpiH, y + 31 * dpiH, 120, 20);
            bool is2D = Get._Editor_PaintSpaceMode == GridPainter.EPaintSpaceMode.XY_2D;
            is2D = GUI.Toggle(bRect, is2D, " Paint 2D");
            Get._Editor_PaintSpaceMode = is2D ? GridPainter.EPaintSpaceMode.XY_2D : GridPainter.EPaintSpaceMode.XZ;

            //bRect = new Rect(x + 200, y - 7 * dpiH, 300, 100);
            //GUI.Label(bRect, "If you don't see 'Paint' button on the bottom of\nscene view then you must change dpi settings\nof unity editor and restart it.");


            if (string.IsNullOrEmpty(Get.FieldSetup.InfoText) == false)
            {
                GUIContent cont = new GUIContent("Info:\n" + Get.FieldSetup.InfoText);
                Vector2 sz = EditorStyles.label.CalcSize(cont); sz = new Vector2(sz.x * 1.04f + 8, sz.y * 1.1f);
                bRect = new Rect((Screen.width / dpiH) - sz.x, hOffset - 45 * dpiH - sz.y, sz.x, sz.y);
                GUI.Label(bRect, cont);
            }

            #endregion


            DrawCellTools();

            Handles.EndGUI();

            if (Get.FieldSetup != null)
                if (Event.current.type == EventType.MouseMove)
                    SceneView.RepaintAll();


            #region Triggering Cell Painting etc.


            int eButton = Event.current.button;
            CellsController generating = Get.Cells;

            if (eButton < 2)
                if (Get.PaintingID == -1) // Painting simple grid cells
                {
                    var cell = GridVisualize.ProcessInputEvents(ref Get._Editor_Paint, grid, Get.FieldSetup, ref Get._Editor_YLevel, Get.transform, false, cSize.y, is2D);

                    if (cell != null)
                    {
                        if (eButton == 0)
                        {
                            Get.PaintPosition(cell.Pos);
                        }
                        else if (eButton == 1)
                        {
                            Get.PaintPosition(cell.Pos, true);
                        }

                        if (Get._Editor_PaintRadius > 1 || Get._Editor_RadiusY > 1)
                        {
                            int rad = Mathf.RoundToInt((float)Get._Editor_PaintRadius * 0.7f);

                            if (!is2D)
                            {
                                for (int rx = -rad; rx < rad; rx++)
                                    for (int ry = 0; ry < Get._Editor_RadiusY; ry++)
                                        for (int rz = -rad; rz < rad; rz++)
                                        {
                                            if (rx == 0 && ry == 0 && rz == 0) continue;
                                            Vector3Int radPos = cell.Pos + new Vector3Int(rx, ry, rz);

                                            if (cell.InTargetGridArea)
                                            {
                                                Get.PaintPosition(radPos);
                                            }
                                            else
                                                Get.PaintPosition(radPos, true);
                                        }
                            }
                            else
                            {

                                for (int rx = -rad; rx < rad; rx++)
                                    for (int ry = -rad; ry < rad; ry++)
                                        for (int rz = 0; rz < Get._Editor_RadiusY; rz++)
                                        {
                                            if (rx == 0 && ry == 0 && rz == 0) continue;
                                            Vector3Int radPos = cell.Pos + new Vector3Int(rx, ry, rz);

                                            if (cell.InTargetGridArea)
                                            {
                                                Get.PaintPosition(radPos);
                                            }
                                            else
                                                Get.PaintPosition(radPos, true);
                                        }
                            }


                        }

                        Get.OnChange();
                    }
                }
                else // Painting cell commands
                {
                    //bool change = false;
                    //bool rem = false;

                    //var e = Event.current;
                    //if (e != null) if (e.isMouse) if (e.type == EventType.MouseDown || e.type == EventType.MouseDrag) if (Event.current.button == 1) rem = true;

                    //var cell = GridVisualize.ProcessInputEvents(ref Get._Editor_Paint, grid, Get.FieldPreset, ref Get._Editor_YLevel, Get.transform, false, cSize.y, is2D);

                    //if (cell != null)
                    //{
                    //    int already = -1;
                    //    for (int i = 0; i < Get.CellsInstructions.Count; i++)
                    //    {
                    //        if (Get.CellsInstructions[i] == null) continue;
                    //        if (Get.CellsInstructions[i].pos == cell.Pos)
                    //        {
                    //            already = i;
                    //            if (Get.AllowOverlapInstructions)
                    //            {
                    //                if (Get.CellsInstructions[i].Id == Get.PaintingID)
                    //                {
                    //                    break;
                    //                }
                    //                else
                    //                    if (eButton == 0) already = -1;
                    //            }
                    //            else
                    //                break;
                    //        }
                    //    }

                    //    if (already == -1)
                    //    {

                    //        if (eButton == 0)
                    //        {
                    //            SpawnInstructionGuide instr = new SpawnInstructionGuide();
                    //            instr.pos = cell.Pos;
                    //            instr.Id = Get.PaintingID;

                    //            Get.CellsInstructions.Add(instr);

                    //            if (Get.AddCellsOnInstructions) grid.AddCell(cell.Pos);

                    //            change = true;
                    //            new SerializedObject(target).Update();
                    //        }
                    //    }
                    //    else
                    //    {
                    //        if (rem)
                    //        {
                    //            Get.CellsInstructions.RemoveAt(already);
                    //            change = true;
                    //            new SerializedObject(target).Update();
                    //        }
                    //    }

                    //    if (change) Get.OnChange();
                    //}
                }


            #endregion

        }


        /// <summary>
        /// Draw paint cell instructions pages etc.
        /// </summary>
        public void DrawCellTools()
        {
            if (Get.FieldSetup == null) return;

            Rect bRect = new Rect(15, 15, 132, 24);
            Color preC = GUI.backgroundColor;

            if (Get.PaintingID == -1) GUI.backgroundColor = Color.green;
            if (GUI.Button(bRect, "Paint Cells "))
            {
                Get.PaintingID = -1;
            }

            GUI.backgroundColor = preC;

            //int commandsPerPage = 7;
            //int totalPages = ((Get.FieldSetup.CellsInstructions.Count + (commandsPerPage - 1)) / commandsPerPage);

            //bRect.y += 10;

            //if (totalPages > 1)
            //{
            //    float yy = bRect.y + FGenerators.EditorUIScale * 24;
            //    Rect btRect = new Rect(bRect.x, yy, 20, 18);
            //    if (GUI.Button(btRect, "<")) { Get._Editor_CommandsPage -= 1; if (Get._Editor_CommandsPage < 0) Get._Editor_CommandsPage = totalPages - 1; }
            //    btRect = new Rect(bRect.x + 24, yy, 86, 18);
            //    GUI.Label(btRect, (Get._Editor_CommandsPage + 1) + " / " + totalPages, FGUI_Resources.HeaderStyle);
            //    btRect = new Rect(bRect.x + 100, yy, 20, 18);
            //    if (GUI.Button(btRect, ">")) { Get._Editor_CommandsPage += 1; if (Get._Editor_CommandsPage >= totalPages) Get._Editor_CommandsPage = 0; }
            //    bRect.y += 20;
            //}

            //bRect.y += 4 * FGenerators.EditorUIScale;
            //bRect.height -= 4;
            //bRect.width += 6;
            //float padding = 23 * FGenerators.EditorUIScale;

            //if (Get._Editor_CommandsPage >= totalPages) Get._Editor_CommandsPage = 0;
            //int startI = Get._Editor_CommandsPage * commandsPerPage;

            //for (int i = startI; i < startI + commandsPerPage; i++)
            //{
            //    if (i >= Get.FieldSetup.CellsInstructions.Count) break;

            //    bRect.y += padding;
            //    if (Get.PaintingID == i) GUI.backgroundColor = Color.green;

            //    if (FGenerators.CheckIfExist_NOTNULL(Get.FieldSetup.CellsInstructions[i]))
            //        if (GUI.Button(bRect, Get.FieldSetup.CellsInstructions[i].Title))
            //            Get.PaintingID = i;

            //    if (Get.PaintingID == i) GUI.backgroundColor = preC;
            //}

            GUI.backgroundColor = preC;
        }


        /// <summary>
        /// Drawing button visible in scene view
        /// </summary>
        bool DrawButton(GUIContent content, Vector3 pos, float size)
        {
            float sc = HandleUtility.GetHandleSize(pos);
            float hSize = Mathf.Sqrt(size) * 32 - sc * 16;

            if (hSize > 0f)
            {
                Handles.BeginGUI();
                Vector2 pos2D = HandleUtility.WorldToGUIPoint(pos);
                float hhSize = hSize / 2f;
                if (GUI.Button(new Rect(pos2D.x - hhSize, pos2D.y - hhSize, hSize, hSize), content))
                {
                    Handles.EndGUI();
                    return true;
                }

                Handles.EndGUI();
            }

            return false;
        }


        #endregion

    }


#endif
}