using System.Collections.Generic;
using UnityEngine;

namespace InfinityCode.OnlineMapsSupport
{
    /// <summary>
    /// Class for displaying vector labels on the map.
    /// </summary>
    public class VectorLabels : MonoBehaviour
    {
        /// <summary>
        /// Singleton instance of VectorLabels.
        /// </summary>
        private static VectorLabels instance;
        
        /// <summary>
        /// Container for labels.
        /// </summary>
        private static GameObject labelsContainer;
        
        /// <summary>
        /// The language of the labels.
        /// </summary>
        public Language language = Language.Russian;
        
        /// <summary>
        /// The font size of the labels.
        /// </summary>
        public float fontSize = 15;

        /// <summary>
        /// Instances of labels.
        /// </summary>
        private Dictionary<ulong, Label> labels;
        
        /// <summary>
        /// The map.
        /// </summary>
        private OnlineMaps map;
        
        /// <summary>
        /// The control.
        /// </summary>
        private OnlineMapsControlBaseDynamicMesh control;
        
        /// <summary>
        /// The camera orbit.
        /// </summary>
        private OnlineMapsCameraOrbit cameraOrbit;

        /// <summary>
        /// Creates a label from vector tile.
        /// </summary>
        /// <param name="tile">Vector tile.</param>
        /// <param name="layerName">Name of layer.</param>
        private void CreateLabels(OnlineMapsVectorTile tile, string layerName)
        {
            // Get layer by name.
            OnlineMapsVectorTile.Layer layer = tile.GetLayer(layerName);
            
            // If the layer is null, return.
            if (layer == null) return;

            // Get the language key.
            string lang = GetLanguageKey();

            // Loop through each feature in the layer.
            for (int i = 0; i < layer.featureCount; i++)
            {
                // Get the feature.
                OnlineMapsVectorTile.Feature feature = layer.GetFeature(i);

                // Check if a label already exists for this feature ID.
                Label label;
                if (labels.TryGetValue(feature.id, out label))
                {
                    // If the label already exists, add the tile to the owners.
                    label.owners.Add(tile);
                    continue;
                }

                // Get the properties for the feature.
                Dictionary<string, object> properties = feature.GetProperties();

                // Get the label value for the current language.
                object labelValue;
                if (!properties.TryGetValue(lang, out labelValue)) continue;

                // Get the type value for the feature.
                object typeValue;
                if (!properties.TryGetValue("type", out typeValue)) continue;
    
                string type = typeValue as string;

                // Get the geometry for the feature.
                List<List<OnlineMapsVectorTile.LPoint>> geometry = feature.Geometry();
                if (geometry.Count == 0 || geometry[0].Count == 0) continue;

                // Create a new label for the feature.
                label = new Label(labelValue as string, geometry, layer.extent, tile, type);

                // Add the label to the labels dictionary.
                labels.Add(feature.id, label);

                // Get the symbol rank for the feature.
                object symbolRankO;
                int symbolRank = 0;
                if (properties.TryGetValue("symbolrank", out symbolRankO)) symbolRank = int.Parse(symbolRankO.ToString());

                // Set the zoom range for the label.
                label.zoomRange = new OnlineMapsRange(symbolRank, symbolRank + 7);

                // Update the label.
                label.Update(control, cameraOrbit);
            }
        }

        /// <summary>
        /// Gets the language key.
        /// </summary>
        /// <returns>Language key</returns>
        public string GetLanguageKey()
        {
            switch (language)
            {
                case Language.Arabic:
                    return "name_ar";
                case Language.Chinese:
                    return "name_zh";
                case Language.Chinese_simplified:
                    return "name_zh-Hans";
                case Language.English:
                    return "name_en";
                case Language.French:
                    return "name_fr";
                case Language.German:
                    return "name_de";
                case Language.International:
                    return "name";
                case Language.Portuguese:
                    return "name_pt";
                case Language.Russian:
                    return "name_ru";
                case Language.Spanish:
                    return "name_es";
            }

            return "name";
        }

        /// <summary>
        /// This method is called when the script instance is being loaded.
        /// </summary>
        private void OnEnable()
        {
            instance = this;
        }

        /// <summary>
        /// This method is called when the tile being disposed.
        /// </summary>
        /// <param name="tile">Tile that being disposed.</param>
        private void OnTileDisposed(OnlineMapsTile tile)
        {
            // Get the OnlineMapsVectorTile from the tile.
            OnlineMapsVectorTile t = tile["vector_tile"] as OnlineMapsVectorTile;
    
            // If the tile doesn't have a vector tile, return.
            if (t == null) return;

            // Create a list to keep track of which labels to remove.
            List<ulong> labelsToRemove = new List<ulong>();

            // Loop through all the labels.
            foreach (KeyValuePair<ulong, Label> pair in labels)
            {
                // Get the owners of this label.
                var owners = pair.Value.owners;

                // If this label is owned by the current tile, remove it.
                if (owners.Contains(t))
                {
                    owners.Remove(t);

                    // If there are no more owners of this label, dispose of it and add its key to the list of labels to remove.
                    if (owners.Count == 0)
                    {
                        pair.Value.Dispose();
                        labelsToRemove.Add(pair.Key);
                    }
                }
            }

            // Loop through all the labels to remove and remove them from the labels dictionary.
            foreach (ulong key in labelsToRemove) labels.Remove(key);
        }

        /// <summary>
        /// This method is called when the tile is loaded.
        /// </summary>
        /// <param name="tile">The loaded tile.</param>
        private void OnTileLoaded(OnlineMapsTile tile)
        {
            // Try to cast the loaded tile to a vector tile.
            OnlineMapsVectorTile mt = tile as OnlineMapsVectorTile;

            // If the tile is not a vector tile, create a new Mapbox tile and start downloading it.
            if (mt == null)
            {
                // Create a new Mapbox tile.
                mt = new OnlineMapsMapboxTile(tile.x, tile.y, tile.zoom, map, false);
                
                // Store the vector tile in the tile.
                tile["vector_tile"] = mt;
                
                // Subscribe to the OnDisposed event of the tile.
                tile.OnDisposed += OnTileDisposed;
                
                // Start downloading the tile.
                OnlineMapsTileManager.StartDownloadTile(mt);
                return;
            }

            // Create labels for country, state, and place.
            CreateLabels(mt, "country_label");
            CreateLabels(mt, "state_label");
            CreateLabels(mt, "place_label");
        }


        /// <summary>
        /// This method is called when the script instance is being loaded.
        /// </summary>
        private void Start()
        {
            if (!OnlineMapsKeyManager.hasMapbox)
            {
                Debug.LogError( "You need to add a Mapbox Access Token to the Online Maps Key Manager." );
                return;
            }
            
            // Get the OnlineMaps component and set it as the map variable.
            map = GetComponent<OnlineMaps>();
            if (map == null) map = OnlineMaps.instance;
        
            // Get dynamic mesh control and set it as the control variable.
            control = map.control as OnlineMapsControlBaseDynamicMesh;
        
            // Get CameraOrbit component and set up the UpdateLabels event listener if available.
            cameraOrbit = map.GetComponent<OnlineMapsCameraOrbit>();
            if (cameraOrbit != null) cameraOrbit.OnCameraControl += UpdateLabels;
        
            // Set up the OnTileLoaded event listener.
            OnlineMapsTileManager.OnTileLoaded += OnTileLoaded;
        
            // Initialize the labels dictionary.
            labels = new Dictionary<ulong, Label>();

            // Create a new GameObject to hold the labels.
            labelsContainer = new GameObject("Labels");
            labelsContainer.transform.SetParent(map.transform);
        
            // Set up the OnMapUpdated event listener.
            map.OnMapUpdated += UpdateLabels;
        }

        /// <summary>
        /// Updates the labels.
        /// </summary>
        private void UpdateLabels()
        {
            foreach (var pair in labels) pair.Value.Update(control, cameraOrbit);
        }

        /// <summary>
        /// Represents a label that can be displayed on the map.
        /// </summary>
        public class Label
        {
            /// <summary>
            /// The zoom range at which this label should be visible.
            /// </summary>
            public OnlineMapsRange zoomRange;
        
            /// <summary>
            /// The set of vector tiles that own this label.
            /// </summary>
            public HashSet<OnlineMapsVectorTile> owners = new HashSet<OnlineMapsVectorTile>();
        
            /// <summary>
            /// The game object that this label is attached to.
            /// </summary>
            public GameObject target;
        
            /// <summary>
            /// The longitude of the label's position.
            /// </summary>
            public double longitude;
        
            /// <summary>
            /// The latitude of the label's position.
            /// </summary>
            public double latitude;
        
            /// <summary>
            /// Whether the label should always be facing up on the map.
            /// </summary>
            public bool alwaysUp;

            /// <summary>
            /// The label.
            /// </summary>
            private string label;

            /// <summary>
            /// The type of the label.
            /// </summary>
            private string type;

            /// <summary>
            /// The rotation angle of the label.
            /// </summary>
            private float angle;

            /// <summary>
            /// The label has an instance.
            /// </summary>
            private bool exists;

            /// <summary>
            /// Initializes a new instance of the Label class.
            /// </summary>
            /// <param name="label">The label.</param>
            /// <param name="geometry">The geometry.</param>
            /// <param name="extent">The extent.</param>
            /// <param name="tile">The vector tile.</param>
            /// <param name="type">The type of label.</param>
            public Label(string label, List<List<OnlineMapsVectorTile.LPoint>> geometry, ulong extent, OnlineMapsVectorTile tile, string type)
            {
                // Set label and type
                this.label = label;
                this.type = type;

                // Get geometry center
                List<OnlineMapsVectorTile.LPoint> g = geometry[0];
                Vector2 center;

                if (g.Count == 1)
                {
                    // If there is only one point in the list, set the center to that point and always face up.
                    OnlineMapsVectorTile.LPoint gg = g[0];
                    center = new Vector2(gg.x / (float)extent, gg.y / (float)extent);
                    alwaysUp = true;
                }
                else
                {
                    // If there are multiple points in the list, find the two points that are farthest apart and set the center between them.
                    Vector2[] points = new Vector2[g.Count];
                    Vector2 p1 = points[0];
                    Vector2 p2 = points[1];
                    float sqrD = (p1 - p2).sqrMagnitude;
                
                    for (int i = 0; i < points.Length; i++)
                    {
                        var gg = g[i];
                        Vector2 p = new Vector2(gg.x / (float)extent, gg.y / (float)extent);
                        points[i] = p;
                        if (i > 1)
                        {
                            Vector2 cp1 = points[i - 1];
                            Vector2 cp2 = p;
                            float cd = (cp1 - cp2).sqrMagnitude;
                            if (cd > sqrD)
                            {
                                sqrD = cd;
                                p1 = cp1;
                                p2 = cp2;
                            }
                        }
                    }
                    center = (p1 + p2) / 2;
                
                    if (points.Length > 1)
                    {
                        // Calculate the angle between the two farthest points and adjust it if it's outside the range of -90 to 90 degrees.
                        angle = OnlineMapsUtils.Angle2D(p1, p2);
                        if (angle < -90) angle += 180;
                        else if (angle > 90) angle -= 180;
                    }
                }

                // Convert the center to longitude and latitude.
                double lng, lat;
                OnlineMaps.instance.projection.TileToCoordinates(tile.x + center.x, tile.y + center.y, tile.zoom, out lng, out lat);

                // Set the longitude and latitude.
                longitude = lng;
                latitude = lat;

                // This line adds the tile to the owners list
                owners.Add(tile);
            }

            /// <summary>
            /// Creates an instance of the label.
            /// </summary>
            private void CreateInstance()
            {
                // Set exists to true.
                exists = true;
            
                // Create a new game object.
                target = new GameObject(label);
                target.transform.SetParent(labelsContainer.transform);
            
                // Add a text mesh component to the game object and set the text, character size, alignment, and anchor.
                TextMesh textMesh = target.AddComponent<TextMesh>();
                textMesh.text = label;
                textMesh.characterSize = instance.fontSize;
                textMesh.alignment = TextAlignment.Center;
                textMesh.anchor = TextAnchor.MiddleCenter;
            
                // Set the rotation of the game object.
                target.transform.rotation = Quaternion.Euler(90, 180 - angle, 0);
            }

            /// <summary>
            /// Disposes of the object and cleans up any resources used.
            /// </summary>
            public void Dispose()
            {
                // Check if the object exists before destroying it
                if (exists) OnlineMapsUtils.Destroy(target);
            
                // Set all variables to null to free up memory
                owners = null;
                target = null;
                zoomRange = null;
            }

            /// <summary>
            /// Destroys the instance and sets the exists flag to false.
            /// </summary>
            private void DestroyInstance()
            {
                // Set exists flag to false
                exists = false;
            
                // Destroy target object
                OnlineMapsUtils.Destroy(target);
            }

            /// <summary>
            /// Updates the position and rotation of the label on the map.
            /// </summary>
            /// <param name="control">Dynamic mesh control.</param>
            /// <param name="cameraOrbit">Camera Orbit component.</param>
            public void Update(OnlineMapsControlBaseDynamicMesh control, OnlineMapsCameraOrbit cameraOrbit)
            {
                // Check if the current zoom level is within the specified range
                if (!zoomRange.InRange(control.map.floatZoom))
                {
                    // If the instance exists, destroy it
                    if (exists) DestroyInstance();
                    return;
                }
            
                // Get the world position of the mesh
                Vector3 worldPosition = control.GetWorldPosition(longitude, latitude);
            
                // Check if the mesh is within the bounds of the map
                if (worldPosition.x > 0 || worldPosition.x < -control.sizeInScene.x ||
                    worldPosition.z < 0 || worldPosition.z > control.sizeInScene.y)
                {
                    // If the instance exists, destroy it
                    if (exists) DestroyInstance();
                    return;
                }
            
                // If the instance doesn't exist, create it
                if (!exists) CreateInstance();
            
                // Set the position of the mesh
                target.transform.position = worldPosition;
            
                // Set the rotation of the mesh if alwaysUp is true and cameraOrbit is not null
                if (alwaysUp && cameraOrbit != null) target.transform.rotation = Quaternion.Euler(90, 180 + cameraOrbit.rotation.y, 0);
            }
        }

        /// <summary>
        /// Language of the label.
        /// </summary>
        public enum Language
        {

            International,
            English,
            Spanish,
            French,
            German,
            Russian,
            Chinese,
            Chinese_simplified,
            Portuguese,
            Arabic
        }
    }
}