using TMPro;
using UnityEngine;

public class SceneModeManager : MonoBehaviour
{
    public static SceneModeManager Instance { get { return _instance; } }
    static SceneModeManager _instance;
    [SerializeField, HideInInspector] float _yOffset = 2f;
    public float YOffset {  get { return _yOffset; } }
    [SerializeField,HideInInspector] MoveHandles _moveHandles;
    //public GameObject SceneModeObject;
    [SerializeField, HideInInspector] TextMeshProUGUI _textSM;

    [SerializeField] SceneMode _currentSceneMode;

    public SceneModes _currentSM;
    public SceneModes _previousSM;
    SceneModes _tempSM;
    [Header("Debug Options")]
    [SerializeField] bool _showSceneModeText;
    public bool ShowSceneModeText { get { return _showSceneModeText; } }
    [SerializeField] bool _debugSceneMode;
    [SerializeField] bool _showInputValue;

    [Header("Room Reference")]
    // include wall, ceiling, floor
    [SerializeField] Transform _room;
    public static Transform Room 
    { 
        get 
        {
            if (_instance._room == null)
            {
                _instance._room = GameObject.Find("ROOM")?.transform;
            }
            if (_instance._room == null)
            {
                Debug.Log("_room is NULL");
            }

            return _instance._room; 
        } 
    }

    [SerializeField] Transform _scene;

    public static Transform Scene 
    { 
        get 
        {
            if (_instance._scene == null)
            {
                _instance._scene = GameObject.Find("SCENE")?.transform;
            }
            if (_instance._scene == null)
            {
                Debug.Log("_scene is NULL");
            }
            return _instance._scene; 
        } 
    }
    [SerializeField, HideInInspector] Transform _ceil;
    [SerializeField, HideInInspector] Transform _floor;
    public static Transform Ceil 
    { 
        get 
        {
            if (_instance._ceil == null)
            {
                _instance._ceil = Room.Find("ceil");
            }
            if (_instance._ceil == null)
            {
                Debug.Log("_ceil is NULL");
            }
            return _instance._ceil; 
        } 
    }
    [Header("Selected Reference")]
    //[SerializeField] GameObject _selected;
    //public GameObject Selected { get { return _selected; } }
    [SerializeField] string _selectedName;
    public static Transform Floor 
    { 
        get 
        {
            if (_instance._floor == null)
            {
                _instance._floor = Room.transform.Find("floor");
            }

            if (_instance._floor == null)
            {
                //Debug.Log("_floor is NULL");
            }
                return _instance._floor;
        } 
    }
    public static string SelectedName 
    { 
        get 
        { 
            return _instance._selectedName;
        }
        set
        {
            if (!string.IsNullOrEmpty(value))
            {
                if(_instance._selectedName != value)
                {
                    //Debug.Log($"new Selected Value {value}");
                    _instance._selectedName = value;
                }
                //else
                //{
                //    //Debug.Log("Same Selected Value");
                //}
            }
            else
            {
                //Debug.Log("Remove Selected");

                _instance._selectedName = "";
                MoveHandles.Instance?.HideAllHandles();
            }

            _instance.UpdateSelected();
        }
    }
    [SerializeField] GameObject _selected;
    public static GameObject Selected
    {
        get
        {
            _instance.UpdateSelected();

            return _instance._selected;
        }
    }
    RotatingState _rotationState;
    MovingState _movingState;
    NavigateState _navigateState;
    ReadyMoveState _readyMoveState;
    SlidingState _slidingState;
    EditState _editState;
    CopyingDoorState _CopyingDoorState;

    private void Awake()
    {
        //_textSM=SceneModeObject.GetComponent<TextMeshProUGUI>();
        _G.isExteriorWall=true;
        if (_instance == null)
        {
            _instance = this;
        }
        else
        {
            Destroy(this.gameObject);
        }
        _moveHandles?.Initialize();

        _rotationState = new RotatingState(this);
        _movingState = new MovingState(this);
        _navigateState = new NavigateState(this);
        _readyMoveState = new ReadyMoveState(this);
        _slidingState = new SlidingState(this);
        _editState = new EditState(this);
        _CopyingDoorState = new CopyingDoorState(this);

        if (_room == null)
        {
            _room = GameObject.Find("ROOM")?.transform;
        }
        if (_room != null)
        {
            if (_ceil == null)
            {
                _ceil = _room.transform.Find("ceil");
            }
            if (_floor == null)
            {
                _floor = _room.transform.Find("floor");
            }
        }
        if (_scene == null)
        {
            _scene = GameObject.Find("SCENE")?.transform;
        }
    }
    private void Update()
    {
        OnUpdate();
    }
    public void OnUpdate()
    {
        if (_currentSceneMode != null) { _currentSceneMode.OnStateUpdate(); }
    }
    public void SetNewState(SceneMode newState)
    {
        if (_currentSceneMode != null)
        {
            _currentSceneMode.OnStateExit();
        }

        _currentSceneMode = newState;

        if (_currentSceneMode != null)
        {
            _currentSceneMode.OnStateEnter();
        }
    }
    void UpdateSelected()
    {
        //_textSM=SceneModeObject.GetComponent<TextMeshProUGUI>();
        if (string.IsNullOrEmpty(_selectedName))
        {
            _selected = null;
            MoveHandles.Instance?.HideAllHandles();
            //Debug.Log("No Currently selected Gameobject");
            return;
        }
        else if(_selected != null && _selected.name == _selectedName)
        {
            //Debug.Log("Same Game Object, no need to change");
            return;
        }
        else
        {
            //Debug.Log("needed to change the selected");
            Transform obj = GetObjectInScene(_selectedName);

            if (obj != null)
            {
                _selected = obj.gameObject;

                if (_selected.TryGetComponent<MeshRenderer>(out var selectedMeshRenderer))
                {
                    selectedMeshRenderer.material = _G.GGT;
                }

                return;
            }
        }
    }
    public static Transform GetObjectInScene(string objectName, bool notifyDebug = false)
    {
        Transform t = _instance._scene.Find(objectName);
        if (t == null)
        {
            if (notifyDebug)
            {
                Debug.Log("Could not find object " + objectName + " in scene");
            }
            return null;
        }
        return t;
    }
    
    public static Transform GetObjectInRoom(string objectName, bool notifyDebug = false)
    {
        //print("objectName===="+objectName);
        Transform t = _instance._room.Find(objectName);
        if (t == null)
        {
            if (notifyDebug)
            {
                Debug.Log("Could not find object " + objectName + " in room");
            }
            return null;
        }

        return t;
    }

    public void SetSceneModeVisibility()
    {
        // _textSM=SceneModeObject.GetComponent<TextMeshProUGUI>();
        // bool show = false;
        // var color = _textSM.color;
        // #if UNITY_EDITOR
        //         //show = showSceneModeText;
        // #elif UNITY_WEBGL
        //         show = false;
        // #else 
        //         show = false;
        // #endif
        //         color.a = show ? 1 : 0;
        //         _textSM.color = color;
    }
    private void OnValidate()
    {
        SetSceneModeVisibility();
    }
    public void SetSceneModeVisibility(bool value)
    {
        _showSceneModeText = value;
        var color = _textSM.color;
        color.a = _showSceneModeText ? 1 : 0;
        _textSM.color = color;
    }
    public void SetSceneMode(string sceneMode)
    {
        _textSM.text = sceneMode.ToString();

        if (_showSceneModeText && _debugSceneMode)
        {
            Debug.Log("Scene Mode == " + sceneMode);
        }
    }
    public void SetInputValue(string value)
    {
        if (_showInputValue)
        {
            _textSM.text = value.ToString();
        }
    }
    public void SetSceneMode(SceneModes sceneMode)
    {
        if (CompareSceneMode(sceneMode))
        {
            if (!CompareSceneMode(SceneModes.ReadyMove))
            {
                return;
            }
        }

        if (_debugSceneMode)
        {
            //Debug.Log("Scene Mode == " + sceneMode.ToString());
        }

        SceneMode newState = null;
        switch (sceneMode)
        {
            case SceneModes.Start:
                break;
            case SceneModes.Panel:
                if (CompareSceneMode(SceneModes.Start))
                {
                    sceneMode = SceneModes.Start;
                }
                if (CompareSceneMode(SceneModes.SnapOn))
                {
                    sceneMode = SceneModes.SnapOn;
                }
                if (CompareSceneMode(SceneModes.Install))
                {
                    sceneMode = SceneModes.Install;
                }
                break;
            case SceneModes.Install:
                break;
            case SceneModes.InstallOnCab:
                break;
            case SceneModes.SnapOn:

                break;
            case SceneModes.Navigate:
                //DASH.RefreshLite();
                break;
            case SceneModes.Calcule:
                break;
            case SceneModes.Plan2D:
                break;
            case SceneModes.ZoomTouch:
                break;
            case SceneModes.ShowTips:
                break;
            case SceneModes.Paint:
                break;
            case SceneModes.Align:
                break;
            case SceneModes.Measure:
                break;
            case SceneModes.GroupMove:
                break;
            case SceneModes.Follow:
                break;
            case SceneModes.Hit:
                break;
            case SceneModes.Move:
                break;
            case SceneModes.MouseOut:
                break;
            case SceneModes.Button:
                break;
            case SceneModes.Ceramic:
                break;
            case SceneModes.CounterView:
                break;
            case SceneModes.Duplicate:
                break;
            case SceneModes.ReadyMove:
                newState = _readyMoveState;
                break;
            case SceneModes.CopyingDoor:
                newState = _CopyingDoorState;
                break;
            case SceneModes.MoveHandle:
                newState = _movingState;
                break;
            case SceneModes.RotationHandle:
                newState = _rotationState;
                break;
            case SceneModes.SlidingHandle:
                newState = _slidingState;
                break;
            case SceneModes.Cathedral:
                break;
            case SceneModes.EditingHandle:
                newState = _editState;
                break;
            case SceneModes.Ai:
                if (CompareSceneMode(SceneModes.Ai))
                {
                    sceneMode = SceneModes.Ai;
                    //newState = sceneMode;
                    }
                    break;
        }

        if (CompareSceneMode(sceneMode))
        {
            if (!CompareSceneMode(SceneModes.ReadyMove))
            {
                return;
            }
        }

        _previousSM = _currentSM;
        _currentSM = sceneMode;
        _textSM.text = sceneMode.ToString();

        SetNewState(newState);
    }
    public static bool CompareSceneMode(SceneModes sceneMode)
    {
        return _instance._currentSM == sceneMode ;
    }
    public SceneModes GetSceneMode()
    {
        return _currentSM;
    }
    public void OnMouseOut()
    {
        SetTempSM(_currentSM, SceneModes.MouseOut);
    }
    public void OnMouseIn()
    {
        //if (_tempSM == SceneModes.Navigate)
        //{
        //    _tempSM = SceneModes.Panel;
        //}

        SetSceneMode(_tempSM);
    }

    public void OnDashEnter()
    {
        SetTempSM(_currentSM, SceneModes.ShowTips);
    }
    public void OnDashExit()
    {
        //_G.SM = _tempSM;
        SetSceneMode(_tempSM);
    }
    public void SetTempSM(SceneModes tempState, SceneModes newState)
    {
        SetSceneMode(newState);

        if (tempState == SceneModes.MouseOut) return;
        if (tempState == newState) return;

        if (_debugSceneMode)
        {
            //Debug.Log("temp SM == " + tempState);
        }
        _tempSM = tempState;
    }
    public GameObject InstantiateFakeRotationHandle(GameObject original,Vector3 position, Quaternion rotation, Transform parent)
    {
        return Instantiate(original, position, rotation, parent);
    }
}