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


namespace Poco
{
    public class UnityNode : AbstractNode
    {
        public static Dictionary<string, string> TypeNames = new Dictionary<string, string>() {
            { "Text", "Text" },
            { "Gradient Text", "Gradient.Text" },
            { "Image", "Image" },
            { "RawImage", "Raw.Image" },
            { "Mask", "Mask" },
            { "2DRectMask", "2D-Rect.Mask" },
            { "Button", "Button" },
            { "InputField", "InputField" },
            { "Toggle", "Toggle" },
            { "Toggle Group", "ToggleGroup" },
            { "Slider", "Slider" },
            { "ScrollBar", "ScrollBar" },
            { "DropDown", "DropDown" },
            { "ScrollRect", "ScrollRect" },
            { "Selectable", "Selectable" },
            { "Camera", "Camera" },
            { "RectTransform", "Node" },
        };
        public static string DefaultTypeName = "GameObject";
        private GameObject gameObject;
        private Renderer renderer;
        private RectTransform rectTransform;
        private Rect rect;
        private Vector2 objectPos;
        private List<string> components;
        private Camera camera;


        public UnityNode(GameObject obj)
        {
            gameObject = obj;
            camera = Camera.main;
            foreach (var cam in Camera.allCameras)
            {
                // skip the main camera
                // we want to use specified camera first then fallback to main camera if no other cameras
                // for further advanced cases, we could test whether the game object is visible within the camera
                if (cam == Camera.main)
                {
                    continue;
                }
                if ((cam.cullingMask & (1 << gameObject.layer)) != 0)
                {
                    camera = cam;
                }
            }

            renderer = gameObject.GetComponent<Renderer>();
            rectTransform = gameObject.GetComponent<RectTransform>();
            rect = GameObjectRect(renderer, rectTransform);
            objectPos = renderer ? WorldToGUIPoint(camera, renderer.bounds.center) : Vector2.zero;
            components = GameObjectAllComponents();
        }

        public override AbstractNode getParent()
        {
            GameObject parentObj = gameObject.transform.parent.gameObject;
            return new UnityNode(parentObj);
        }

        public override List<AbstractNode> getChildren()
        {
            List<AbstractNode> children = new List<AbstractNode>();
            foreach (Transform child in gameObject.transform)
            {
                children.Add(new UnityNode(child.gameObject));
            }
            return children;
        }

        public override object getAttr(string attrName)
        {
            switch (attrName)
            {
                case "name":
                    return gameObject.name;
                case "type":
                    return GuessObjectTypeFromComponentNames(components);
                case "visible":
                    return GameObjectVisible(renderer, components);
                case "pos":
                    return GameObjectPosInScreen(objectPos, renderer, rectTransform, rect);
                case "size":
                    return GameObjectSizeInScreen(rect, rectTransform);
                case "scale":
                    return new List<float>() { 1.0f, 1.0f };
                case "anchorPoint":
                    return GameObjectAnchorInScreen(renderer, rect, objectPos);
                case "zOrders":
                    return GameObjectzOrders();
                case "clickable":
                    return GameObjectClickable(components);
                case "text":
                    return GameObjectText();
                case "components":
                    return components;
                case "texture":
                    return GetImageSourceTexture();
                case "tag":
                    return GameObjectTag();
                case "layer":
                    return GameObjectLayerName();
                case "_ilayer":
                    return GameObjectLayer();
                case "_instanceId":
                    return gameObject.GetInstanceID();
                default:
                    return null;
            }
        }


        public override Dictionary<string, object> enumerateAttrs()
        {
            Dictionary<string, object> payload = GetPayload();
            Dictionary<string, object> ret = new Dictionary<string, object>();
            foreach (KeyValuePair<string, object> p in payload)
            {
                if (p.Value != null)
                {
                    ret.Add(p.Key, p.Value);
                }
            }
            return ret;
        }


        private Dictionary<string, object> GetPayload()
        {
            Dictionary<string, object> payload = new Dictionary<string, object>() {
                { "name", gameObject.name },
                { "type", GuessObjectTypeFromComponentNames (components) },
                { "visible", GameObjectVisible (renderer, components) },
                { "pos", GameObjectPosInScreen (objectPos, renderer, rectTransform, rect) },
                { "size", GameObjectSizeInScreen (rect, rectTransform) },
                { "scale", new List<float> (){ 1.0f, 1.0f } },
                { "anchorPoint", GameObjectAnchorInScreen (renderer, rect, objectPos) },
                { "zOrders", GameObjectzOrders () },
                { "clickable", GameObjectClickable (components) },
                { "text", GameObjectText () },
                { "components", components },
                { "texture", GetImageSourceTexture () },
                { "tag", GameObjectTag () },
                { "_ilayer", GameObjectLayer() },
                { "layer", GameObjectLayerName() },
                { "_instanceId", gameObject.GetInstanceID () },
            };
            return payload;
        }

        private string GuessObjectTypeFromComponentNames(List<string> components)
        {
            List<string> cns = new List<string>(components);
            cns.Reverse();
            foreach (string name in cns)
            {
                if (TypeNames.ContainsKey(name))
                {
                    return TypeNames[name];
                }
            }
            return DefaultTypeName;
        }

        private bool GameObjectVisible(Renderer renderer, List<string> components)
        {
            if (gameObject.activeInHierarchy)
            {
                bool light = components.Contains("Light");
                // bool mesh = components.Contains ("MeshRenderer") && components.Contains ("MeshFilter");
                bool particle = components.Contains("ParticleSystem") && components.Contains("ParticleSystemRenderer");
                if (light || particle)
                {
                    return false;
                }
                else
                {
                    return renderer ? renderer.isVisible : true;
                }
            }
            else
            {
                return false;
            }
        }

        private int GameObjectLayer()
        {
            return gameObject.layer;
        }
        private string GameObjectLayerName()
        {
            return LayerMask.LayerToName(gameObject.layer);
        }

        private bool GameObjectClickable(List<string> components)
        {
            Button button = gameObject.GetComponent<Button>();
            return button ? button.isActiveAndEnabled : false;
        }

        private string GameObjectText()
        {
            Text text = gameObject.GetComponent<Text>();
            return text ? text.text : null;
        }

        private string GameObjectTag()
        {
            string tag;
            try
            {
                tag = !gameObject.CompareTag("Untagged") ? gameObject.tag : null;
            }
            catch (UnityException)
            {
                tag = null;
            }
            return tag;
        }

        private List<string> GameObjectAllComponents()
        {
            List<string> components = new List<string>();
            Component[] allComponents = gameObject.GetComponents<Component>();
            if (allComponents != null)
            {
                foreach (Component ac in allComponents)
                {
                    if (ac != null)
                    {
                        components.Add(ac.GetType().Name);
                    }
                }
            }
            return components;
        }

        private Dictionary<string, float> GameObjectzOrders()
        {
            float CameraViewportPoint = 0;
            if (camera != null)
            {
                CameraViewportPoint = Math.Abs(camera.WorldToViewportPoint(gameObject.transform.position).z);
            }
            Dictionary<string, float> zOrders = new Dictionary<string, float>() {
                { "global", 0f },
                { "local", -1 * CameraViewportPoint }
            };
            return zOrders;
        }

        private Rect GameObjectRect(Renderer renderer, RectTransform rectTransform)
        {
            Rect rect = new Rect(0, 0, 0, 0);
            if (renderer)
            {
                rect = RendererToScreenSpace(camera, renderer);
            }
            else if (rectTransform)
            {
                rect = RectTransformToScreenSpace(rectTransform);
            }
            return rect;
        }

        private float[] GameObjectPosInScreen(Vector3 objectPos, Renderer renderer, RectTransform rectTransform, Rect rect)
        {
            float[] pos = { 0f, 0f };

            if (renderer)
            {
                // 3d object
                pos[0] = objectPos.x / (float)Screen.width;
                pos[1] = objectPos.y / (float)Screen.height;
            }
            else if (rectTransform)
            {
                // ui object (rendered on screen space, other render modes may be different)
                // use center pos for now
                Canvas rootCanvas = GetRootCanvas(gameObject);
                RenderMode renderMode = rootCanvas != null ? rootCanvas.renderMode : new RenderMode();
                switch (renderMode)
                {
                    case RenderMode.ScreenSpaceCamera:
                        //上一个方案经过实际测试发现还有两个问题存在
                        //1.在有Canvas Scaler修改了RootCanvas的Scale的情况下坐标的抓取仍然不对，影响到了ScreenSpaceCameram模式在不同分辨率和屏幕比例下识别的兼容性。
                        //2.RectTransformUtility转的 rectTransform.transform.position本质上得到的是RectTransform.pivot中心轴在屏幕上的坐标，如果pivot不等于(0.5,0.5)，
                        //那么获取到的position就不等于图形的中心点。
                        //试了一晚上，找到了解决办法。

                        //用MainCanvas转一次屏幕坐标
                        Vector2 position = RectTransformUtility.WorldToScreenPoint(rootCanvas.worldCamera, rectTransform.transform.position);
                        //注意: 这里的position其实是Pivot点在Screen上的坐标，并不是图形意义上的中心点,在经过下列玄学公式换算才是真的图形中心在屏幕的位置。
                        //公式内算上了rootCanvas.scaleFactor 缩放因子，经测试至少在Canvas Scaler.Expand模式下，什么分辨率和屏幕比都抓的很准，兼容性很强，其他的有待测试。
                        //由于得出来的坐标是左下角为原点，触控输入是左上角为原点，所以要上下反转一下Poco才能用,所以y坐标用Screen.height减去。
                        position.Set(
                            position.x - rectTransform.rect.width * rootCanvas.scaleFactor * (rectTransform.pivot.x - 0.5f),
                            Screen.height - (position.y - rectTransform.rect.height * rootCanvas.scaleFactor * (rectTransform.pivot.y - 0.5f))
                            );
                        pos[0] = position.x / Screen.width;
                        pos[1] = position.y / Screen.height;
                        break;
                    case RenderMode.WorldSpace:
                        Vector2 _pos = RectTransformUtility.WorldToScreenPoint(rootCanvas.worldCamera, rectTransform.transform.position);
                        pos[0] = _pos.x / Screen.width;
                        pos[1] = (Screen.height - _pos.y) / Screen.height;
                        break;
                    default:
                        pos[0] = rect.center.x / (float)Screen.width;
                        pos[1] = rect.center.y / (float)Screen.height;
                        break;
                }
            }
            return pos;
        }

        private Canvas GetRootCanvas(GameObject gameObject)
        {
            Canvas canvas = gameObject.GetComponentInParent<Canvas>();
            // 如果unity版本小于unity5.5，就用递归的方式取吧，没法直接取rootCanvas
            // 如果有用到4.6以下版本的话就自己手动在这里添加条件吧
#if UNITY_4_6 || UNITY_4_7 || UNITY_4_8 || UNITY_4_9 || UNITY_5_0 || UNITY_5_1 || UNITY_5_2 || UNITY_5_3 || UNITY_5_4
			if (canvas && canvas.isRootCanvas) {
				return canvas;
			} else {
				if (gameObject.transform.parent.gameObject != null) {
					return GetRootCanvas(gameObject.transform.parent.gameObject);
				} else {
					return null;
				}
			}
#else
            if (canvas && canvas.isRootCanvas)
            {
                return canvas;
            }
            else if (canvas)
            {
                return canvas.rootCanvas;
            }
            else
            {
                return null;
            }
#endif
        }

        private float[] GameObjectSizeInScreen(Rect rect, RectTransform rectTransform)
        {
            float[] size = { 0f, 0f };
            if (rectTransform)
            {
                Canvas rootCanvas = GetRootCanvas(gameObject);
                RenderMode renderMode = rootCanvas != null ? rootCanvas.renderMode : new RenderMode();
                switch (renderMode)
                {
                    case RenderMode.ScreenSpaceCamera:
                        Rect _rect = RectTransformUtility.PixelAdjustRect(rectTransform, rootCanvas);
                        size = new float[] {
                            _rect.width * rootCanvas.scaleFactor / (float)Screen.width,
                            _rect.height * rootCanvas.scaleFactor / (float)Screen.height
                        };
                        break;
                    case RenderMode.WorldSpace:
                        Rect rect_ = rectTransform.rect;
                        RectTransform canvasTransform = rootCanvas.GetComponent<RectTransform>();
                        size = new float[] { rect_.width / canvasTransform.rect.width, rect_.height / canvasTransform.rect.height };
                        break;
                    default:
                        size = new float[] { rect.width / (float)Screen.width, rect.height / (float)Screen.height };
                        break;
                }
            }
            else
            {
                size = new float[] { rect.width / (float)Screen.width, rect.height / (float)Screen.height };
            }
            return size;
        }

        private float[] GameObjectAnchorInScreen(Renderer renderer, Rect rect, Vector3 objectPos)
        {
            float[] defaultValue = { 0.5f, 0.5f };
            if (rectTransform)
            {
                Vector2 data = rectTransform.pivot;
                defaultValue[0] = data[0];
                defaultValue[1] = 1 - data[1];
                return defaultValue;
            }
            if (!renderer)
            {
                //<Modified> some object do not have renderer
                return defaultValue;
            }
            float[] anchor = { (objectPos.x - rect.xMin) / rect.width, (objectPos.y - rect.yMin) / rect.height };
            if (Double.IsNaN(anchor[0]) || Double.IsNaN(anchor[1]))
            {
                return defaultValue;
            }
            else if (Double.IsPositiveInfinity(anchor[0]) || Double.IsPositiveInfinity(anchor[1]))
            {
                return defaultValue;
            }
            else if (Double.IsNegativeInfinity(anchor[0]) || Double.IsNegativeInfinity(anchor[1]))
            {
                return defaultValue;
            }
            else
            {
                return anchor;
            }
        }

        private string GetImageSourceTexture()
        {
            Image image = gameObject.GetComponent<Image>();
            if (image != null && image.sprite != null)
            {
                return image.sprite.name;
            }

            RawImage rawImage = gameObject.GetComponent<RawImage>();
            if (rawImage != null && rawImage.texture != null)
            {
                return rawImage.texture.name;
            }

            SpriteRenderer spriteRenderer = gameObject.GetComponent<SpriteRenderer>();
            if (spriteRenderer != null && spriteRenderer.sprite != null)
            {
                return spriteRenderer.sprite.name;
            }

            Renderer render = gameObject.GetComponent<Renderer>();
            if (renderer != null && renderer.material != null)
            {
                return renderer.material.color.ToString();
            }

            return null;
        }

        protected static Vector2 WorldToGUIPoint(Camera camera, Vector3 world)
        {
            Vector2 screenPoint = Vector2.zero;
            if (camera != null)
            {
                screenPoint = camera.WorldToScreenPoint(world);
                screenPoint.y = (float)Screen.height - screenPoint.y;
            }
            return screenPoint;
        }

        protected static Rect RendererToScreenSpace(Camera camera, Renderer renderer)
        {
            Vector3 cen = renderer.bounds.center;
            Vector3 ext = renderer.bounds.extents;
            Vector2[] extentPoints = new Vector2[8] {
                WorldToGUIPoint (camera, new Vector3 (cen.x - ext.x, cen.y - ext.y, cen.z - ext.z)),
                WorldToGUIPoint (camera, new Vector3 (cen.x + ext.x, cen.y - ext.y, cen.z - ext.z)),
                WorldToGUIPoint (camera, new Vector3 (cen.x - ext.x, cen.y - ext.y, cen.z + ext.z)),
                WorldToGUIPoint (camera, new Vector3 (cen.x + ext.x, cen.y - ext.y, cen.z + ext.z)),
                WorldToGUIPoint (camera, new Vector3 (cen.x - ext.x, cen.y + ext.y, cen.z - ext.z)),
                WorldToGUIPoint (camera, new Vector3 (cen.x + ext.x, cen.y + ext.y, cen.z - ext.z)),
                WorldToGUIPoint (camera, new Vector3 (cen.x - ext.x, cen.y + ext.y, cen.z + ext.z)),
                WorldToGUIPoint (camera, new Vector3 (cen.x + ext.x, cen.y + ext.y, cen.z + ext.z))
            };
            Vector2 min = extentPoints[0];
            Vector2 max = extentPoints[0];
            foreach (Vector2 v in extentPoints)
            {
                min = Vector2.Min(min, v);
                max = Vector2.Max(max, v);
            }
            return new Rect(min.x, min.y, max.x - min.x, max.y - min.y);
        }

        protected static Rect RectTransformToScreenSpace(RectTransform rectTransform)
        {
            Vector2 size = Vector2.Scale(rectTransform.rect.size, rectTransform.lossyScale);
            Rect rect = new Rect(rectTransform.position.x, Screen.height - rectTransform.position.y, size.x, size.y);
            rect.x -= (rectTransform.pivot.x * size.x);
            rect.y -= ((1.0f - rectTransform.pivot.y) * size.y);
            return rect;
        }

        public static bool SetText(GameObject go, string textVal)
        {
            if (go != null)
            {
                var inputField = go.GetComponent<InputField>();
                if (inputField != null)
                {
                    inputField.text = textVal;
                    return true;
                }
            }
            return false;
        }
    }
}