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

public class CounterView : MonoBehaviour
{
    public static void ON()
    {
        //Camera top orthogonal view
        DASH.HDsetBTNcolor(true);
        GameObject.Find("HIDER").transform.Find("LoadingCircle").gameObject.SetActive(false);
        print("Do CounterView==========================ON");
        DASH.CamOrtho();
        set.SH_S(true);
        float xmin = 1000;
        //float xmax=1000;
        //float zmin=1000;
        float zmax = 1000;
        Vector2 Vstart = new Vector2(1000, 1000);
        List<int> CABlist = DOLIST.CABLISTint();
        Dictionary<Vector2, string> dict = new Dictionary<Vector2, string>();
        foreach (int nO in CABlist)
        {
            string[] C = _G.OBJs[nO];
            string[] c42 = C[42].Split(',');
            float a = DOIT.ConvertStringToNumber(C[19]);
            if (c42[0] != "0")
            {
                Vector3 V1 = Get.o2(C[0], "PC1").transform.position;
                Vector3 V2 = Get.o2(C[0], "PC2").transform.position;
                Vector3 V3 = Get.o2(C[0], "PC3").transform.position;
                Vector3 V4 = Get.o2(C[0], "PC4").transform.position;
                Vector2 v1 = new Vector2(V1.x, V1.z);
                Vector2 v2 = new Vector2(V2.x, V2.z);
                Vector2 v3 = new Vector2(V3.x, V3.z);
                Vector2 v4 = new Vector2(V4.x, V4.z);
                print("V1====" + V1);
                float A2 = a;
                float A3 = a + 90;
                float A4 = a + 180;
                float A1 = a + 270;
                addITEM(dict, v2, resetA(A1) + "_" + resetA(A2));
                addITEM(dict, v3, resetA(A2) + "_" + resetA(A3));
                addITEM(dict, v4, resetA(A3) + "_" + resetA(A4));
                addITEM(dict, v1, resetA(A4) + "_" + resetA(A1));
                xmin = v1.x;
                zmax = v1.y;
                if (Vstart == new Vector2(1000, 1000)) { Vstart = v2; }
            }
        }

        foreach (KeyValuePair<Vector2, string> pair in dict)
        {
            print("Key==" + pair.Key + "    value==" + pair.Value);
        }


        //find point 2
        /*    float dir=0;         
            Vector2 VP2=new Vector2(1000,1000);
            dir=dict[Vstart];
            print("Vstart=="+Vstart+"    dir=="+dir);
            Dictionary<Vector2, float> dict2 = new Dictionary<Vector2, float>();
            float angle=0;
            foreach(KeyValuePair<Vector2,float> pair in dict){
                angle= Mathf.Atan2(pair.Key.y - Vstart.y , pair.Key.x-Vstart.x) * 180 / Mathf.PI;
                if(angle==dir){dict2.Add(pair.Key,pair.Value);break;}
            }//find nearest
            float dis=1000;
            foreach(KeyValuePair<Vector2,float> pair in dict2){
                if(Vector2.Distance(pair.Key,Vstart)<dis)VP2=pair.Key;
            }
            print("VP2===="+VP2+"    dir=="+dict[VP2]);

        //find point 3  
            dir=dict[VP2];
            Vector2 VP3=new Vector2(1000,1000);
            Dictionary<Vector2, float> dict3 = new Dictionary<Vector2, float>();
            foreach(KeyValuePair<Vector2,float> pair in dict){
                angle= Mathf.Atan2(pair.Key.y - VP2.y , pair.Key.x-VP2.x) * 180 / Mathf.PI;
                print( "angle===="+ angle);
                if(Mathf.Abs(angle)==Mathf.Abs(dir)){dict3.Add(pair.Key,pair.Value);print( "angle===2="+ angle);break;}
            }//find nearest
            dis=1000;
            foreach(KeyValuePair<Vector2,float> pair in dict3){
                if(Vector2.Distance(pair.Key,Vstart)<dis)VP3=pair.Key;
            }
            print("VP3===="+VP3+"    dir=="+dict[VP3]);

        //find point 4 
            dir=dict[VP3];
            Vector2 VP4=new Vector2(1000,1000);
            Dictionary<Vector2, float> dict4 = new Dictionary<Vector2, float>();
            foreach(KeyValuePair<Vector2,float> pair in dict){
                angle= Mathf.Atan2(pair.Key.y - VP3.y , pair.Key.x-VP3.x) * 180 / Mathf.PI;
                if(angle==dir){dict4.Add(pair.Key,pair.Value);break;}
            }//find nearest
            dis=1000;
            foreach(KeyValuePair<Vector2,float> pair in dict4){
                if(Vector2.Distance(pair.Key,Vstart)<dis)VP4=pair.Key;
            }
            print("VP4===="+VP4+"    dir=="+dict[VP4]);
    */


        //Vstart=dict.Keys.First();
        //Dictionary<Vector2, float> dictminmax = new Dictionary<Vector2, float>();
        /*foreach(KeyValuePair<Vector2,float> pair in dict){
            if(pair.Key.x<zmin) {xmin=pair.Key.x;}break;
            if(pair.Key.y>zmax) {zmax=pair.Key.y;}
        }
        foreach(KeyValuePair<Vector2,float> pair in dict){
            if(pair.Key.x==xmin) {if(!dictminmax.ContainsKey(pair.Key))dictminmax.Add(pair.Key,pair.Value);}
            if(pair.Key.y==zmax) {if(!dictminmax.ContainsKey(pair.Key))dictminmax.Add(pair.Key,pair.Value);}
        }
        foreach(KeyValuePair<Vector2,float> pair in dictminmax){
            if(pair.Key.x==xmin) {Vstart=pair.Key; dir1=pair.Value;}
        }
        foreach(KeyValuePair<Vector2,float> pair in dict){
            if(pair.Key==Vstart) { dir1=pair.Value;}
        }*/
        set.SH_S(false);
        /* float size=60;
         float xmin=1000;
         float xmax=1000;
         float zmin=1000;
         float zmax=1000;

         Vector3 v3=new Vector3(0,0,1);
         foreach( int nO in CABlist)
         {
             string[] C = _G.OBJs[nO];
             string[] c42=C[42].Split(',');

             if(c42[0]!="0")
             {
                 if(C[4]=="B1" || C[4]=="B2" || C[4]=="B3" || C[4]=="B4" || C[4]=="B5"|| C[4]=="B9" || C[4]=="B10")
                 {
                     set.SH_SO(C[0], true);
                     Vector3 BS=Get.o1(C[0]).GetComponent<BoxCollider>().bounds.size;
                     float w=BS.x; 
                     float d=BS.z;
                     float a=DOIT.ConvertStringToNumber(C[19]); 
                     v3=Get.o1(C[0]).transform.localPosition;
                     if(xmin==1000) xmin=v3.x;
                     if(xmax==1000) xmax=v3.x;
                     if(zmin==1000) zmin=v3.z;
                     if(zmax==1000) zmax=v3.z;
                     if(v3.x+w/2<xmin)xmin=v3.x+w/2;
                     if(v3.x+w/2>xmax)xmax=v3.x+w/2;
                     if(v3.z+d/2<zmin)zmin=v3.z+d/2;
                     if(v3.z+d/2>zmax)zmax=v3.z+d/2; 
                     if(v3.x-w/2<xmin)xmin=v3.x-w/2;
                     if(v3.x-w/2>xmax)xmax=v3.x-w/2;
                     if(v3.z-d/2<zmin)zmin=v3.z-d/2;
                     if(v3.z-d/2>zmax)zmax=v3.z-d/2; 
                 }
             }
         }
         _G.SM="CounterView";
         set.SH_R(false);
         //Background white
         GameObject.Find("Main Camera").GetComponent<Camera>().backgroundColor = DOIT.CSc("ffffff", 255);
         //scale view 30 t0 200*/
    }

    public static string resetA(float A)
    {
        if (A > 360) A = 0;
        return A.ToString(CultureInfo.InvariantCulture);
    }

    public static void addITEM(Dictionary<Vector2, string> dict, Vector2 P, string Q)
    {
        if (!dict.ContainsKey(P)) { dict.Add(P, Q); }
        else
        {
            if (Q.Split('_')[0] == dict[P].Split('_')[1]) { dict.Remove(P); }
            else { dict[P] = Q; }
        }
    }
    public static void scale(float xmin, float xmax, float zmin, float zmax)
    {
        float size = 60;
        float dx = Mathf.Abs(xmin - xmax);
        float dz = Mathf.Abs(zmin - zmax);
        size = dx;
        if (dz > dx) size = dz * 1280 / 750;
        print("size====" + size);
        if (size <= 30) size = 30;
        else size = size * 0.4f;
        Camera cam = GameObject.Find("MainCamera").GetComponent<Camera>();
        cam.orthographicSize = size;
        cam.transform.localPosition = new Vector3(xmin + dx / 2, 0, zmin + dz / 2);
    }

    public static float rescale(string cat)
    {
        float S = 3.2f;

        GameObject Obj = Get.o3("PLAN2D", "PLAN", cat);
        float xmin = 0;
        float xmax = 0;
        float ymin = 0;
        float ymax = 0;

        for (int i = 0; i < Obj.transform.childCount; i++)
        {
            Vector2 v2 = Obj.transform.GetChild(i).transform.localPosition;
            if (v2.x < xmin) xmin = v2.x;
            if (v2.x > xmax) xmax = v2.x;
            if (v2.y < ymin) ymin = v2.y;
            if (v2.y > ymax) ymax = v2.y;
        }
        float dx = Mathf.Abs(xmin - xmax);
        float dy = Mathf.Abs(ymin - ymax);

        S = dx * (1280 / 300);
        if (dy * S > (750 / 300)) S = dy * (750 / 300);
        print("S====" + S / 100);
        return S / 100;
    }
    public static void OFF()
    {
        //Camera top orthogonal view
        //Hide Room
        //Show only cab with counter
    }
}