using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using TMPro;

public class SudokuManage : MonoBehaviour
{
    public SoundManage soundManage;

    private WaveFuncSudoku s;
    // 存储命令链
    private Stack<Command> commands = new Stack<Command>();

    // 各种Tile的对象
    private TextMeshProUGUI[,] nums = new TextMeshProUGUI[9, 9];
    private Transform[,,] miniTiles = new Transform[9, 9, 9];
    private Vector3[,] TilePos = new Vector3[9, 9];
    private Vector3[] miniTilePos = new Vector3[9];

    // 数字选择面板的对象
    private GameObject DigitalSelection;
    private GameObject[] NumButton = new GameObject[9];

    private UIAnim uiAnim;

    // 控制游戏暂停
    private bool isPause = false;
    private bool isWin = false;

    void Start()
    {
        // UI动画
        uiAnim = new UIAnim(this);

        #region 获取数独Tile数字对象和miniTile对象
        for (int i = 0; i < 9; i++)
            for (int j = 0; j < 9; j++)
            {
                // 获取Tile字符对象
                var tile = transform.Find("Tiles").GetChild(i).GetChild(j).transform;
                nums[i, j] = tile.Find("Image").Find("Text (TMP)").GetComponent<TextMeshProUGUI>();
                // 获取Tile初始位置
                TilePos[i, j] = new Vector3(tile.position.x, tile.position.y, 0);

                // 获取miniTile对象
                for (int l = 0; l < 9; l++)
                {
                    miniTiles[i, j, l] = tile.Find("MiniTile").GetChild(l).transform;
                }
            }
        
        // 获取miniTile初始位置
        for (int i = 0; i < 9; i++)
            miniTilePos[i] = new Vector3(miniTiles[0, 0, i].localPosition.x, miniTiles[0, 0, i].localPosition.y, 0);
        #endregion

        #region 注册每个格子的事件
        for (int i = 0; i < 9; i++) 
        { 
            var row = transform.Find("Tiles").GetChild(i).transform;
            for (int j = 0; j < 9; j++) 
            { 
                var tile = row.GetChild(j).transform;
                WaveFuncSudoku.Coordinates c = new WaveFuncSudoku.Coordinates(i, j);
                tile.Find("Button").GetComponent<Button>().onClick.AddListener(
                        () =>
                        {
                            soundManage.PlayButton();
                            NumButtonClick(row, tile, c);
                        }
                    );
            }
        }
        #endregion

        #region 数字选择面板
        DigitalSelection = transform.Find("Tiles").Find("DigitalSelection").gameObject;
        DigitalSelection.transform.Find("BackButton").GetComponent<Button>().onClick.AddListener(
                () =>
                {
                    soundManage.PlayButton();
                    uiAnim.CloseWindow(DigitalSelection);
                }
            );
        for (int i = 0; i < 9; i++)
        {
            NumButton[i] = DigitalSelection.transform.Find("NumButton").GetChild(i).gameObject;
            int num = i;
            NumButton[i].GetComponent<Button>().onClick.AddListener(
                    () =>
                    {
                        soundManage.PlayButton();
                        WaveFuncSudoku.Coordinates c = DigitalSelection.GetComponent<DigitalSelectionRecords>().c;
                        Command select = new NumSelect(s, num + 1, c, this);
                        select.execute();
                        // 加入命令链
                        commands.Push(select);
                        // 判断胜利
                        if (s.IsWin()) isWin = true;

                        uiAnim.CloseWindow(DigitalSelection);
                    }
                );
        }
        #endregion

        // 初始化数独
        InitSudoku();
    }
    // Tile按键事件
    private void NumButtonClick(Transform row, Transform tile, WaveFuncSudoku.Coordinates c)
    {
        // 点击非固定格子操作有效
        if (!isPause && SudokuCreate.currentSudoku[c.x, c.y] == 0)
        {
            // 点击空格子打开数字选择面板
            if (s.sudoku[c.x, c.y].currentNum == 0)
            {
                for (int l = 0; l < 9; l++)
                    if (s.sudoku[c.x, c.y].GetPossible().Contains(l + 1))
                        NumButton[l].SetActive(true);
                    else
                        NumButton[l].SetActive(false);

                float x = tile.localPosition.x >= 0 ?
                            (tile.localPosition.x > 450f ? 450f : tile.localPosition.x) :
                            (tile.localPosition.x < -450f ? -450f : tile.localPosition.x);
                float y = row.localPosition.y >= 0 ?
                            (row.localPosition.y > 337.5f ? 337.5f : row.localPosition.y) :
                            (row.localPosition.y < -337.5f ? -337.5f : row.localPosition.y);
                DigitalSelection.transform.GetChild(1).localPosition = new Vector3(x, y);
                DigitalSelection.GetComponent<DigitalSelectionRecords>().c = c;
                uiAnim.OpenWindow(DigitalSelection);
            }
            // 点击有数字的格子取消数字
            else
            {
                Command select = new NumSelect(s, 0, c, this);
                select.execute();
                // 加入命令链
                commands.Push(select);
            }
        }
    }
    // 初始化数独
    private void InitSudoku()
    {
        // 新建数独
        s = new WaveFuncSudoku(SudokuCreate.currentSudoku);

        // 修改非固定数字颜色
        for (int i = 0; i < 9; i++)
            for (int j = 0; j < 9; j++)
                
                if (SudokuCreate.currentSudoku[i, j] == 0)
                    nums[i, j].color = new Color(9 / 255f, 209 / 255f, 191 / 255f);
                else
                    nums[i, j].color = Color.black;

        UpdateSudokuBoard(true);
    }
    // 更新数独面板
    public void UpdateSudokuBoard(bool isInit = false)
    {
        for (int i = 0; i < 9; i++)
        {
            for (int j = 0; j < 9; j++)
            {
                // 读取显示的数字
                nums[i, j].text = s.sudoku[i, j].currentNum != 0 ? s.sudoku[i, j].currentNum.ToString() : "";

                // 设置miniTile对象位置
                var passible = s.sudoku[i, j].GetPossible();
                for (int l = 0; l < 9; l++)
                {
                    // 初始化不需要动画
                    if (!isInit)
                    {
                        //掉落动画与还原
                        if (IsReturnMiniTile(new WaveFuncSudoku.Coordinates(i, j), l))
                        {
                            //miniTiles[i, j, l].gameObject.SetActive(true);
                            uiAnim.TileBack(miniTiles[i, j, l], 
                                TilePos[i, j].x + miniTilePos[l].x, 
                                TilePos[i, j].y + miniTilePos[l].y);
                        }
                        else if (IsOutMiniTile(new WaveFuncSudoku.Coordinates(i, j), l))
                        {
                            //miniTiles[i, j, l].gameObject.SetActive(false);
                            uiAnim.TileFalldown(miniTiles[i, j, l]);
                        }
                    }
                    else
                    {
                        if (!passible.Contains(l + 1))
                        {
                            miniTiles[i, j, l].gameObject.SetActive(false);
                        }

                        else
                        {
                            miniTiles[i, j, l].gameObject.SetActive(true);
                        }
                    }
                }
            }
        }
    }
    // 判断miniTile是否属于回归
    private bool IsReturnMiniTile(WaveFuncSudoku.Coordinates c, int num)
    {
        if (!miniTiles[c.x, c.y, num].gameObject.activeSelf)
        {
            if (s.sudoku[c.x, c.y].GetPossible().Contains(num + 1))
            {
                return true;
            }
        }

        return false;
    }
    // 判断miniTile是否脱落
    private bool IsOutMiniTile(WaveFuncSudoku.Coordinates c, int num)
    {
        if (miniTiles[c.x, c.y, num].gameObject.activeSelf)
        {
            if (!s.sudoku[c.x, c.y].GetPossible().Contains(num + 1))
            {
                return true;
            }
        }

        return false;
    }
    // 暂停游戏
    public void Pause()
    {
        isPause = true;
    }
    // 继续游戏
    public void Continue()
    {
        isPause = false;
    }
    // 重置数独
    public void Reset()
    {
        Command command = new Reset(s, this);
        command.execute();
        // 加入命令链
        commands.Push(command);
    }
    // 自动完成
    public void Auto()
    {
        Command command = new Auto(s, this);
        command.execute();
        // 加入命令链
        commands.Push(command);
    }
    // 撤销操作
    public void Undo()
    {
        if (commands.Count > 0)
        {
            commands.Pop().undo();
        }
    }
    public bool IsWin()
    {
        return isWin;
    }

    public void AutoExtrapolation()
    {
        s.AutoExtrapolation(false);
    }
    public void SetNum(WaveFuncSudoku.Coordinates c, int num)
    {
        s.SetTileNumber(c, num);
    }

    public void SetSudoku(WaveFuncSudoku s)
    {
        this.s = s;
    }

}
#region 命令模式控制游戏
interface Command
{
    void execute();
    void undo();
}

public class NumSelect : Command
{
    private int[,] last = new int[9, 9];
    private int now;
    private WaveFuncSudoku.Coordinates c;
    private SudokuManage current;

    public NumSelect(WaveFuncSudoku last, int now, WaveFuncSudoku.Coordinates c, SudokuManage current) 
    {
        this.last = last.ToArrays();
        this.now = now;
        this.c = c;
        this.current = current;
    }

    public void execute()
    {
        current.SetNum(c, now);
        current.UpdateSudokuBoard();
    }

    public void undo()
    {
        current.SetSudoku(new WaveFuncSudoku(last));
        current.UpdateSudokuBoard();
    }
}

public class Reset : Command
{
    private WaveFuncSudoku last;
    private SudokuManage current;

    public Reset(WaveFuncSudoku last, SudokuManage current)
    {
        this.last = last;
        this.current = current;
    }

    public void execute()
    {
        current.SetSudoku(new WaveFuncSudoku(SudokuCreate.currentSudoku));
        current.UpdateSudokuBoard();
    }

    public void undo()
    {
        current.SetSudoku(last);
        current.UpdateSudokuBoard();
    }
}

public class Auto : Command
{
    private int[,] last = new int[9, 9];
    private SudokuManage current;

    public Auto(WaveFuncSudoku last, SudokuManage current)
    {
        this.last = last.ToArrays();
        this.current = current;
    }

    public void execute()
    {
        current.AutoExtrapolation();
        current.UpdateSudokuBoard();
    }

    public void undo()
    {
        current.SetSudoku(new WaveFuncSudoku(last));
        current.UpdateSudokuBoard();
    }
}
#endregion