using UnityEngine;
using System.Collections.Generic;

public class GameBoard : MonoBehaviour
{
const ushort CELL_COUNT_X = 10;
const ushort CELL_COUNT_Y = 24; // only 20 will be visible to player, but we will use 24
const ushort CELL_SIZE = 1;

GameObject brick;
List<GameObject> bricks = new List<GameObject>();
private Sprite brickSprite;
private Sprite wallSprite;
GameObject[] debugWallBricks = new GameObject[CELL_COUNT_X * CELL_COUNT_Y];
TetrisPiece fallingPiece;
const ushort BLOCKTYPE_COUNT = 7;

const short DEFAULT_POSITION_X = CELL_COUNT_X / 2 - 2;
const short DEFAULT_POSITION_Y = CELL_COUNT_Y - 4;

//bool[,] frozenCells = new bool[CELL_COUNT_X, CELL_COUNT_Y]; // ill use this to store record of all fixed/settled blocks no longer falling
FrozenPiece[,] frozenCells = new FrozenPiece[CELL_COUNT_X, CELL_COUNT_Y];
List<GameObject> frozenCellBricks = new List<GameObject>();

float dropTimer = 0f;
float dropTimerBaseSpeed = 1f;
float dropTimerSuperSpeed = 15f;
float dropDelay = 0.7f;
float moveTimer = 0f;
float moveToDropSpeedFactor = 5f;
float moveDelay; // this value depends on what value the dropDelay is and is set in Update
float rotTimer = 0f;
float rotDelay = 0.15f;


private void Start()
{
    brickSprite = Resources.Load<Sprite>("Tex/tetris_brick");
    wallSprite = Resources.Load<Sprite>("Tex/border_rounded");

    CreateDebugWall();
    MakeNewFallingPiece();

    for (int y = 0; y < frozenCells.GetLength(1); y++)
    {
        for (int x = 0; x < frozenCells.GetLength(0); x++)
        {
            FrozenPiece f = new FrozenPiece(Color.grey, false);
            f.isFilled = false;
            frozenCells[x,y] = f;
        }
    }
}

// i clear the visual board every frame and re-create a new brick, spriterenderer etc every frame (probably a shit way !) todo
void ClearBoard()
{
    foreach (GameObject go in bricks)
        Destroy(go);
    foreach (GameObject go in frozenCellBricks)
        Destroy(go);

}

void CreateDebugWall()
{
    int i = 0;
    for (int x = 0; x < CELL_COUNT_X; x++)
    {
        for (int y = 0; y < CELL_COUNT_Y; y++)
        {
            brick = new GameObject();
            brick.name = "Debug_Wall_Brick";
            brick.AddComponent<SpriteRenderer>();
            brick.GetComponent<SpriteRenderer>().sprite = wallSprite;
            brick.transform.position = new Vector2(x * CELL_SIZE, y * CELL_SIZE);
            brick.GetComponent<SpriteRenderer>().color = Color.grey;
            debugWallBricks[i] = brick;

        }
    }
}

void MakeNewFallingPiece()
{
    TetrisPiece.BlockType blockType = (TetrisPiece.BlockType)Random.Range(0, BLOCKTYPE_COUNT);
    dropTimer = 0f;
    fallingPiece = new TetrisPiece(blockType, DEFAULT_POSITION_X, DEFAULT_POSITION_Y);
    DrawFallingPiece();
}

void DropDown()
{
    // check cell directly below a block:
    for (int y = 0; y < fallingPiece.GetCurrentOrientation().orientations.GetLength(0); y++)
    {
        for (int x = 0; x < fallingPiece.GetCurrentOrientation().orientations.GetLength(0); x++)
        {
            if (fallingPiece.GetCurrentOrientation().orientations[y, x] == 1)
            {
                if (fallingPiece.pos_y + y == 0)
                {
                    Debug.Log("HIT FLOOR!");
                    ConvertFallingPieceToFrozenBricks();
                    return;
                }
                if (frozenCells[fallingPiece.pos_x + x, fallingPiece.pos_y + y - 1].isFilled == true)
                {
                    Debug.Log("HIT FROZEN CELLS!");
                    ConvertFallingPieceToFrozenBricks();
                    return;
                }
            }
        }
    }
    fallingPiece.pos_y--;
}

void MoveLeft()
{
    // check cell directly to left of a block:
    for (int y = 0; y < fallingPiece.GetCurrentOrientation().orientations.GetLength(0); y++)
    {
        for (int x = 0; x < fallingPiece.GetCurrentOrientation().orientations.GetLength(0); x++)
        {
            if (fallingPiece.GetCurrentOrientation().orientations[y, x] == 1)
            {
                if (fallingPiece.pos_x + x == 0)
                {
                    Debug.Log("hit side wall");
                    return;
                }
                if(frozenCells[fallingPiece.pos_x - 1 + x, fallingPiece.pos_y + y].isFilled == true)
                {
                    Debug.Log("tried moving left but there was a frozen brick");
                    return;
                }
            }
        }
    }
    fallingPiece.pos_x--;
}

void MoveRight()
{
    // check cell directly to left of a block:
    for (int y = 0; y < fallingPiece.GetCurrentOrientation().orientations.GetLength(0); y++)
    {
        for (int x = 0; x < fallingPiece.GetCurrentOrientation().orientations.GetLength(0); x++)
        {
            if (fallingPiece.GetCurrentOrientation().orientations[y, x] == 1)
            {
                if (fallingPiece.pos_x + x == CELL_COUNT_X - 1)
                {
                    Debug.Log("hit side wall");
                    return;
                }
                if (frozenCells[fallingPiece.pos_x + 1 + x, fallingPiece.pos_y + y].isFilled == true)
                {
                    Debug.Log("tried moving right but there was a frozen brick");
                    return;
                }
            }
        }
    }
    fallingPiece.pos_x++;
}

void RotatePositive()
{
    for (int y = 0; y < fallingPiece.GetCurrentOrientation().orientations.GetLength(0); y++)
    {
        for (int x = 0; x < fallingPiece.GetCurrentOrientation().orientations.GetLength(0); x++)
        {
            if (fallingPiece.GetNextOrientation().orientations[y, x] == 1)
            {
                if (fallingPiece.pos_x + x < 0)
                {
                    Debug.Log("tried rotation but hit a wall");
                    return;
                }
                if (fallingPiece.pos_x + x >= CELL_COUNT_X)
                {
                    Debug.Log("tried rotation but hit a wall");
                    return;
                }
                if (fallingPiece.pos_y + y == 0)
                {
                    Debug.Log("tried rotation but hit floor");
                    return;
                }
            }
        }
    }
    fallingPiece.GotoNextOrientation();
}

void ConvertFallingPieceToFrozenBricks()
{
    for (int y = 0; y < fallingPiece.GetCurrentOrientation().orientations.GetLength(0); y++)
    {
        for (int x = 0; x < fallingPiece.GetCurrentOrientation().orientations.GetLength(0); x++)
        {
            if (fallingPiece.GetCurrentOrientation().orientations[y,x] == 1)
                frozenCells[fallingPiece.pos_x + x, fallingPiece.pos_y + y] = new FrozenPiece(fallingPiece.color, true);
        }
    }
    fallingPiece = null;
}

void DrawFallingPiece()
{
    if (fallingPiece == null)
        return;

    for (int y = 0; y < fallingPiece.GetCurrentOrientation().orientations.GetLength(0); y++)
    {
        for (int x = 0; x < fallingPiece.GetCurrentOrientation().orientations.GetLength(0); x++)
        {
            if (fallingPiece.GetCurrentOrientation().orientations[y, x] == 1)
            {
                brick = new GameObject();
                brick.name = "TetrisPiece_" + fallingPiece.blockType;
                brick.AddComponent<SpriteRenderer>();
                brick.GetComponent<SpriteRenderer>().sprite = brickSprite;
                brick.transform.position = new Vector2((fallingPiece.pos_x + x) * CELL_SIZE, (fallingPiece.pos_y + y) * CELL_SIZE);
                brick.GetComponent<SpriteRenderer>().color = fallingPiece.color;
                bricks.Add(brick);
            }
        }
    }
}

void DrawFrozenBricks()
{
    for (int x = 0; x < frozenCells.GetLength(0); x++)
    {
        for (int y = 0; y < frozenCells.GetLength(1); y++)
        {
            if (frozenCells[x, y].isFilled == true)
            {
                brick = new GameObject();
                brick.name = "Frozen Cell Brick";
                brick.AddComponent<SpriteRenderer>();
                brick.GetComponent<SpriteRenderer>().sprite = brickSprite;
                brick.transform.position = new Vector2(x * CELL_SIZE, y * CELL_SIZE);
                brick.GetComponent<SpriteRenderer>().color = frozenCells[x,y].color;
                frozenCellBricks.Add(brick);
            }
        }
    }
}

void HandleMovementAndBlockCreation()
{
    float input_x = Input.GetAxis("Horizontal");
    float input_y = Input.GetAxis("Vertical");
    bool rotateButton = Input.GetButtonDown("Rotate_Positive");
    moveDelay = dropDelay / moveToDropSpeedFactor;

    moveTimer += Time.deltaTime;
    rotTimer += Time.deltaTime;

    if (fallingPiece != null)
    {
        if (input_y < 0)
            dropTimer += dropTimerSuperSpeed * Time.deltaTime;
        else
            dropTimer += dropTimerBaseSpeed * Time.deltaTime;


        if (dropTimer >= dropDelay)
        {
            DropDown();
            dropTimer = 0f;
        }
        else
        {
            if (moveTimer >= moveDelay)
            {
                moveTimer = 0f;

                if (input_x < 0)
                    MoveLeft();
                else if (input_x > 0)
                    MoveRight();
            }
            if (rotateButton)
                RotatePositive();
        }
    }
    else
    {
        MakeNewFallingPiece();
    }
}

private void Update()
{
    ClearBoard();

    HandleMovementAndBlockCreation();



    DrawFallingPiece();
    DrawFrozenBricks();

}
}

public class TetrisPiece
{
public enum BlockType { A, B, C, D, E, F, G };
public BlockType blockType;
private Orientation[] possibleOrientations;
private int currentOrientationIndex = 0;
public short pos_x, pos_y;
public Color color;

public TetrisPiece(BlockType blockType, short PosX, short PosY)
{
    pos_x = PosX;
    pos_y = PosY;

    this.blockType = blockType;
    switch (blockType)
    {
        case BlockType.A:
            color = Color.red;
            possibleOrientations = new Orientation[2];
            possibleOrientations[0] = new Orientation(new int[4, 4] { { 0, 1, 0, 0 }, { 0, 1, 0, 0 }, { 0, 1, 0, 0 }, { 0, 1, 0, 0 } });
            possibleOrientations[1] = new Orientation(new int[4, 4] { { 0, 0, 0, 0 }, { 1, 1, 1, 1 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } });
            break;
        case BlockType.B:
            color = Color.blue;
            possibleOrientations = new Orientation[1];
            possibleOrientations[0] = new Orientation(new int[4, 4] { { 0, 0, 0, 0 }, { 0, 1, 1, 0 }, { 0, 1, 1, 0 }, { 0, 0, 0, 0 } });
            break;
        case BlockType.C:
            color = Color.green;
            possibleOrientations = new Orientation[4];
            possibleOrientations[0] = new Orientation(new int[4, 4] { { 0, 0, 0, 0 }, { 0, 1, 0, 0 }, { 1, 1, 1, 0 }, { 0, 0, 0, 0 } });
            possibleOrientations[1] = new Orientation(new int[4, 4] { { 0, 0, 0, 0 }, { 0, 1, 0, 0 }, { 1, 1, 0, 0 }, { 0, 1, 0, 0 } });
            possibleOrientations[2] = new Orientation(new int[4, 4] { { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 1, 1, 1, 0 }, { 0, 1, 0, 0 } });
            possibleOrientations[3] = new Orientation(new int[4, 4] { { 0, 0, 0, 0 }, { 0, 1, 0, 0 }, { 0, 1, 1, 0 }, { 0, 1, 0, 0 } });
            break;
        case BlockType.D:
            color = Color.cyan;
            possibleOrientations = new Orientation[2];
            possibleOrientations[0] = new Orientation(new int[4, 4] { { 0, 0, 0, 0 }, { 0, 0, 1, 0 }, { 0, 1, 1, 0 }, { 0, 1, 0, 0 } });
            possibleOrientations[1] = new Orientation(new int[4, 4] { { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 1, 1, 0, 0 }, { 0, 1, 1, 0 } });
            break;
        case BlockType.E:
            color = ColorTools.Color255(128f, 41f, 11f); // brown
            possibleOrientations = new Orientation[2];
            possibleOrientations[0] = new Orientation(new int[4, 4] { { 0, 0, 0, 0 }, { 0, 1, 0, 0 }, { 0, 1, 1, 0 }, { 0, 0, 1, 0 } });
            possibleOrientations[1] = new Orientation(new int[4, 4] { { 0, 0, 0, 0 }, { 0, 0, 1, 1 }, { 0, 1, 1, 0 }, { 0, 0, 0, 0 } });
            break;
        case BlockType.F:
            color = ColorTools.Color255(255f, 255f, 0f); // yellow
            possibleOrientations = new Orientation[4];
            possibleOrientations[0] = new Orientation(new int[4, 4] { { 0, 0, 0, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 1, 1, 0 } });
            possibleOrientations[1] = new Orientation(new int[4, 4] { { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 1, 1, 1 }, { 0, 0, 0, 1 } });
            possibleOrientations[2] = new Orientation(new int[4, 4] { { 0, 0, 0, 0 }, { 0, 1, 1, 0 }, { 0, 1, 0, 0 }, { 0, 1, 0, 0 } });
            possibleOrientations[3] = new Orientation(new int[4, 4] { { 0, 0, 0, 0 }, { 0, 1, 0, 0 }, { 0, 1, 1, 1}, { 0, 0, 0, 0 } });
            break;
        case BlockType.G:
            color = ColorTools.Color255(128f, 0f, 128f); // purple
            possibleOrientations = new Orientation[4];
            possibleOrientations[0] = new Orientation(new int[4, 4] { { 0, 0, 0, 0 }, { 0, 1, 0, 0 }, { 0, 1, 0, 0 }, { 0, 1, 1, 0 } });
            possibleOrientations[1] = new Orientation(new int[4, 4] { { 0, 0, 0, 0 }, { 0, 0, 1, 0 }, { 1, 1, 1, 0 }, { 0, 0, 0, 0 } });
            possibleOrientations[2] = new Orientation(new int[4, 4] { { 0, 0, 0, 0 }, { 1, 1, 0, 0 }, { 0, 1, 0, 0 }, { 0, 1, 0, 0 } });
            possibleOrientations[3] = new Orientation(new int[4, 4] { { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 1, 1, 1, 0 }, { 1, 0, 0, 0 } });
            break;
    }
}


public Orientation GetCurrentOrientation()
{
    return possibleOrientations[currentOrientationIndex];
}

public Orientation GetNextOrientation()
{
    Debug.Log("index = " + currentOrientationIndex);
    if (possibleOrientations.Length == 1)
        return possibleOrientations[0];
    if (currentOrientationIndex == possibleOrientations.Length - 1)
        return possibleOrientations[0];
    else
        return possibleOrientations[currentOrientationIndex + 1];
}

public void GotoNextOrientation()
{
    currentOrientationIndex++;
    if (currentOrientationIndex >= possibleOrientations.Length)
        currentOrientationIndex = 0;
}
}

 public struct Orientation
 {
public int[,] orientations;

public Orientation(int[,] Orientations)
{
    orientations = Orientations;
}
}

public class FrozenPiece
{
public Color color;
public bool isFilled = false;

public FrozenPiece(Color Color, bool IsFilled)
{
    color = Color;
    isFilled = IsFilled;
}
}

public static class ColorTools
{
public static Color Color255(float r, float g, float b)
{
    return new Color(r / 255f, g / 255f, b / 255f);
}
public static Color Color255_Alpha(float r, float g, float b, float a)
{
    return new Color(r / 255f, g / 255f, b / 255f, a / 255f);
}
}