using System;
using System.Windows.Forms;
using DevComponents.DotNetBar;
using GeoScene.Data;
using GeoScene.Globe;
using GeoScene.Engine;
using System.Xml;

namespace Cyberpipe
{
    public partial class FrmLayerControl : Office2007Form
    {
        GSOGlobeControl globeControl1;
        GSOGlobeControl globeControl2;

        TreeNode terrainManagerNode = null;
        TreeNode layerManagerNode = null;
        TreeNode terrainManagerNode1 = null;
        TreeNode layerManagerNode1 = null;
        
        public FrmLayerControl(GSOGlobeControl ctl1,GSOGlobeControl ctl2)
        {
            InitializeComponent();
            globeControl1 = ctl1;
            globeControl2 = ctl2;
        }

        private void initLayerTree(out TreeNode treeNode, string strTreeNodeText)
        {
            treeNode=new TreeNode();
            treeNode.ImageIndex = 0;
            treeNode.SelectedImageIndex = 0;
            treeNode.Checked = false;
            treeNode.Text = strTreeNodeText;
        }

        private void initTreeView()
        {
            layerTree1.Nodes.Clear();
            layerTree2.Nodes.Clear();

            //加载layertree2
            initLayerTree(out layerManagerNode1, "图层管理");
            layerTree1.Nodes.Add(layerManagerNode1);
            initLayerTree(out terrainManagerNode1, "地形管理");
            layerTree1.Nodes.Add(terrainManagerNode1);

            initLayerTree(out layerManagerNode, "图层管理");
            layerTree2.Nodes.Add(layerManagerNode);
            initLayerTree(out terrainManagerNode, "地形管理");
            layerTree2.Nodes.Add(terrainManagerNode);
        }

        private void initNode(string nodeName)
        {
            TreeNode nodeGroupElse1 = new TreeNode();
            nodeGroupElse1.Text = nodeName;
            layerTree1.Nodes[0].Nodes.Add(nodeGroupElse1);

            TreeNode nodeGroupElse = new TreeNode();
            nodeGroupElse.Text = nodeName == "供电" ? "电力" : nodeName;
            layerTree2.Nodes[0].Nodes.Add(nodeGroupElse);
        }

        private void initTreeNode(XmlNodeList Params)
        {
            foreach (XmlNode paramsNode in Params) //layers
            {
                foreach (XmlNode layerNode in paramsNode) //layer
                {
                    initNode(layerNode.Attributes["label"].Value);
                }
            }

            initNode("基础图层");
            initNode("其他");
        }

        private void FrmLayerControl_Load(object sender, EventArgs e)
        {
            initTreeView();
            try
            {
                XmlDocument doc = new XmlDocument();
                doc.Load(Application.StartupPath + "\\双屏设置.xml");
                XmlNodeList Params = doc.SelectNodes("/Params/layers");

                initTreeNode(Params);
            }
            catch (Exception ex)
            {
                LogError.PublishError(ex);
            }

            RefreshLayerAndTerrainTree();
        }

        private void addLayerTreeNode(int nLayerCount, int nTerrainCount, GSOGlobeControl globcontrol,
            TreeView layerTree)
        {
            try
            {
                for (int i = 0; i < nLayerCount; i++)
                {
                    GSOLayer layer = globcontrol.Globe.Layers[i];
                    if (layer == null) continue;
                    string layerName = layer.Name;
                    TreeNode node = new TreeNode();
                    node.Tag = layer;
                    node.ImageIndex = 0;
                    node.SelectedImageIndex = 0;
                    node.Text = layer.Caption;
                    node.Checked = layer.Visible;

                    bool isContains = false;
                    for (int j = 0; j < layerTree.Nodes[0].Nodes.Count; j++)
                    {
                        if (!layerName.Contains("fttp:"))
                        {
                            switch (layerTree.Name)
                            {
                                case "layerTree1":
                                    if (!layerName.Contains(layerTree.Nodes[0].Nodes[j].Text.Trim()) ||
                                        layerName.Contains("施工") ||
                                        layerName.Contains("规划")) continue;
                                    break;
                                case "layerTree2":
                                    if (!layerName.Contains(layerTree.Nodes[0].Nodes[j].Text.Trim())) continue;
                                    break;
                                default:
                                    break;
                            }

                            layerTree.Nodes[0].Nodes[j].Nodes.Add(node);
                            isContains = true;
                            break;
                        }
                        else
                        {
                            layerTree.Nodes[0].Nodes[layerTree.Nodes[0].Nodes.Count - 2].Nodes.Add(node);
                            isContains = true;
                            break;
                        }
                    }
                    switch (layerTree.Name)
                    {
                        case "layerTree1":
                            if (layerName.Contains("tempLgdData") || layerName.Contains("城市") ||
                                layerName.Contains("标注") ||
                                isContains == true || layerName.Contains("施工") || layerName.Contains("规划") ||
                                layerName.Contains("景观") || layerName.Contains("红线"))
                                continue;
                            break;
                        case "layerTree2":
                            if (isContains != false || layerName.Contains("tempLgdData2"))
                                continue;
                            break;
                        default:
                            break;
                    }

                    layerTree.Nodes[0].Nodes[layerTree.Nodes[0].Nodes.Count - 1].Nodes.Add(node);
                }

                for (int i = 0; i < nTerrainCount; i++)
                {
                    GSOTerrain terrain = globcontrol.Globe.Terrains[i];
                    if (terrain == null) continue;
                    TreeNode node = new TreeNode();
                    node.Tag = terrain;
                    node.ImageIndex = 0;
                    node.SelectedImageIndex = 0;
                    node.Text = terrain.Caption;
                    node.Checked = terrain.Visible;
                    switch (layerTree.Name)
                    {
                        case "layerTree1":
                            terrainManagerNode1.Nodes.Add(node);
                            break;
                        case "layerTree2":
                            terrainManagerNode.Nodes.Add(node);
                            break;
                        default:
                            break;
                    }
                }
            }
            catch (Exception ex)
            {
                LogError.PublishError(ex);
            }
        }

        private void initTreeNodeCheckedStatus(TreeView layerTreeView)
        {
            //节点选中状态控制
            foreach (TreeNode node in layerTreeView.Nodes[0].Nodes)
            {
                foreach (TreeNode childNode in node.Nodes)
                {
                    GSOLayer layer = childNode.Tag as GSOLayer;
                    if (layer == null || layer.Visible != true) continue;
                    node.Checked = true;
                    break;
                }
            }
            
            foreach (TreeNode node in layerTreeView.Nodes[0].Nodes)
            {
                if (node.Checked != true) continue;
                layerTreeView.Nodes[0].Checked = true;
                break;
            }
             
            foreach (TreeNode node in layerTreeView.Nodes[1].Nodes)
            {
                foreach (TreeNode childNode in node.Nodes)
                {
                    GSOTerrain layer = childNode.Tag as GSOTerrain;
                    if (layer == null || layer.Visible != true) continue;
                    node.Checked = true;
                    break;
                }
            }
        }

        void exPandTreeNode()
        {
            layerManagerNode1.Expand();
            terrainManagerNode1.Expand();
            layerManagerNode.Expand();
            terrainManagerNode.Expand();
        }
        /// <summary>
        /// 刷新节点树
        /// </summary>
        private void RefreshLayerAndTerrainTree()
        {
            int nLayerCount1 = globeControl1.Globe.Layers.Count;//图层
            int nTerrainCount1 = globeControl1.Globe.Terrains.Count;//地形
            addLayerTreeNode(nLayerCount1, nTerrainCount1, globeControl1, layerTree1);
            initTreeNodeCheckedStatus(layerTree1);

            int nLayerCount = globeControl2.Globe.Layers.Count;
            int nTerrainCount = globeControl2.Globe.Terrains.Count;
            addLayerTreeNode(nLayerCount, nTerrainCount, globeControl2, layerTree2);
            initTreeNodeCheckedStatus(layerTree2);
            
            // 展开
            exPandTreeNode();
        }

        /// <summary>
        /// 节点树复选框选中状态改变事件处理
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void layerTree2_AfterCheck(object sender, TreeViewEventArgs e)
        {
            if (e.Action != TreeViewAction.Unknown)
            {
                if (e.Node.Tag != null)
                {
                    if (e.Node.Tag is GSOLayer)
                    {
                        GSOLayer layer = e.Node.Tag as GSOLayer;
                        if (layer != null)
                        {
                            layer.Visible = e.Node.Checked;
                            globeControl2.Globe.Refresh();
                        }
                    }
                    if (e.Node.Tag is GSOTerrain)
                    {
                        GSOTerrain feat = e.Node.Tag as GSOTerrain;
                        feat.Visible = e.Node.Checked;
                        globeControl2.Globe.Refresh();
                    }
                }

                CheckParentNode(e.Node);
                if (e.Node.Nodes.Count > 0)
                    checkChildrenNodeLayertree2(e.Node, e.Node.Checked);
            }
        }
        /// <summary>
        /// 改变指定节点的子节点的选中状态
        /// </summary>
        /// <param name="parentNode"></param>
        /// <param name="isChecked"></param>
        private void checkChildrenNodeLayertree1(TreeNode parentNode, bool isChecked)
        {
            foreach (TreeNode childNode in parentNode.Nodes)
            {
                childNode.Checked = isChecked;
                if (childNode.Tag is GSOLayer)
                {
                    GSOLayer layer = childNode.Tag as GSOLayer;
                    if (layer != null)
                    {
                        layer.Visible = isChecked;
                        globeControl1.Globe.Refresh();
                    }
                }
                if (childNode.Tag is GSOTerrain)
                {
                    GSOTerrain feat = childNode.Tag as GSOTerrain;
                    feat.Visible = isChecked;
                    globeControl1.Globe.Refresh();
                }
                if (childNode.Nodes.Count > 0)
                    checkChildrenNodeLayertree1(childNode, isChecked);
            }
        }
        /// <summary>
        /// 改变指定节点的子节点的选中状态
        /// </summary>
        /// <param name="parentNode"></param>
        /// <param name="isChecked"></param>
        private void checkChildrenNodeLayertree2(TreeNode parentNode, bool isChecked)
        {
            foreach (TreeNode childNode in parentNode.Nodes)
            {
                childNode.Checked = isChecked;
                if (childNode.Tag is GSOLayer)
                {
                    GSOLayer layer = childNode.Tag as GSOLayer;
                    if (layer != null)
                    {
                        layer.Visible = isChecked;
                        globeControl2.Globe.Refresh();
                    }
                }
                if (childNode.Tag is GSOTerrain)
                {
                    GSOTerrain feat = childNode.Tag as GSOTerrain;
                    feat.Visible = isChecked;
                    globeControl2.Globe.Refresh();
                }
                if (childNode.Nodes.Count > 0)
                    checkChildrenNodeLayertree2(childNode, isChecked);
            }
        }
        /// <summary>
        /// 节点树选中状态改变事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void layerTree1_AfterCheck(object sender, TreeViewEventArgs e)
        {
            if (e.Action != TreeViewAction.Unknown)
            {
                if (e.Node.Tag != null)
                {
                    if (e.Node.Tag is GSOLayer)
                    {
                        GSOLayer layer = e.Node.Tag as GSOLayer;
                        if (layer != null)
                        {
                            layer.Visible = e.Node.Checked;
                            globeControl1.Globe.Refresh();
                        }
                    }
                    if (e.Node.Tag is GSOTerrain)
                    {
                        GSOTerrain feat = e.Node.Tag as GSOTerrain;
                        feat.Visible = e.Node.Checked;
                        globeControl1.Globe.Refresh();
                    }
                }

                CheckParentNode(e.Node);
                if (e.Node.Nodes.Count > 0)
                    checkChildrenNodeLayertree1(e.Node, e.Node.Checked);
            }
        }
        /// <summary>
        /// 改变父节点的选中状态，此处为所有子节点不选中时才取消父节点选中，可以根据需要修改
        /// </summary>
        /// <param name="curNode"></param>
        private void CheckParentNode(TreeNode curNode)
        {
            bool bChecked = false;

            if (curNode.Parent != null)
            {
                foreach (TreeNode node in curNode.Parent.Nodes)
                {
                    if (node.Checked)
                    {
                        bChecked = true;
                        break;
                    }
                }
                if (bChecked)
                {
                    curNode.Parent.Checked = true;
                    CheckParentNode(curNode.Parent);
                }
                else
                {
                    curNode.Parent.Checked = false;
                    CheckParentNode(curNode.Parent);
                }
            }
        }
    }
}