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

public class VaultedCeiling : MonoBehaviour
{
    static private VaultedCeiling _instance;
    static public VaultedCeiling Instance
    {
        get
        {
            if (_instance == null)
            {
                return Get.o4("Canvas", "Panel_SCENE", "PNL", "CEILINGpnl").GetComponent<VaultedCeiling>();
            }
            return _instance;
        }
    }

    [SerializeField] InputField inputA; // inner width (horizontal)
    [SerializeField] InputField inputB; // inner depth (vertical)
    [SerializeField] InputField inputC; // outer west
    [SerializeField] InputField inputD; // outer east
    [SerializeField] InputField inputE; // outer north
    [SerializeField] InputField inputF; // outer south
    [SerializeField] InputField inputH; // height

    float _vaultHeight; // H
    float _innerWidth; // A
    float _innerDepth; // B
    float _outerWest; // C
    float _outerEast; // D
    float _outerNorth; // E
    float _outerSouth; // F

    bool _wasModified;

    private void Awake()
    {
        if (_instance != null && _instance != this)
        {
            Debug.LogError($"Multiple instances of {nameof(VaultedCeiling)} class object found!");
        }
        else
        {
            InitInstance();
            //Debug.Log("awake vault");
        }
    }

    private void InitInstance()
    {
        _instance = this;

        //Transform uiCeil = transform.Find("Inputs");
        //inputA = uiCeil.Find("InputFieldA").GetComponent<InputField>();
        //inputB = uiCeil.Find("InputFieldB").GetComponent<InputField>();
        //inputC = uiCeil.Find("InputFieldC").GetComponent<InputField>();
        //inputD = uiCeil.Find("InputFieldD").GetComponent<InputField>();
        //inputE = uiCeil.Find("InputFieldE").GetComponent<InputField>();
        //inputF = uiCeil.Find("InputFieldF").GetComponent<InputField>();
        //inputH = uiCeil.Find("InputFieldH").GetComponent<InputField>();

        InitDefaultMeasures(); // TODO : load save file
    }

    //mesh creation
    // amount to create (check if relevant edges are 0 length) (only center matters?)
    // faces : 4 (pyramid), 4 (NS triangles, EW trapezes), 4 (EW triangles, NS trapezes), 5
    // vertices : 5 (pyramid), 6 (2 triangles, 2 trapezes), 8
    // AB == 0, A == 0, B == 0, AB > 0

    //get and set values
    // input(keypad/ui) link

    //update on room change

    //usage flow
    // button in plan 2d -> ui ceiling (input fields, ref image, ui handle buttons)

    //mvp
    // generate roof from preset ceiling values and room values

    //save file

    public void InitDefaultMeasures() // TODO : ignore if save file loaded
    {
        _vaultHeight = 30.0f;
        _innerWidth = _G.WIDE / 3.0f;
        _innerDepth = _G.DEPTH / 3.0f;
        _outerWest = _innerWidth;
        _outerEast = _innerWidth;
        _outerNorth = _innerDepth;
        _outerSouth = _innerDepth;
    }

    //interface
    // lettered inputs -> opens keypad -> sets temporary values?
    //  get temp values from input field? then reset/update on opening pnl again
    // buttons confirm, cancel, drag/handle
    // button panel in PLAN2DHandler/CanvasPlan/BTNS
    // panel in Canvas/Panel_SCENE/PNL/CEILINGpnl

    // used by PLAN2DHandler/CanvasPlan/BTNS/CEIL
    public void SetPanelActive(bool setActive)
    {
        // TODO
        // apply new values
        // cancel input values

        //Debug.Log("Vault panel set actice : " + setActive);

        gameObject.SetActive(setActive);

        if (setActive)
        {
            SceneModeManager.Instance.SetSceneMode(SceneModes.Panel);
            _G.PNL = "CeilingPNL";

            inputA.text = DOIT.CNs(_innerWidth);
            inputB.text = DOIT.CNs(_innerDepth);
            inputC.text = DOIT.CNs(_outerWest);
            inputD.text = DOIT.CNs(_outerEast);
            inputE.text = DOIT.CNs(_outerNorth);
            inputF.text = DOIT.CNs(_outerSouth);
            inputH.text = DOIT.CNs(_vaultHeight);
        }
        else if (_wasModified)
        {
            _innerWidth = DOIT.ConvertStringToNumber(inputA.text);
            _innerDepth = DOIT.ConvertStringToNumber(inputB.text);
            _outerWest = DOIT.ConvertStringToNumber(inputC.text);
            _outerEast = DOIT.ConvertStringToNumber(inputD.text);
            _outerNorth = DOIT.ConvertStringToNumber(inputE.text);
            _outerSouth = DOIT.ConvertStringToNumber(inputF.text);
            _vaultHeight = DOIT.ConvertStringToNumber(inputH.text);
        }

        _wasModified = false;
    }

    private void DisablePanel()
    {
        SetPanelActive(false);
    }

    public void SetMeasure()
    {
        _wasModified = true;
        //Debug.Log("vault mesure modified");
    }

    // used by CEILINGpnl/BTN/ADD
    public void CreateCeiling()
    {
        Transform room = GameObject.Find("ROOM").transform;
        var c = room.Find("ceil");
        if (c != null)
        {
            Destroy(c.gameObject);
        }
        //var sc = room.Find("sceil");
        //if (sc != null)
        //{
        //    Destroy(sc.gameObject);
        //}

        float widthStart = _G.WIDE / 2.0f; // X
        float heightStart = _G.HEIGHT / 2.0f; // Y
        float depthStart = _G.DEPTH / 2.0f; // Z

        Vector3 vertexOuterNE = new Vector3(+widthStart, heightStart, +depthStart);
        Vector3 vertexOuterSE = new Vector3(+widthStart, heightStart, -depthStart);
        Vector3 vertexOuterSW = new Vector3(-widthStart, heightStart, -depthStart);
        Vector3 vertexOuterNW = new Vector3(-widthStart, heightStart, +depthStart);

        Vector3 vertexInnerNE = vertexOuterNE + new Vector3(-_outerEast, _vaultHeight, -_outerNorth);
        Vector3 vertexInnerSE = vertexOuterSE + new Vector3(-_outerEast, _vaultHeight, +_outerSouth);
        Vector3 vertexInnerSW = vertexOuterSW + new Vector3(+_outerWest, _vaultHeight, +_outerSouth);
        Vector3 vertexInnerNW = vertexOuterNW + new Vector3(+_outerWest, _vaultHeight, -_outerNorth);

        //mesh
        // meshrenderer
        // material
        // meshfilter
        // mesh

        // vertices //
        // normals //
        // tangents //
        // uvs //
        // triangles //
        // meshfilter < mesh

        GameObject vaultedCeiling = new GameObject("ceil");

        MeshRenderer meshRenderer = vaultedCeiling.AddComponent<MeshRenderer>();
        meshRenderer.material = _G.ceilm;
        MeshFilter meshFilter = vaultedCeiling.AddComponent<MeshFilter>();
        Mesh mesh = new Mesh();

        Vector3[] vertices = new Vector3[]
        {
            vertexOuterNE, vertexOuterSE, vertexOuterSW, vertexOuterNW,
            vertexInnerNE, vertexInnerSE, vertexInnerSW, vertexInnerNW
        };
        mesh.vertices = vertices;

        int[] triangles = new int[]
        {
            // East
            0, 4, 1,
            1, 4, 5,
            // South
            1, 5, 2,
            2, 5, 6,
            // West
            2, 6, 3,
            3, 6, 7,
            // North
            3, 7, 0,
            0, 7, 4,
            // Center
            4, 6, 5,
            4, 7, 6
        };
        mesh.triangles = triangles;

        mesh.RecalculateNormals();
        mesh.RecalculateTangents();

        meshFilter.mesh = mesh;

        DOIT.SetSizeTex(vaultedCeiling, 48, 48, 0, 0, 0, 0, 0, 0); // UVs

        vaultedCeiling.tag = "ceilling"; // typo error 
        //vaultedCeiling.layer = 6;
        //meshRenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.TwoSided;
        vaultedCeiling.transform.SetParent(room);

        // ab first, scales the rest accordingly
        // cdef after, offsets others, keeping ab values if possible
    }
}