using Godot;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;


public partial class Actor : Sprite2D
{
	public Sprite2D _markNormal, _markPressed, _markHovered, _markDisabled, _markFocused;
    public Board _board;
	public override void _Ready()
	{
        _markNormal = GetNode<Sprite2D>("MarkNormal");
        _markPressed = GetNode<Sprite2D>("MarkPressed");
		_markHovered = GetNode<Sprite2D>("MarkHovered");
        _markDisabled = GetNode<Sprite2D>("MarkDisabled");
        _markFocused = GetNode<Sprite2D>("MarkFocused");
    }

    // CALLABLE ACTIONS

    public bool RotateCells(int ROTATIONS = 1, bool JUST_MARKS = false)
    {
        List<Vector2> positions = new(_board._cells.Select(c=>c.Position).ToList());
        List<int> addresses = new(_board._cells.Select(c=>c._address).ToList());
        Dictionary<int, int> cwShifts = new()
        {
            {0,1}, {1,2}, {2,5}, {3,0}, {4,4}, {5,8}, {6,3}, {7,6}, {8,7}
        };
        Dictionary<int, int> ccwShifts = new()
        {
            {0,3}, {1,0}, {2,1}, {3,6}, {4,4}, {5,2}, {6,7}, {7,8}, {8,5}
        };
        Dictionary<int, int> shifts = ROTATIONS > 0 ? cwShifts : ccwShifts;
        
        for (int i = 0; i < Math.Abs(ROTATIONS); i++)
        {
            for (int j = 0; j < addresses.Count; j++)
            {
                int address = addresses[j];
                int newAddress = shifts[address];
                addresses[j] = newAddress;
            }
        }

        for (int i = 0; i < _board._cells.Count; i++)
        {
            int newCellAddress = addresses[i];
            _board._cells[i].Position = positions[newCellAddress];
        }

        _board.RenumberCells();
        return true;
    }

    public bool ShiftMarks(int COLUMNS = 0, int ROWS = 0)
    {
        List<Actor> markers = new(_board._cells.Select(c=>c._marker).ToList());
        int[,] cellsToTable = {{0,1,2},{3,4,5},{6,7,8}};
        for (int i = 0; i < cellsToTable.GetLength(0); i++) //ROWS / Y
        {
            for (int j = 0; j < cellsToTable.GetLength(1); j++) //COLUMNS / X
            {
                int toY = ROWS >= 0 ? cellsToTable.GetLength(0) - 1 - i : i;
                int fromY = toY - ROWS;
                int toX = COLUMNS >= 0 ? cellsToTable.GetLength(1) - 1 - j : j;
                int fromX = toX - COLUMNS;
                if (fromY >= 0 && fromY <= cellsToTable.GetLength(0) && fromX >= 0 && fromX <= cellsToTable.GetLength(1))
                {
                    int toI = cellsToTable[toY, toX];
                    int fromI = cellsToTable[fromY, fromX];
                    if (_board._cells[fromI]._marker != null)
                    {
                        _board._cells[toI].Mark(_board._cells[fromI]._marker);
                        _board._cells[fromI].Clear();
                    }
                    else
                    {
                        _board._cells[toI].Clear();
                    }
                    
                }
                
            }
            // int actualIndex = 
            // int cellCol = i % 3;
            // int cellRow = (int)Math.Floor(i / 3f);
            // int newCol = cellCol + COLUMNS;
            // int newRow = cellRow + ROWS;
            // if (newCol >= 0 &&  newRow >= 0 && newCol <= 2 && newRow <= 2)
            // {
            //     int newAddress = newRow*3 + newCol;
            //     GD.Print(i, cellCol, cellRow, newCol, newRow, newAddress);
            //     if (_board._cells[i]._marker != null)
            //     {
            //         _board._cells[newAddress].Mark(_board._cells[i]._marker);
            //     }
            //     // _board._cells[i].Clear();
            // }
        }
        _board.RenumberCells();
        
        return true;
    }

    public bool SlideCells(int SHIFT_SPOTS = 1)
    {
        List<Vector2> positions = new(_board._cells.Select(c=>c.Position).ToList());
        int start = SHIFT_SPOTS > 0 ? 0 : 9;
        for (int i = 0; i < _board._cells.Count; i++)
        {
            int newSpot = (start + i + SHIFT_SPOTS) % 9;
            _board._cells[i].Position = positions[newSpot];
        }
        _board.RenumberCells();
        return true;
    }

    public bool SwapCells(int CELL_A_ADDRESS = -1, int CELL_B_ADDRESS = -1)
    {
        if (CELL_A_ADDRESS < -1 || CELL_A_ADDRESS > 8 || CELL_B_ADDRESS < -1 || CELL_B_ADDRESS > 8 || CELL_A_ADDRESS == CELL_B_ADDRESS)
        {
            return false;
        }
        List<Vector2> positions = new(_board._cells.Select(c=>c.Position).ToList());
        if (CELL_A_ADDRESS == -1)
        {
            CELL_A_ADDRESS = Globals._rng.Next(0,8);
            while (CELL_A_ADDRESS == CELL_B_ADDRESS)
            {
                CELL_A_ADDRESS = Globals._rng.Next(0,8);
            }
        }
        if (CELL_B_ADDRESS == -1)
        {
            CELL_B_ADDRESS = Globals._rng.Next(0,8);
            while (CELL_B_ADDRESS == CELL_A_ADDRESS)
            {
                CELL_B_ADDRESS = Globals._rng.Next(0,8);
            }
        }
        _board._cells[CELL_A_ADDRESS].Position = positions[CELL_B_ADDRESS];
        _board._cells[CELL_B_ADDRESS].Position = positions[CELL_A_ADDRESS];
        _board.RenumberCells();
        
        return true;
    }


    //MoveMark

    //ShiftColumns

    //ShiftRows


    
}