using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using NUnit.Framework;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.SceneManagement;
using UnityEngine.TestTools;
using UnityEngine.UI;

public class CreateNewSceneTest
{
    private static bool _previousTestCompleted = false;
    [UnityTest]
    public static IEnumerator RunTestsSequentially()
    {

        //MenuScript menuScript = GameObject.FindObjectOfType<MenuScript>();
        //Assert.IsNotNull(menuScript, "Expecting MenuScript Reference");

        // Load New Scene
        yield return SceneManager.LoadSceneAsync("Ciemetric");

        //
        // check if library loads without error
        // would like to implement a for loop of all our client
        _previousTestCompleted = false;
        yield return Test_1_LibraryLoadedWithinTimeLimit();

        // after library are loaded, press the play button

        if (_previousTestCompleted)
        {
            _previousTestCompleted = false;
            yield return Test_2_PressPlay();
        }

        // In the room selection Menu
        // select room1
        if (_previousTestCompleted)
        {
            _previousTestCompleted = false;
            yield return Test_3_ChooseRoom();
        }

        if (_previousTestCompleted)
        {
            _previousTestCompleted = false;
            yield return Test_4_PlaceAnObject();
        }
    }


    static IEnumerator Test_1_LibraryLoadedWithinTimeLimit()
    {
        // float duration = 60f;
        // do
        // {
        //     yield return null;
        //     duration -= Time.deltaTime;
        // }
        // while (duration >= 0 && !MenuScript.IsReady());

        //Assert.IsTrue(MenuScript.IsReady(), "Library Loaded Successfully");
        yield return null;
        _previousTestCompleted = true;
    }
    static IEnumerator Test_2_PressPlay()
    {
        // Give time for colors to load on menu
        yield return new WaitForSeconds(2);
        //TestPressPlayButton();
        yield return null;
        //TestOpenRoomPanel();
        yield return null;
        _previousTestCompleted = true;
    }
    static IEnumerator Test_3_ChooseRoom()
    {

        //TestGoBackToMenu();
        yield return null;
        //TestPressPlayButton();
        yield return null;
        //TestOpenRoomPanel();
        yield return null;
        //TestSelectARoom();

        // Test Height changes

        // Test Clicking over all room options

        // Test Opening and closing Tooltips

        // Test Create 3D
        //TestCreate3D();


        yield return null;
        _previousTestCompleted = true;
    }
    static IEnumerator Test_4_PlaceAnObject()
    {
        // Find required game objects
        GameObject buttonLeft = GameObject.Find("BTN_LEFT");
        Assert.IsNotNull(buttonLeft, "Expect BTN_LEFT Reference");

        GameObject cabinetButtonGameObject = GameObject.Find("CABINET");
        Assert.IsNotNull(cabinetButtonGameObject, "Expect CABINET Reference");

        // press cabinet button on left side
        // Create a new pointer event data
        PointerEventData pointerEventData = new PointerEventData(EventSystem.current);

        // Click cabinet button
        cabinetButtonGameObject.GetComponent<Button>().onClick.Invoke();
        cabinetButtonGameObject.GetComponent<EventTrigger>().OnPointerClick(pointerEventData);
        yield return new WaitForEndOfFrame(); // Wait for UI update

        GameObject cabinetPanel = GameObject.Find("Canvas/Panel_SCENE/MAIN BTN/PNL_TAB/CABINETPNL");
        Assert.IsNotNull(cabinetPanel, "Expect CABINETPNL Reference");

        // Test each category of cabinet
        List<GameObject> activeCabinetCategories = GetActiveCategories(cabinetPanel);
        foreach (GameObject category in activeCabinetCategories)
        {
            yield return TestCabinetCategory(category, pointerEventData);
            yield return new WaitForEndOfFrame(); // Wait for UI update
        }

        Debug.Log("Test Over");
        _previousTestCompleted = true;
    }

    static List<GameObject> GetActiveCategories(GameObject cabinetPanel)
    {
        List<GameObject> activeCategories = new List<GameObject>();
        Transform icons = cabinetPanel.transform.Find("Icons");

        for (int i = 0; i < icons.childCount; i++)
        {
            GameObject child = icons.GetChild(i).gameObject;
            if (child.activeSelf && !IsExcludedCategory(child.name))
            {
                activeCategories.Add(child);
            }
        }

        return activeCategories;
    }

    static bool IsExcludedCategory(string categoryName)
    {
        string[] excludedCategories = { "BED", "CREATE", "DECO", "PANEL" };
        return excludedCategories.Contains(categoryName);
    }

    static IEnumerator TestCabinetCategory(GameObject category, PointerEventData pointerEventData)
    {
        // // Click category button
        // category.GetComponent<Button>().onClick.Invoke();
        // category.GetComponent<EventTrigger>().OnPointerClick(pointerEventData);
        // yield return new WaitForEndOfFrame(); // Wait for UI update

        // // Assert cabinet panel is active
        // GameObject cabinetPanel = GameObject.Find("Canvas/Panel_SCENE/PNL/CABINETpnl");
        // Assert.IsNotNull(cabinetPanel, "CabinetPnl should have a reference");

        // // Test filters
        // Transform filters = cabinetPanel.transform.Find("FILTERS");
        // Assert.IsNotNull(filters, "Filters should have a reference");

        // Transform content = filters.Find("Viewport").Find("Content");
        // Assert.IsNotNull(content, "Content should have a reference");

        // int filterCount = content.childCount;
        // for (int i = 0; i < filterCount; i++)
        // {
        //     if (!cabinetPanel.activeSelf)
        //     {
        //         category.GetComponent<Button>().onClick.Invoke();
        //         category.GetComponent<EventTrigger>().OnPointerClick(pointerEventData);
        //         yield return new WaitForEndOfFrame(); // Wait for UI update
        //     }

        //     GameObject filter = content.GetChild(i).gameObject;
        //     // Click filter
        //     filter.GetComponent<EventTrigger>().OnPointerClick(pointerEventData);
        //     filter.GetComponent<Toggle>().isOn = true; // Toggle the filter on
        //     yield return new WaitForEndOfFrame(); // Wait for UI update

        //     // Assert sub-filters
        //     Transform subFilters = cabinetPanel.transform.Find("SUB_FILTERS");
        //     Assert.IsNotNull(subFilters, "SubFilters should have a reference");

        //     Transform subFiltersContent = subFilters.Find("Viewport").Find("Content");
        //     Assert.IsNotNull(subFiltersContent, "SubFilters Content should have a reference");

        //     int subFilterCount = subFiltersContent.childCount;
        //     for (int j = 0; j < subFilterCount; j++)
        //     {
        //         if (!cabinetPanel.activeSelf)
        //         {
        //             category.GetComponent<Button>().onClick.Invoke();
        //             category.GetComponent<EventTrigger>().OnPointerClick(pointerEventData);
        //             yield return new WaitForEndOfFrame(); // Wait for UI update
        //             filter = content.GetChild(i).gameObject;
        //             filter.GetComponent<EventTrigger>().OnPointerClick(pointerEventData);
        //             filter.GetComponent<Toggle>().isOn = true; // Toggle the filter on
        //             yield return new WaitForEndOfFrame(); // Wait for UI update
        //         }

        //         GameObject subFilter = subFiltersContent.GetChild(j).gameObject;
        //         // Click sub-filter
        //         subFilter.GetComponent<EventTrigger>().OnPointerClick(pointerEventData);
        //         subFilter.GetComponent<Toggle>().isOn = true; // Toggle the sub-filter on
        //         yield return new WaitForEndOfFrame(); // Wait for UI update

        //         // Assert models
        //         Transform cabinetModel = cabinetPanel.transform.Find("CABMODEL");
        //         Assert.IsNotNull(cabinetModel, "CabinetModel should have a reference");

        //         Transform modelContent = cabinetModel.Find("Viewport").Find("Content");
        //         Assert.IsNotNull(modelContent, "Model Content should have a reference");

        //         int modelCount = modelContent.childCount;
        //         for (int k = 0; k < modelCount; k++)
        //         {
        //             if (!cabinetPanel.activeSelf)
        //             {
        //                 category.GetComponent<Button>().onClick.Invoke();
        //                 category.GetComponent<EventTrigger>().OnPointerClick(pointerEventData);
        //                 yield return new WaitForEndOfFrame(); // Wait for UI update
        //                 filter = content.GetChild(i).gameObject;
        //                 filter.GetComponent<EventTrigger>().OnPointerClick(pointerEventData);
        //                 filter.GetComponent<Toggle>().isOn = true; // Toggle the filter on
        //                 yield return new WaitForEndOfFrame(); // Wait for UI update

        //                 subFilter = subFiltersContent.GetChild(j).gameObject;
        //                 subFilter.GetComponent<EventTrigger>().OnPointerClick(pointerEventData);
        //                 subFilter.GetComponent<Toggle>().isOn = true; // Toggle the sub-filter on
        //                 yield return new WaitForEndOfFrame(); // Wait for UI update
        //             }

        //             GameObject model = modelContent.GetChild(k).gameObject;
        //             Debug.Log($"TEST  for {model} starting!");
        //             model.GetComponent<EventTrigger>().OnPointerClick(pointerEventData);
        //             model.GetComponent<Toggle>().isOn = true;
        //             //Debug.Log($"TEST  Selecting Cabinet {model}");
        //             yield return new WaitForEndOfFrame(); // Wait for UI update


        //             Transform ShowSelection = cabinetPanel.transform.Find("SHOWSELECTION");
        //             Assert.IsNotNull(ShowSelection, $" ShowSelection GameObject should have a reference");
        //             //Debug.Log($"TEST found SHOWSELECTION");
        //             // Press hammer
        //             Transform hammer = ShowSelection.Find("ADD");
        //             Assert.IsNotNull(hammer, $" add GameObject should have a reference");

        //             //Debug.Log($"TEST found ADD");
        //             Button AddButton = hammer.GetComponent<Button>();
        //             Assert.IsNotNull(AddButton, $" add GameObject should have a button reference");

        //             Debug.Log($"TEST found ButtonAdd");
        //             AddButton.onClick.Invoke();
        //             Debug.Log($"TEST clicked ButtonAdd");
        //             yield return new WaitForEndOfFrame(); // Wait for UI update

        //             HitObject.HandleInstall(true);

        //             // Need to select the new created object
        //             GameObject obj = SceneModeManager.GetObjectInScene(_G.OBJs[_G.OBJnum - 1][0]).gameObject;
        //             Assert.IsNotNull(obj, $" add obj should have a reference");
        //             MoveObject moveObject = obj.GetComponent<MoveObject>();
        //             Assert.IsNotNull(moveObject, $" Expecting a moveObject GameObject reference");

        //             Assert.IsTrue(model.name == _G.OBJs[_G.OBJnum - 1][1], $"Was expecting value to be equal to {model.name} but other value was {_G.OBJs[_G.OBJnum - 1][1]}");
        //             moveObject.OnMouseDownEventAfterProtection();
        //             Assert.IsTrue(SceneModeManager.Selected == obj, $" Expecting a Selected GameObject to be the same as current moveobject reference");
        //             Assert.IsTrue(SceneModeManager.Scene.childCount == 1, $"Scene Gameobject should have only 1 child at this point but got {SceneModeManager.Scene.childCount}");
        //             yield return new WaitForEndOfFrame(); // Wait for UI update

        //            // yield return new WaitForSeconds(3);
        //             // Get access to garbage button
        //             GameObject btnBasket = GameObject.Find("Canvas/HIDER/CONTROL/BTNGROUP/btnBASKET");
        //             Assert.IsNotNull(btnBasket, $" Expecting a garbage GameObject reference");
        //             Button btnBacketButton = btnBasket.GetComponent<Button>();
        //             Assert.IsNotNull(btnBacketButton, $" Expecting a btnBacketButton Button reference");
        //             btnBacketButton.onClick.Invoke();
        //             btnBacketButton.GetComponent<EventTrigger>().OnPointerClick(pointerEventData);
        //             //yield return new WaitForSeconds(3);
        //             yield return new WaitForEndOfFrame(); // Wait for UI update

        //             Assert.IsTrue(SceneModeManager.Scene.childCount == 0, $"Scene Gameobject should have 0 child at this point but got {SceneModeManager.Scene.childCount}");
        //             Debug.Log($"TEST  for {filter.name} {subFilter.name} {model.name} over!");
        //         }

        //         yield return new WaitForEndOfFrame(); // Wait for UI update
        //     }

            yield return new WaitForEndOfFrame(); // Wait for UI update
        //}
    }


    static void TestOpenRoomPanel()
    {
        // if (_P.DrawRoomRewrite)
        // {
        //     GameObject PanelPlan2D = GameObject.Find("Panel_DRAWPlan_NEW");
        //     Assert.IsNotNull(PanelPlan2D, "Expecting Panel_DRAWPlan_NEW Reference");
        //     Assert.IsTrue(PanelPlan2D.activeSelf, "Expecting for Panel_DRAWPlan_NEW to be active");
        // }
        // else
        // {
        //     GameObject PanelPlan2D = GameObject.Find("Panel_plan2d");
        //     Assert.IsNotNull(PanelPlan2D, "Expecting Panel_plan2d Reference");
        //     Assert.IsTrue(PanelPlan2D.activeSelf, "Expecting for Panel_plan2d to be active");
        // }
    }

    static void TestPressPlayButton()
    {
        GameObject PanelMain = GameObject.Find("Panel_main");
        Assert.IsNotNull(PanelMain, "Should have Panel_main reference");

        Transform playButtonGO = PanelMain.transform.Find("START");
        Assert.IsNotNull(playButtonGO, "Expected Start Game Object Reference");
        Button playButton = playButtonGO.GetComponent<Button>();
        Assert.IsNotNull(playButton, "Expecting a button Component on the START GameObject");

        // Create a new pointer event data
        PointerEventData pointerEventData = new PointerEventData(EventSystem.current);

        playButton.GetComponent<EventTrigger>().OnPointerClick(pointerEventData);
        Assert.IsTrue(!PanelMain.activeSelf, " Panel Main should be inactive");
    }
    static void TestSelectARoom()
    {
        // if (_P.DrawRoomRewrite)
        // {

        // }
        // else
        // {
        //     GameObject PanelPlan2D = GameObject.Find("Panel_plan2d");
        //     Assert.IsNotNull(PanelPlan2D, "Expecting Panel_plan2d Reference");

        //     Transform Room = PanelPlan2D.transform.Find("R1");
        //     Assert.IsNotNull(PanelPlan2D, "Expecting R1 Reference");

        //     Button RoomButton = Room.GetComponent<Button>();
        //     Assert.IsNotNull(RoomButton, "Expecting a button Component on the R1 GameObject");
        //     PointerEventData pointerEventData = new PointerEventData(EventSystem.current);
        //     BaseEventData baseEventData = new BaseEventData(EventSystem.current);
        //     EventSystem.current.SetSelectedGameObject(RoomButton.gameObject, baseEventData);
        //     RoomButton.GetComponent<EventTrigger>().OnPointerClick(pointerEventData);
        //     RoomButton.onClick.Invoke();
        // }
    }

    static void TestCreate3D()
    {
        // if (_P.DrawRoomRewrite)
        // {
        //     GameObject PanelPlan2D = GameObject.Find("Panel_DRAWPlan_NEW");
        //     Assert.IsNotNull(PanelPlan2D, "Expecting Panel_DRAWPlan_NEW Reference");
        //     Assert.IsTrue(PanelPlan2D.activeSelf, "Expecting for Panel_DRAWPlan_NEW to be active");

        //     GameObject gameObject3D = GameObject.Find("3D");
        //     Assert.IsNotNull(gameObject3D, "Should have 3D reference");

        //     Button button3D = gameObject3D.GetComponent<Button>();
        //     Assert.IsNotNull(button3D, "Expecting a button Component on the 3D GameObject");

        //     // Create a new pointer event data
        //     PointerEventData pointerEventData = new PointerEventData(EventSystem.current);

        //     button3D.GetComponent<EventTrigger>().OnPointerClick(pointerEventData);
        //     button3D.onClick.Invoke();

        //     Assert.IsTrue(!PanelPlan2D.activeSelf, "Expecting for Panel_DRAWPlan_NEW to be inactive");
        // }
        // else
        // {

       // }
    }

    static void TestGoBackToMenu()
    {
        // Test Going back to main menu and come back to selecting a room
        GameObject backToStart = GameObject.Find("Back to START");
        Assert.IsNotNull(backToStart, "Expecting Back to START Reference");

        Button backToStartButton = backToStart.GetComponent<Button>();
        Assert.IsNotNull(backToStartButton, "Expecting a button reference for Back to  Start GameObject");

        backToStartButton.onClick.Invoke();
    }

    [TearDown]
    public static void Cleanup()
    {
        //SceneManager.UnloadScene("Udesignit 01");
    }
}