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

public class Recover : MonoBehaviour
{
    static string ColorID;
    static Vector3 OffsetPanelStart;
    static Vector3 OffsetPanelEnd;
    static int ADNnumber;
    public static void AddtoCabinetFromEditPNL(string GlobalNumberSelectedColor,string SideON)
    {
        bool isOnCover =true;
        if (GlobalNumberSelectedColor=="NONE")isOnCover =false;
        //ADNnumber et OffsetPanelStart doivent etre initialises ici aussi : SetParameters/AddToCabinet
        //s'en servent, sinon on travaille sur le cabinet du clic droit precedent.
        ADNnumber=Get.GetObjectIndex(SceneModeManager.SelectedName);
        OffsetPanelStart=GetPanelOffset();
        string ColorUniqueName = Get.o2("Panel_SCENE/PNL/EDITCABpnl/EDITOR/DropdownList","DropSelection1").GetComponent<TMP_Dropdown>().options[0].text;
        ColorID=UIT.GetIDByUnique_Name(Library.CabTexture,ColorUniqueName);
        string Coverfit=Get.o2("Panel_SCENE/PNL/EDITCABpnl/EDITOR/DropdownList","DropSelection2").GetComponent<TMP_Dropdown>().options[0].text;
        if(Coverfit!="No Match"){
            SetParameters(GetCoverIDFromUniqueName(Coverfit,SideON),SideON,isOnCover );
            AddToCabinet();
        }
        else{
            _M.PH(30,0,"ffffff",1,1);
        }    
     }
    public static void AddCoverFromRightClick(string SideON,bool isOnCover){
        ColorID=GetColorID();
        ADNnumber=Get.GetObjectIndex(SceneModeManager.SelectedName);
        print("ADNnumber====="+ADNnumber);
        OffsetPanelStart=GetPanelOffset();        
        if(SideON!="NONE"){
            string Coverfit=GetCoverfit(SideON);
            ////print("Coverfit====="+Coverfit);
            if(Coverfit!="No Match"){
                SetParameters(Coverfit,SideON,isOnCover);//Coverfit===ID de la ligne trouvee (pas le Unique_Name)
                AddToCabinet();
            }
            else{
                _M.PH(30,0,"ffffff",1,1);
            }
        }
        else {
            string[] ADN = GetADN();
            ADN[81]="0_0_0_0_0_0_0";
            SetCounterProjection("LEFT","0");
            SetCounterProjection("RIGHT","0");
            AddToCabinet();
        }
    }    
    public static void SetParameters(string CoverID,string SideON,bool isOnCover ){
        //////print("CoverID======"+CoverID);
        string Thickness=UIT.Value(Library.Panel,CoverID,Header.Thick);
        if(Thickness.Split("_").Length==3)Thickness=Thickness.Split("_")[1];
        int IndexRecover=GetIndexOfRecover();
        if(SideON=="LEFT"){IndexRecover=0;}
        if(_G.PATH=="free"){CoverID="P1";}
        string PanelCode=CoverID+"?"+ColorID+"?"+Thickness;

        if(isOnCover) {
            SetNewValueOnCoverRecipe(IndexRecover, PanelCode);
            SetCounterProjection(SideON,"1");
            }
        else  {
            PanelCode="0";
            SetNewValueOnCoverRecipe(0, PanelCode);
            SetNewValueOnCoverRecipe(IndexRecover, PanelCode);
            SetCounterProjection("NONE","0");
        }

    }
    public static void AddRecoverOnCab(GameObject Base,string[] C,float leftbox,float backbox,float rightbox)
    {
        string[] Recipe=C[81].Split("_");
        ////print("AddRecoverOnCab==="+C[81]);//AddRecoverOnCab===0_0_P_01?14?0_0_0_0_0
        //AddRecoverOnCab===0_0_P1?17?0.625_0_0_0_0
        for(int i=0; i<7; i++)
        {
            if(Recipe[i]!="0")
            {
                ConstructPanel(Base,C,i,Recipe[i],leftbox,backbox,rightbox);
            }
        }
    }

    public static void AddRecoverOnCornerCab(GameObject Base,string[] C,float leftbox,float backbox,float rightbox)
    {
        string[] Recipe=C[81].Split("_");
        //////print("AddRecoverOnCab==="+C[81]);
        for(int i=0; i<7; i++)
        {
            if(Recipe[i]!="0")
            {
                ConstructPanel(Base,C,i,Recipe[i],leftbox,backbox,rightbox);
            }
        }
    }
    public static void ConstructPanel(GameObject BASE, string[] ADN, int Side, string PanelColor, float leftbox, float backbox, float rightbox)
    {
        Vector3 StartPosition = BASE.transform.position;
        ////print("PanelColor====" + PanelColor);//0_0_P2?1?0_0_0_0_0
        string PanelID = PanelColor.Split('?')[0];
        ColorID = PanelColor.Split('?')[1];

        if(_G.PATH=="free")PanelID=PanelID.Replace("P","");

        ////print("PanelID====" + PanelID);//0_0_P2?1?0_0_0_0_0

        float w = DOIT.ConvertStringToNumber(UIT.Value(Library.Panel, PanelID, Header.Wide));
        float h = DOIT.ConvertStringToNumber(UIT.Value(Library.Panel, PanelID, Header.Height));
        float d = DOIT.ConvertStringToNumber(UIT.Value(Library.Panel, PanelID, Header.Thick));

        if (_P.ListSwitch["ALLOW_RECOVER_RESIZE"])
        {
            w = DOIT.ConvertStringToNumber(ADN[8]);
            h = DOIT.ConvertStringToNumber(ADN[7]) - DOIT.ConvertStringToNumber(ADN[10]);
            if (_P.ListSwitch["RECOVER_UP_TO_FLOOR"])
            {
                h = DOIT.ConvertStringToNumber(ADN[7]);
                if (ADN[4] == "T1" && h < 72) h += 36;
            }
        }

        //Un panneau de recouvrement ne doit jamais depasser en hauteur le caisson qu'il habille.
        //Les caissons COURTS (over sink : 12/15/18 de haut) n'ont pas forcement de ligne de panneau a
        //leur hauteur dans Library.Panel -> on prenait celle de 30, qui debordait sous le caisson.
        //Le style (Model P_XX) est conserve, seule la hauteur est ramenee a celle du caisson.
        //T1 exclu : RECOVER_UP_TO_FLOOR rallonge volontairement le panneau d'une colonne.
        float CabinetHeight = DOIT.ConvertStringToNumber(ADN[7]);
        if (ADN[4] != "T1" && CabinetHeight > 0f && h > CabinetHeight) { h = CabinetHeight; }
        if (new List<string> { "B2", "B4", "B9", "W2", "W4", "W9", "B3", "B4", "B10", "W3", "W5", "W10" }.Contains(ADN[4]))
        {
            if (Side == 0) { w = DOIT.ConvertStringToNumber(ADN[28]); }
            if (Side == 3) { w = DOIT.ConvertStringToNumber(ADN[29]); }
        }

        Material Mat = UIT_MATERIAL.GetMaterial(ColorID);

        float ct = DOIT.ConvertStringToNumber(UIT.Value(Library.Panel, PanelID, Header.Cthick));
        float eh = DOIT.ConvertStringToNumber(UIT.Value(Library.Panel, PanelID, Header.E_H));
        float ev = DOIT.ConvertStringToNumber(UIT.Value(Library.Panel, PanelID, Header.E_V));
        float sw = DOIT.ConvertStringToNumber(UIT.Value(Library.Panel, PanelID, Header.Slat));
        string Model = UIT.Value(Library.Panel, PanelID, Header.Model);

        ////print("Model============================"+Model);

        switch (Model)
        {
            case "P_01": PanelShow.Model_P_01(w, h, d, Mat); break;
            case "P_02": PanelShow.Model_P_02(w, h, d, Mat); break;
            case "P_03": PanelShow.Model_P_03(w, h, d, ct, eh, ev, Mat); break;
            case "P_04": PanelShow.Model_P_04(w, h, d, ct, eh, ev, Mat); break;
            case "P_05": PanelShow.Model_P_05(w, h, d, ct, eh, ev, Mat); break;
            case "P_06": PanelShow.Model_P_06(w, h, d, ct, eh, ev, Mat); break;
            case "P_07": PanelShow.Model_P_07(w, h, d, sw, Mat); break;
            case "P_08": PanelShow.Model_P_08(w, h, d, sw, Mat); break;
            case "P_09": PanelShow.Model_P_09(w, h, d, ct, sw, eh, ev, Mat); break;
            case "P_10": PanelShow.Model_P_10(w, h, d, ct, sw, eh, ev, Mat); break;
            case "P_11": PanelShow.Model_P_11(w, h, d, ct, sw, eh, ev, Mat); break;
            case "P_12": PanelShow.Model_P_12(w, h, d, ct, sw, eh, ev, Mat); break;
            case "P_13": PanelShow.Model_P_13(w, h, d, ct, eh, ev, Mat); break;
            case "P_14": PanelShow.Model_P_14(w, h, d, ct, eh, ev, Mat); break;
            case "P_15": PanelShow.Model_P_15(w, h, d, ct, eh, ev, Mat); break;
            case "P_16": PanelShow.Model_P_16(w, h, d, ct, eh, ev, Mat); break;
        }

        GameObject Panel = Get.o1("3D Object Show").transform.GetChild(0).gameObject;
        Panel.name = "RECOVER PANEL" + Model;
        Panel.transform.position = new(0, 0, 0);
        Panel.layer = 0;
        foreach (Transform go in Panel.transform) { go.gameObject.layer = 0; }

        string[] C42 = ADN[42].Split('_');
        float Counterheight = DOIT.ConvertStringToNumber(C42[0]);
        float PositioY = DOIT.ConvertStringToNumber(ADN[7]) * 0.5f - Counterheight * 0.5f - h * 0.5f;
        float sideleft = DOIT.ConvertStringToNumber(ADN[28]);
        float sideRight = DOIT.ConvertStringToNumber(ADN[29]);

        if (new List<string> { "B1", "W1", "T1" }.Contains(ADN[4]))
        {
            if (Side == 0)
            {
                Panel.transform.eulerAngles = new(0, 90, 0);
                Panel.transform.position = new(leftbox - d * 0.5f, PositioY, backbox-w*0.5f);
            }
            if (Side == 1)
            {
                Panel.transform.eulerAngles = new(0, 180, 0);
                Panel.transform.position = new(0, PositioY, backbox - d * 0.5f);
            }
            if (Side == 2)
            {
                Panel.transform.eulerAngles = new(0, -90, 0);
                Panel.transform.position = new(rightbox + d * 0.5f, PositioY, backbox-w*0.5f);
            }
        }

        if (new List<string> { "B2", "B4", "B9", "W2", "W4", "W9" }.Contains(ADN[4]))
        {
            if (Side == 0)
            {
                Panel.transform.eulerAngles = new(0, 0, 0);
                Panel.transform.position = new(leftbox + sideleft * 0.5f, PositioY, -backbox);
            }
            if (Side == 3)
            {
                Panel.transform.eulerAngles = new(0, -90, 0);
                Panel.transform.position = new(rightbox + d * 0.5f, PositioY, backbox - sideRight * 0.5f);
            }
        }

        if (new List<string> { "B3", "B5", "B10", "W3", "W5", "W10" }.Contains(ADN[4]))
        {
            if (Side == 0)
            {
                Panel.transform.eulerAngles = new(0, -90, 0);
                Panel.transform.position = new(leftbox, PositioY, backbox - sideleft * 0.5f);
            }
            if (Side == 3)
            {
                Panel.transform.eulerAngles = new(0, 0, 0);
                Panel.transform.position = new(rightbox - sideRight * 0.5f, PositioY, -backbox);
            }
        }

        Panel.transform.SetParent(BASE.transform);
        foreach(Transform Child in Panel.transform)
        {
            Child.gameObject.GetComponent<BoxCollider>().enabled=false;
        }
        

        //Panel.GetComponent<Renderer>().probeAnchor = GameObject.Find("Reflection Probe").transform;

        //Reposition cabinet
        Vector3 Direction = BASE.transform.right;
        if(Side == 3)Direction=-Direction;
        _G.OffsetPosition=1f * d * Direction;

    }    
    public static void AddToCabinet(){
        //////print("------------------Add to cabinet-------------");
        //////print("------------------Add to cabinet--_G.OBJs[_G.nO][81]======"+_G.OBJs[_G.nO][81]);

        DOIT.REDOCAB(ADNnumber);
        DOIT.CloseALLPNL();

        if(_G.OBJs[ADNnumber][4].IndexOf("W")!=-1 || _G.OBJs[ADNnumber][4].IndexOf("T")!=-1 ){_MOL.SetMolding();}
        else PRICE.Calprice();

        OffsetPanelEnd=GetPanelOffset();
        print(" OffsetPanelStart====="+ OffsetPanelStart);
        print(" OffsetPanelEnd====="+ OffsetPanelEnd);

        GameObject Cabinet=Get.o2("SCENE",_G.OBJs[ADNnumber][0]);
        Cabinet.transform.position+=OffsetPanelEnd-OffsetPanelStart;
        DOIT.SaveObjectPositionInData(Cabinet);
    }

    ///---------------------------SETTING-----------------------------------
    public static void SetCounterProjection(string SideON,string wide){
        string[] ADN = GetADN();
        string[] CTpr = ADN[42].Split("_"[0]);
        int index = GetCounterIndex();

        float Wide=DOIT.ConvertStringToNumber(wide);
        float WideOnNow;

        if (SideON=="LEFT"){
            WideOnNow = DOIT.ConvertStringToNumber(CTpr[1]);
            if(CTpr[1]=="0" ||  Wide < WideOnNow) CTpr[1]=wide; 
        }
        if (SideON=="RIGHT"){
            WideOnNow = DOIT.ConvertStringToNumber(CTpr[index]);
            if(CTpr[index]=="0" || Wide< WideOnNow) CTpr[index]=wide; 
        }
        if (SideON=="NONE"){
            CTpr[1]="0";
            CTpr[index]="0";
        }
        ADN[42]="";
        for(int i=0; i<CTpr.Length; i++){
             ADN[42]+=CTpr[i];
             if(i<CTpr.Length-1)ADN[42]+="_";
        }
    }
    public static string SetNewValueOnCoverRecipe( int indPosition,string newvalue){
        string[] ADN = GetADN();
        ADN[81]=DOIT.ChangeCodeOnPos(ADN[81],indPosition, newvalue ,"_"); //C[81]===0_0_0_3?1_0_0_0
        return ADN[81];
    }
 
    ///---------------------------GET---------------------------------------
    public static string[] GetADN(){
        //_G.nO=Get.GetObjectIndex(SceneModeManager.SelectedName);
        return  _G.OBJs[ADNnumber];
    }
    public static int GetCounterIndex(){
        string[] ADN=GetADN();
        switch (ADN[4]){
            case "B1":case "W1":case "T1":return 3;            
            case "B9":case "W9":case "B10":case "W10":case "B2":case "B3":case "W2":case "W3":return 4;
            case "B6":case "W26":case "B7":case "W27":case "B11":case "B12":return 5;
            default: break;
        }
        return 1;
    }
    public static Vector3 GetCabinetSize(){
        string[] ADN=GetADN();
        float Wide= 0;
        float Height= 0;
        float Depth=0;

        if(new List<string>{"B1","W1","T1"}.Contains(ADN[4])){
            Wide= DOIT.ConvertStringToNumber(ADN[6]);
            Height= DOIT.ConvertStringToNumber(ADN[7]);
            Depth= DOIT.ConvertStringToNumber(ADN[8]);
        }
        if(new List<string>{"B2","B3","B4","B5","B9","B10","W2","W3","W4","W5","W9","W10"}.Contains(ADN[4])){
            Wide= DOIT.ConvertStringToNumber(ADN[28]);
            Height= DOIT.ConvertStringToNumber(ADN[7]);
            Depth= DOIT.ConvertStringToNumber(ADN[29]);
        }
        

        return new(Wide,Height,Depth);
    }
    //Retourne l'ID de la ligne Library.Panel qui correspond au cabinet ("No Match" si aucune).
    //On retourne l'ID et non le Unique_Name : plusieurs lignes partagent le meme Unique_Name
    //avec des Wide/Height differents, le nom seul ne permet pas de retrouver la bonne ligne.
    public static string GetCoverfit(string SideON)
    {
        if(_G.PATH=="free")return "P1";
        //////print("ColorID======="+ColorID);
        Vector2 SizeToVerify=GetSizeToVerify(SideON);
        float WideToVerify=SizeToVerify.x;
        float HeightToVerify=SizeToVerify.y;

        int IndHeight=UIT.Ind(Library.Panel,Header.Height);
        int IndWide=UIT.Ind(Library.Panel,Header.Wide);
        int IndUniqueName=UIT.Ind(Library.Panel,Header.Unique_Name);
        int IndModel=UIT.Ind(Library.Panel,Header.Model);
        float HeightCSV;
        float WideCSV;

        //int PanelID;
        int IndColorID=UIT.Ind(Library.Panel,Header.ColorID);
        string CoverFit="No Match";
        string SmallestCoverFit="No Match";
        float Offset=6;
        float SmallessOffset=100;
        foreach(string line in _G.UIT_LibraryPanels)
        {
            string[] L=line.Split(',');
            if (!string.IsNullOrEmpty(L[0]) && Set.Chars(L[0]) != "ID" && L[IndModel][..2] == "P_")//L[0]======ID
            {
                WideCSV = GetSizeFromCSV(L[IndWide]);
                HeightCSV = GetSizeFromCSV(L[IndHeight]);

                ////print(WideCSV + " vs " + WideToVerify + "     " + HeightCSV + " vs " + HeightToVerify + "    Color===" + ColorID + " vs " + L[IndColorID]);
                //1 vs 23.625     72 vs 34.5    Color===1 vs All

                if (L[IndColorID] == "All") { L[IndColorID] = ColorID; }

                bool isColorOnList = L[IndColorID].Split("_").Contains(ColorID);
                string Substitute = UIT.Value(Library.CabTexture, ColorID, Header.Substitute);
                if (!isColorOnList && Substitute != "0" && Substitute != ColorID) { ColorID = Substitute; isColorOnList = true; }
                
                float HeightOffset = HeightCSV - HeightToVerify;
                float WideOffset = WideCSV - WideToVerify;

                if (HeightOffset < 2 && WideOffset < 2 && isColorOnList && HeightOffset > 0 && WideOffset > 0)
                {
                    float NewOffset = HeightOffset + WideOffset;
                    ////print("Model===="+L[IndUniqueName]+"    Offset==="+NewOffset+"    WideCSV===="+WideCSV+"   WideToVerify===="+WideToVerify);
                    if (NewOffset < Offset)//strict : en cas d'egalite on garde la premiere ligne trouvee
                    {
                        CoverFit = L[0];
                        Offset = NewOffset;
                    }
                }  

                ////print("HeightOffset====" + HeightOffset + "     WideOffset====" + WideOffset);
                if (HeightOffset >= 0 && WideOffset >= 0 && isColorOnList && _P.ListSwitch["ALLOW_RECOVER_RESIZE"])
                {
                    float SmallestNewOffset = HeightOffset + WideOffset;
                    //////print("Model===="+L[IndUniqueName]+"    Offset==="+NewOffset);
                    if (SmallestNewOffset < SmallessOffset)//strict : en cas d'egalite on garde la premiere ligne trouvee
                    {
                        SmallestCoverFit = L[0];
                        SmallessOffset = SmallestNewOffset;
                    }
                }  
            }    
        }

        if(_P.ListSwitch["ALLOW_RECOVER_RESIZE"]){
                return SmallestCoverFit;
            }
        return CoverFit;
    }
    public static string GetColorID(){
        int ObjectNumber=Get.GetObjectIndex(SceneModeManager.SelectedName);
        return _G.OBJs[ObjectNumber][61].Split("?")[1];
    }
    //Plusieurs lignes de Library.Panel peuvent porter le meme Unique_Name avec des Wide/Height
    //differents : on garde celle qui colle le mieux au cabinet, sinon la premiere trouvee.
    public static string GetCoverIDFromUniqueName(string UniqueName,string SideON){
        string ID ="";
        int indexOfUnique_Name=UIT.Ind(Library.Panel,Header.Unique_Name);
        int IndWide=UIT.Ind(Library.Panel,Header.Wide);
        int IndHeight=UIT.Ind(Library.Panel,Header.Height);

        Vector2 SizeToVerify=GetSizeToVerify(SideON);
        float BestOffset=float.MaxValue;

        foreach(string sel in _G.UIT_LibraryPanels){
            if(string.IsNullOrEmpty(sel))continue;
            string[] L=sel.Split(',');
            string ID_Panel=L[0];
            if(string.IsNullOrEmpty(ID_Panel) || ID_Panel.IndexOf("ID")!=-1)continue;
            if(indexOfUnique_Name>=L.Length || IndWide>=L.Length || IndHeight>=L.Length)continue;
            if(L[indexOfUnique_Name]!=UniqueName)continue;

            if(ID=="")ID=ID_Panel;//repli : premiere ligne portant ce Unique_Name

            float WideOffset=GetSizeFromCSV(L[IndWide])-SizeToVerify.x;
            float HeightOffset=GetSizeFromCSV(L[IndHeight])-SizeToVerify.y;
            if(WideOffset<0 || HeightOffset<0)continue;

            float NewOffset=WideOffset+HeightOffset;
            if(NewOffset<BestOffset){ BestOffset=NewOffset; ID=ID_Panel;}
        }
        return ID;
    }
    public static Vector2 GetSizeToVerify(string SideON){
        string[] ADN = GetADN();
        float HeightToVerify=GetCabinetSize().y-1;
        float WideToVerify=0;
        if(new List<string>{"B1","W1","T1"}.Contains(ADN[4])){
            WideToVerify=GetCabinetSize().z;
        }
        else if(new List<string>{"B2","B3","B4","B5","B9","B10","W2","W3","W4","W5","W9","W10"}.Contains(ADN[4])){
            if(SideON=="LEFT")WideToVerify=GetCabinetSize().x;
            if(SideON=="RIGHT")WideToVerify=GetCabinetSize().z;
        }
        return new Vector2(WideToVerify,HeightToVerify);
    }
    public static float GetSizeFromCSV(string Value){
        string Size=Set.Chars(Value);
        string[] Parts=Size.Split("_");
        if(Parts.Length>1)Size=Parts[^1];
        return DOIT.ConvertStringToNumber(Size);
    }
    public static int GetIndexOfRecover(){
        string[] ADN=GetADN();
        switch (ADN[4]){
            case "B1":case "W1":case "T1":return 2;            
            case "B9":case "W9":case "B10":case "W10":case "B2":case "B3":case "W2":case "W3":return 3;
            case "B6":case "W26":case "B7":case "W27":case "B11":case "B12":return 4;
            default: break;
        }
        return 0;
    }

    public static Vector3 GetPanelOffset()
    {
        float OffsetSide=0;
        float OffsetDepth=0;

        string[] ADN = _G.OBJs[ADNnumber];
        string[] ADN81=ADN[81].Split("_");
        float PanelThickness=0.625f;

        for(int i=0; i<ADN81.Length; i++)
        {
            if (ADN81[i] != "0")
            {
                 if(new List<string> { "B1", "W1", "T1" }.Contains(ADN[4]))
                {
                    if(i==0 )OffsetSide-=PanelThickness*0.5f;
                    if(i==2)OffsetSide+=PanelThickness*0.5f;
                }
                if(new List<string> { "B2", "W2", "B4" ,"W4","B9" ,"W9"}.Contains(ADN[4]))
                {
                    if(i==0 )OffsetDepth-=PanelThickness*0.5f;//Fonctionne
                    if(i==3)OffsetSide+=PanelThickness*0.5f;
                }
                if(new List<string> { "B3", "W3", "B5" ,"W5","B10" ,"W10"}.Contains(ADN[4]))
                {
                    if(i==0 )OffsetSide-=PanelThickness*0.5f;//fonctionne
                    if(i==3)OffsetDepth-=PanelThickness*0.5f;
                }
            }
        }

        GameObject Cabinet=Get.o2("SCENE",ADN[0]);//ADNnumber et non _G.nO : _G.nO peut pointer un autre cabinet
        if(Cabinet==null)return Vector3.zero;
        Vector3 OffsetMove=OffsetSide*Cabinet.transform.right+OffsetDepth*Cabinet.transform.forward;

        return OffsetMove;
    }

}