using QFramework;
using QFramework.Example;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Xml;
using System.Xml.Linq;
using UnityEngine;

using static XMLTool.Body3D;
namespace XMLTool
{
    public class AppData
    {
        public PreLoad preLoad;
        public List<Module> Modules
        {
            get; set;
        }
    }


    public class PreLoad
    {
        public Action action;
    }

    public class Module
    {

        public string type
        {
            get; set;
        }
        public string Scene
        {
            get; set;
        }
        public string ModuleName
        {
            get; set;
        }
        public string Descript
        {
            get; set;
        }

        public string OnlyCurScore
        {
            get; set;
        }
        public string Icon
        {
            get; set;
        }

        public List<Operation> Operations
        {
            get; set;
        }
        public List<Device> Devices
        {
            get; set;
        }

        public Dictionary<string, FSM> FSM = new Dictionary<string, FSM>();
        public Dictionary<string, Action> ActionDict
        {
            get; set;
        }

        public Score score;

        public Body3D body3d;

        public Knowledge knowledge;
    }

    public class Device
    {
        public string Name
        {
            get; set;
        }
        public string Icon
        {
            get; set;
        }
        public string HighColor
        {
            get; set;
        }
        public string Path
        {
            get; set;
        }
        public string Tip
        {
            get; set;
        }
        public string BoxColliderSize
        {
            get; set;
        }
        public string BoxColliderCenter
        {
            get; set;
        }
        public bool MeshCollider
        {
            get; set;
        }

        // 可以限制场景中一共有多少个此道具 -1 代表无限多
        public int Count = -1;

        public RightMenu rightMenu;
    }

    public class RightMenu
    {
        public List<string> items = new List<string>();
    }



    public class Score
    {
        public List<ScoreStep> scores;
    }
    public class ScoreStep
    {
        public string step;
        public string name;
        public string sum;
        public string bind;
        public float value;
        public string time;
        public string timeFormat = "yyyy-MM-dd HH:mm:ss";
    }




    public class ActionItem
    {
        public string Name
        {
            get; set;
        }
        public string Type
        {
            get; set;
        }
        public string Value
        {
            get; set;
        }
        public List<ActionItem> SubActions
        {
            get; set;
        }

    }

    public class Action : ActionItem
    {
    }

    public class Point3DQuestion : Action
    {
        public class Data
        {
            public string name;
            public string deviceName;
            public Vector3 pos;
            public Vector3 rotate;
            public Vector3 scale;
            public float rotateSpeed;
            public int order = 1;
            public string clickEvent;
        }
        public List<Data> datas = new List<Data>();
    }


    public class InputAction : Action
    {
        public UIInputData data;
    }

    public class Show3DAction : Action
    {
        public UI3DObjShowData data;
    }


    public class Condition : ActionItem
    {
    }



    public class FSM
    {
        public string Name
        {
            get; set;
        }
        public List<Transision> Transisions
        {
            get; set;
        }
        public Dictionary<string, State> StateDict
        {
            get; set;
        }

    }
    public class State
    {
        public string Name
        {
            get; set;
        }
        public StatePart Enter
        {
            get; set;
        }
        public StatePart Exit
        {
            get; set;
        }

    }
    public class StatePart
    {
        public Action Action
        {
            get; set;
        }
    }

    public class Transision
    {

        public string Name
        {
            get; set;
        }
        public string From
        {
            get; set;
        }
        public string To
        {
            get; set;
        }
        public Condition Action
        {
            get; set;
        }
    }

    public class Operation
    {
        public string name;
        public string moduleType
        {
            get; set;
        }
        public bool freeStep
        {
            get; set;
        }
        public List<Step> Steps
        {
            get; set;
        }
    }
    public class Step
    {
        public Step Parent
        {
            get; set;
        }
        public string Name
        {
            get; set;
        }
        public Action Reset
        {
            get; set;
        }
        public Action Start
        {
            get; set;
        }
        public Action Finished
        {
            get; set;
        }
        public bool isFinished = false;
        public List<Step> SubSteps
        {
            get; set;
        }
    }


    public class Body3D
    {
        public class Body
        {
            public string Icon
            {
                get; set;
            }
            public string Name
            {
                get; set;
            }
            public string Path
            {
                get; set;
            }

            public string Tip
            {
                get; set;
            }

            public string Audio
            {
                get; set;
            }

            public string FocusDistance
            {
                get; set;
            }

            public bool isShow = false;

            public bool isBodyList = false;

            public ObjectToggle toggle;
            public Dictionary<string, Body> subBody { get; set; } = new Dictionary<string, Body>();

            public Body parent;
            //public Dictionary<string, Body> bodyList { get; set; } = new Dictionary<string, Body>();
        }


        public Dictionary<string, Body> parts = new Dictionary<string, Body>();

    }

    public class ObjectToggle
    {
        public ColorToggle color;
    }

    public class ColorToggle
    {
        public string isOn;
        public string isOff;
    }

    public class Knowledge
    {
        public class Item
        {
            public class Component
            {
                public string type;
                public string size;
                public string pos;
                public Action action;
            }
            public string title;
            public string bgImage;
            public string setPos;
            public List<Item> subs;
            public List<Component> components;
        }
        public string bgImage;
        public List<Item> items;
        public List<Item.Component> components;
    }





    public class XmlParser
    {
        public static AppData ParseXml(string xmlString)
        {
            // 加载XML
            XDocument doc = XDocument.Parse(xmlString);

            // 获取根元素
            XElement appDataElement = doc.Root;

            // 初始化AppData对象
            AppData appData = new AppData
            {
                Modules = new List<Module>(),
            };


            // 解析预加载动作
            var preLoadElement = appDataElement.Element("PreLoad");
            if (preLoadElement != null)
            {
                appData.preLoad = new PreLoad();
                foreach (XElement actionElement in preLoadElement.Elements("Action"))
                {
                    var action = ParseAction(actionElement);
                    appData.preLoad.action = action;
                }
            }


            // 加载模块数据
            LoadModules(appDataElement, appData);

            return appData;
        }




        public static void LoadModules(XElement appDataElement, AppData appData)
        {

            foreach (XElement moduleElement in appDataElement.Elements("Module"))
            {
                LoadModule(moduleElement, appData);
            }
        }

        public static void LoadModule(XElement moduleElement, AppData appData)
        {
            if (moduleElement != null)
            {
                Module module = new Module()
                {
                    Devices = new List<Device>(),
                    ActionDict = new Dictionary<string, Action>(),
                    Operations = new List<Operation>(),
                };
                appData.Modules.Add(module);
                // 解析模块名称
                module.type = moduleElement.Element("Type")?.Value;
                module.ModuleName = moduleElement.Element("Name")?.Value;
                module.Icon = moduleElement.Element("Icon")?.Value;
                module.OnlyCurScore = moduleElement.Element("OnlyCurScore")?.Value;
                module.Descript = moduleElement.Element("Descript")?.Value.Trim();
                module.Scene = moduleElement.Element("Scene")?.Value;

                // 解析设备
                foreach (XElement deviceElement in moduleElement.Elements("Device"))
                {
                    Device device = new Device
                    {
                        Name = deviceElement.Element("Name")?.Value,
                        Icon = deviceElement.Element("Icon")?.Value,
                        HighColor = deviceElement.Element("HighLight")?.Attribute("color")?.Value,
                        Path = deviceElement.Element("Path")?.Value,
                        Tip = deviceElement.Element("Tip")?.Value,
                        MeshCollider = deviceElement.Element("MeshCollider") != null,
                        BoxColliderCenter = deviceElement.Element("BoxCollider")?.Attribute("center")?.Value,
                        BoxColliderSize = deviceElement.Element("BoxCollider")?.Attribute("size")?.Value,

                    };


                    var menuElment = deviceElement.Element("RightMenu");
                    if (menuElment != null)
                    {
                        device.rightMenu = new RightMenu();
                        var atrr = menuElment.Attribute("values");
                        if (atrr != null)
                        {
                            device.rightMenu.items = atrr.Value.Split(',').ToList();
                        }
                    }

                    module.Devices.Add(device);
                }
                // 解析动作
                foreach (XElement actionElement in moduleElement.Elements("Action"))
                {
                    var action = ParseAction(actionElement);
                    // 解析动作
                    module.ActionDict.Add(action.Name, action);
                }
                // 解析状态机
                foreach (XElement fsmElement in moduleElement.Elements("FSM"))
                {
                    FSM fsm = new FSM()
                    {
                        Name = fsmElement.Attribute("name")?.Value,
                        StateDict = new Dictionary<string, State>(),
                        Transisions = new List<Transision>(),

                    };

                    // 解析状态
                    foreach (var stateNode in fsmElement.Elements("State"))
                    {
                        State state = new State()
                        {
                            Name = stateNode.Attribute("name")?.Value,
                        };
                        fsm.StateDict.Add(state.Name, state);

                        XElement enterElement = stateNode.Element("Enter");
                        XElement exitElement = stateNode.Element("Exit");
                        if (enterElement != null)
                        {
                            state.Enter = new StatePart();
                            state.Enter.Action = ParseAction(enterElement.Element("Action"));
                        }
                        if (exitElement != null)
                        {
                            state.Exit = new StatePart();
                            state.Exit.Action = ParseAction(exitElement.Element("Action"));
                        }

                    }
                    // 解析状态转换
                    foreach (var transNode in fsmElement.Elements("Transision"))
                    {
                        Transision trans = new Transision()
                        {
                            Name = transNode.Attribute("name")?.Value,
                            From = transNode.Attribute("from")?.Value,
                            To = transNode.Attribute("to")?.Value,
                        };
                        trans.Action = ParseCondition(transNode.Element("Condition"));
                        fsm.Transisions.Add(trans);
                    }
                    module.FSM.Add(fsm.Name, fsm);
                }
                // 解析操作列表
                foreach (var operationNode in moduleElement.Elements("Operation"))
                {
                    //module.Operations
                    // 解析操作步骤

                    var op = new Operation()
                    {
                        Steps = new List<Step>(),
                    };
                    op.name = operationNode.Attribute("name")?.Value;
                    op.moduleType = operationNode.Attribute("moduleType")?.Value;
                    var free = operationNode.Attribute("freeStep");
                    bool isFree = true;
                    if (free != null)
                    {
                        bool.TryParse(free.Value, out isFree);
                    }
                    op.freeStep = isFree;
                    foreach (XElement stepNode in operationNode.Elements("Step"))
                    {
                        op.Steps.Add(ParserStep(stepNode, null));
                    }
                    module.Operations.Add(op);
                }
                // 解析3DBody
                var body3d = moduleElement.Element("Body3D");
                if (body3d != null)
                {
                    module.body3d = new Body3D();
                    foreach (var item in body3d.Elements("Body"))
                    {
                        var part = ParseBody(item);
                        module.body3d.parts.Add(part.Name, part);
                    }
                }
                // 解析评分
                XElement scoreNode = moduleElement.Element("Score");
                if (scoreNode != null)
                {
                    module.score = new Score()
                    {
                        scores = new List<ScoreStep>()
                    };
                    foreach (var item in scoreNode.Elements("Item"))
                    {
                        module.score.scores.Add(
                            new ScoreStep()
                            {
                                step = item.Attribute("step")?.Value,
                                name = item.Attribute("name")?.Value,
                                sum = item.Attribute("sum")?.Value,
                                bind = item.Attribute("bind")?.Value,
                                timeFormat = item.Attribute("timeFormat")?.Value,
                            });
                    }
                }
                // 解析知识点
                var knowledge = moduleElement.Element("Knowledge");
                if (knowledge != null)
                {
                    module.knowledge = new Knowledge();
                    module.knowledge.bgImage = knowledge.Attribute("bgImage")?.Value;
                    foreach (var itemXml in knowledge.Elements("Item"))
                    {
                        Knowledge.Item item = ParserKnowledgeItem(itemXml);
                        if (module.knowledge.items == null)
                        {
                            module.knowledge.items = new List<Knowledge.Item>();
                        }
                        module.knowledge.items.Add(item);
                    }

                    module.knowledge.components = ParserKnowledgeComponet(knowledge);
                }
            }
        }

        private static Knowledge.Item ParserKnowledgeItem(XElement itemXml)
        {
            Knowledge.Item item = new Knowledge.Item();
            item.title = itemXml.Attribute("title")?.Value;
            item.bgImage = itemXml.Attribute("bgImage")?.Value;
            item.setPos = itemXml.Attribute("setPos")?.Value;
            item.components = ParserKnowledgeComponet(itemXml);
            foreach (var subXml in itemXml.Elements("Item"))
            {
                if (item.subs == null)
                {
                    item.subs = new List<Knowledge.Item>();
                }
                // 增加子物体
                item.subs.Add(ParserKnowledgeItem(subXml));
            }
            return item;
        }

        private static List<Knowledge.Item.Component> ParserKnowledgeComponet(XElement xmlData)
        {
            List<Knowledge.Item.Component> list = null;
            foreach (var componentXml in xmlData.Elements("Component"))
            {
                if (list == null)
                {
                    list = new List<Knowledge.Item.Component>();
                }
                Knowledge.Item.Component component = new Knowledge.Item.Component();
                component.type = componentXml.Attribute("type")?.Value;
                component.pos = componentXml.Attribute("pos")?.Value;
                component.size = componentXml.Attribute("size")?.Value;
                component.action = ParseAction(componentXml.Element("Action"));
                list.Add(component);
            }
            return list;
        }


        private static Body3D.Body ParseBody(XElement bodyElement, Body parent = null)
        {
            Body3D.Body body = new Body3D.Body
            {
                Icon = bodyElement.Attribute("icon")?.Value,
                Name = bodyElement.Attribute("name")?.Value,
                Path = bodyElement.Attribute("path")?.Value,
                Tip = bodyElement.Attribute("tip")?.Value,
                Audio = bodyElement.Attribute("audio")?.Value,
                FocusDistance = bodyElement.Attribute("FocusDistance")?.Value
            };

            var isShow = bodyElement.Attribute("isShow");
            if (isShow != null)
            {
                bool.TryParse(isShow.Value, out body.isShow);
            }
            var isBodyList = bodyElement.Attribute("isBodyList");
            if (isBodyList != null)
            {
                bool.TryParse(isBodyList.Value, out body.isBodyList);
            }
            var toggle = bodyElement.Element("ObjectToggle");
            if (toggle != null)
            {
                body.toggle = new ObjectToggle();
                var color = toggle.Element("Color");
                if (color != null)
                {
                    body.toggle.color = new ColorToggle();
                    body.toggle.color.isOn = color.Attribute("isOn")?.Value;
                    body.toggle.color.isOff = color.Attribute("isOff")?.Value;
                }
            }
            foreach (var childElement in bodyElement.Elements("Body"))
            {
                var subBody = ParseBody(childElement, body);
                body.subBody.Add(subBody.Name, subBody);
            }
            body.parent = parent;
            return body;
        }



        public static Step ParserStep(XElement stepNode, Step parent)
        {
            Step step = new Step();
            step.Name = stepNode.Attribute("name")?.Value;
            step.Reset = ParseAction(stepNode.Element("Reset")?.Element("Action"));
            step.Start = ParseAction(stepNode.Element("Start")?.Element("Action"));
            step.Finished = ParseAction(stepNode.Element("Finished")?.Element("Action"));
            step.SubSteps = ParserSteps(stepNode, step);
            step.Parent = parent;
            return step;
        }
        public static List<Step> ParserSteps(XElement step, Step parent)
        {
            List<Step> steps = new List<Step>();
            if (step.Elements("Step").Any())
            {
                foreach (var item in step.Elements("Step"))
                {
                    steps.Add(ParserStep(item, parent));
                }
            }
            return steps;
        }

        public static Action ParseAction(XElement action)
        {
            if (action == null)
            {
                return null;
            }

            string type = action.Attribute("type").Value;

            Action newAction = null;

            // 这里是用于扩展Action的字段
            switch (type)
            {
                case "Move":
                case "Rotate":
                case "Scale":
                    {
                        var act = new MoveOrAction();
                        act.to = Utility.GetVector3FromStrArray(action.Attribute("to").Value);
                        act.time = float.Parse(action.Attribute("time").Value);
                        newAction = act;
                    }
                    break;

                case "ReSetZhanShiCameraAction":
                    {
                        var act = new DictionaryAction();
                        var path = action.Attribute("path");
                        if (path != null)
                        {
                            act.args.Add("path", path.Value);
                        }
                        var x = action.Attribute("x");
                        if ( x!= null)
                        {
                            act.args.Add("x", x.Value);
                        }

                        var y = action.Attribute("y");
                        if (y != null)
                        {
                            act.args.Add("y", y.Value);
                        }

                        var Distance = action.Attribute("Distance");
                        if (Distance != null)
                        {
                            act.args.Add("Distance", Distance.Value);
                        }



                        newAction = act;
                    }
                    break;
                case "Anim":
                    {
                        var act = new DictionaryAction();
                        var animName = action.Attribute("animName");
                        if (animName != null)
                        {
                            act.args.Add("animName", animName.Value);
                        }
                        var frame = action.Attribute("frame");
                        if (frame != null)
                        {
                            act.args.Add("frame", frame.Value);
                        }
                        var speed = action.Attribute("speed");
                        if (speed != null)
                        {
                            act.args.Add("speed", speed.Value);
                        }
                        var deviceName = action.Attribute("deviceName");
                        if (deviceName != null)
                        {
                            act.args.Add("deviceName", deviceName.Value);
                        }
                        newAction = act;
                    }
                    break;
                case "UITools":
                    {
                        var act = new DictionaryAction();
                        act.args.Add("devices", action.Attribute("devices").Value);
                        act.args.Add("answers", action.Attribute("answers").Value);
                        var setActive = action.Attribute("setActive");
                        if (setActive != null)
                        {
                            act.args.Add("setActive", setActive.Value);
                        }
                        var rightLabel = action.Attribute("rightLabel");
                        if (rightLabel != null)
                        {
                            act.args.Add("rightLabel", rightLabel.Value);
                        }
                        var wrongLabel = action.Attribute("wrongLabel");
                        if (wrongLabel != null)
                        {
                            act.args.Add("wrongLabel", wrongLabel.Value);
                        }
                        var rightEvent = action.Attribute("rightEvent");
                        if (rightEvent != null)
                        {
                            act.args.Add("rightEvent", rightEvent.Value);
                        }
                        var wrongEvent = action.Attribute("wrongEvent");
                        if (wrongEvent != null)
                        {
                            act.args.Add("wrongEvent", wrongEvent.Value);
                        }
                        var rightScore = action.Attribute("rightScore");
                        if (rightScore != null)
                        {
                            act.args.Add("rightScore", rightScore.Value);
                        }
                        var wrongScore = action.Attribute("wrongScore");
                        if (wrongScore != null)
                        {
                            act.args.Add("wrongScore", wrongScore.Value);
                        }
                        var totalScore = action.Attribute("totalScore");
                        if (totalScore != null)
                        {
                            act.args.Add("totalScore", totalScore.Value);
                        }
                        var scoreStepName = action.Attribute("scoreStepName");
                        if (scoreStepName != null)
                        {
                            act.args.Add("scoreStepName", scoreStepName.Value);
                        }
                        var autoHide = action.Attribute("autoHide");
                        if (autoHide != null)
                        {
                            act.args.Add("autoHide", autoHide.Value);
                        }
                        var random = action.Attribute("random");
                        if (random != null)
                        {
                            act.args.Add("random", random.Value);
                        }
                        var scrollSpeed = action.Attribute("scrollSpeed");
                        if (scrollSpeed != null)
                        {
                            act.args.Add("scrollSpeed", scrollSpeed.Value);
                        }
                        var position = action.Attribute("position");
                        if (position != null)
                        {
                            act.args.Add("position", position.Value);
                        }
                        var wrongCount = action.Attribute("wrongCount");
                        if (wrongCount != null)
                        {
                            act.args.Add("wrongCount", wrongCount.Value);
                        }
                        newAction = act;
                    }
                    break;
                case "UIBackPack":
                    {
                        var act = new DictionaryAction();
                        act.args.Add("devices", action.Attribute("devices").Value);
                        var random = action.Attribute("random");
                        if (random != null)
                        {
                            act.args.Add("random", random.Value);
                        }
                        var scrollSpeed = action.Attribute("scrollSpeed");
                        if (scrollSpeed != null)
                        {
                            act.args.Add("scrollSpeed", scrollSpeed.Value);
                        }
                        var position = action.Attribute("position");
                        if (position != null)
                        {
                            act.args.Add("position", position.Value);
                        }
                        newAction = act;
                    }
                    break;
                case "TextQuestion":
                    {
                        var act = new DictionaryAction();
                        XAttribute title = action.Attribute("title");
                        if (title != null)
                        {
                            act.args.Add("title", title.Value);
                        }
                        XAttribute options = action.Attribute("options");
                        if (options != null)
                        {
                            act.args.Add("options", options.Value);
                        }
                        XAttribute answers = action.Attribute("answers");
                        if (answers != null)
                        {
                            act.args.Add("answers", answers.Value);
                        }
                        XAttribute btns = action.Attribute("btns");
                        if (btns != null)
                        {
                            act.args.Add("btns", btns.Value);
                        }
                        XAttribute wait = action.Attribute("wait");
                        if (wait != null)
                        {
                            act.args.Add("wait", wait.Value);
                        }
                        XAttribute showAnswer = action.Attribute("showAnswer");
                        if (showAnswer != null)
                        {
                            act.args.Add("showAnswer", showAnswer.Value);
                        }
                        XAttribute rightScore = action.Attribute("rightScore");
                        if (rightScore != null)
                        {
                            act.args.Add("rightScore", rightScore.Value);
                        }
                        XAttribute errorScore = action.Attribute("wrongScore");
                        if (errorScore != null)
                        {
                            act.args.Add("errorScore", errorScore.Value);
                        }
                        XAttribute scoreName = action.Attribute("scoreName");
                        if (scoreName != null)
                        {
                            act.args.Add("scoreName", scoreName.Value);
                        }
                        XAttribute absolutely = action.Attribute("absolutely");
                        if (absolutely != null)
                        {
                            act.args.Add("absolutely", absolutely.Value);
                        }

                        XAttribute format = action.Attribute("format");
                        if (format != null)
                        {
                            act.args.Add("format", format.Value);
                        }
                        XAttribute finishedEvent = action.Attribute("finishedEvent");
                        if (finishedEvent != null)
                        {
                            act.args.Add("finishedEvent", finishedEvent.Value);
                        }
                        XAttribute optionType = action.Attribute("optionType");
                        if (optionType != null)
                        {
                            act.args.Add("optionType", optionType.Value);
                        }
                        newAction = act;
                    }
                    break;
                case "UIShow":
                    {
                        var act = new StringListAction();
                        XAttribute isShow = action.Attribute("isShow");
                        if (isShow == null)
                        {
                            act.args.Add("true");
                        }
                        else
                        {
                            act.args.Add(isShow.Value);
                        }

                        newAction = act;
                    }
                    break;
                case "Hint":
                    {
                        var act = new StringListAction();
                        XAttribute time = action.Attribute("time");
                        if (time != null)
                        {
                            act.args.Add(time.Value);
                        }
                        else
                        {
                            act.args.Add("-1");
                        }
                        XAttribute icon = action.Attribute("icon");
                        if (icon != null)
                        {
                            act.args.Add(icon.Value);
                        }
                        else
                        {
                            act.args.Add("true");
                        }
                        XAttribute audio = action.Attribute("audio");
                        if (audio != null)
                        {
                            act.args.Add(audio.Value);
                        }
                        else
                        {
                            act.args.Add("");
                        }
                        newAction = act;
                    }
                    break;
                case "Show":
                    {
                        var act = new DictionaryAction();
                        XAttribute isShow = action.Attribute("isShow");
                        if (isShow != null)
                        {
                            act.args.Add("isShow", isShow.Value);
                        }

                        XAttribute isDevice = action.Attribute("isDevice");
                        if (isDevice != null)
                        {
                            act.args.Add("isDevice", isDevice.Value);
                        }
                        XAttribute deviceName = action.Attribute("deviceName");
                        if (deviceName != null)
                        {
                            act.args.Add("deviceName", deviceName.Value);
                        }
                        XAttribute isRoot = action.Attribute("isRoot");
                        if (isRoot != null)
                        {
                            act.args.Add("isRoot", isRoot.Value);
                        }
                        newAction = act;
                    }
                    break;
                case "CameraSwitch":
                    {
                        var act = new DictionaryAction();
                        XAttribute nearDevice = action.Attribute("nearDevice");
                        if (nearDevice != null)
                        {
                            act.args.Add("nearDevice", nearDevice.Value);
                        }
                        else
                        {
                            XAttribute nearPos = action.Attribute("nearPos");
                            if (nearPos != null)
                            {
                                act.args.Add("nearPos", nearPos.Value);
                            }
                            XAttribute nearRot = action.Attribute("nearRot");
                            if (nearRot != null)
                            {
                                act.args.Add("nearRot", nearRot.Value);
                            }
                        }

                        XAttribute normalDevice = action.Attribute("normalDevice");
                        if (normalDevice != null)
                        {
                            act.args.Add("normalDevice", normalDevice.Value);
                        }
                        else
                        {
                            XAttribute normalPos = action.Attribute("normalPos");
                            if (normalPos != null)
                            {
                                act.args.Add("normalPos", normalPos.Value);
                            }
                            XAttribute normalRot = action.Attribute("normalRot");
                            if (normalRot != null)
                            {
                                act.args.Add("normalRot", normalRot.Value);
                            }
                        }

                        XAttribute nearTime = action.Attribute("nearTime");
                        if (nearTime != null)
                        {
                            act.args.Add("nearTime", nearTime.Value);
                        }
                        else
                        {
                            act.args.Add("nearTime", "0");
                        }

                        XAttribute normalTime = action.Attribute("normalTime");
                        if (normalTime != null)
                        {
                            act.args.Add("normalTime", normalTime.Value);
                        }
                        else
                        {
                            act.args.Add("normalTime", "0");
                        }
                        XAttribute isOn = action.Attribute("isOn");
                        if (isOn != null)
                        {
                            act.args.Add("isOn", isOn.Value);
                        }

                        XAttribute vrPos = action.Attribute("vrPos");
                        if (vrPos != null)
                        {
                            act.args.Add("vrPos", vrPos.Value);
                        }
                        XAttribute vrRot = action.Attribute("vrRot");
                        if (vrRot != null)
                        {
                            act.args.Add("vrRot", vrRot.Value);
                        }


                        XAttribute vrTime = action.Attribute("vrTime");
                        if (vrTime != null)
                        {
                            act.args.Add("vrTime", vrTime.Value);
                        }
                        else
                        {
                            act.args.Add("vrTime", "0");
                        }


                        newAction = act;
                    }
                    break;
                case "CameraLock":
                    {
                        var act = new DictionaryAction();
                        XAttribute isMove = action.Attribute("isMove");
                        if (isMove != null)
                        {
                            act.args.Add("isMove", isMove.Value);
                        }
                        XAttribute isRotate = action.Attribute("isRotate");
                        if (isRotate != null)
                        {
                            act.args.Add("isRotate", isRotate.Value);
                        }
                        newAction = act;
                    }
                    break;
                case "TipWindow":
                case "TextTip":
                    {
                        var act = new DictionaryAction();
                        XAttribute audio = action.Attribute("audio");
                        if (audio != null)
                        {
                            act.args.Add("audio", audio.Value);
                        }
                        XAttribute btns = action.Attribute("btns");
                        if (btns != null)
                        {
                            act.args.Add("btns", btns.Value);
                        }
                        XAttribute title = action.Attribute("title");
                        if (title != null)
                        {
                            act.args.Add("title", title.Value);
                        }
                        XAttribute alpha = action.Attribute("alpha");
                        if (alpha != null)
                        {
                            act.args.Add("alpha", alpha.Value);
                        }

                        newAction = act;
                    }
                    break;
                case "TextWindow":
                    {
                        var act = new DictionaryAction();
                        XAttribute audio = action.Attribute("audio");
                        if (audio != null)
                        {
                            act.args.Add("audio", audio.Value);
                        }
                        XAttribute btns = action.Attribute("btns");
                        if (btns != null)
                        {
                            act.args.Add("btns", btns.Value);
                        }
                        XAttribute title = action.Attribute("title");
                        if (title != null)
                        {
                            act.args.Add("title", title.Value);
                        }
                        var scrollSpeed = action.Attribute("scrollSpeed");
                        if (scrollSpeed != null)
                        {
                            act.args.Add("scrollSpeed", scrollSpeed.Value);
                        }
                        var position = action.Attribute("position");
                        if (position != null)
                        {
                            act.args.Add("position", position.Value);
                        }
                        newAction = act;
                    }
                    break;
                case "Video":
                    {
                        var act = new StringListAction();
                        XAttribute size = action.Attribute("size");
                        if (size != null)
                        {
                            act.args.Add(size.Value);
                        }
                        else
                        {
                            act.args.Add("792,458");
                        }
                        XAttribute offset = action.Attribute("offset");
                        if (offset != null)
                        {
                            act.args.Add(offset.Value);
                        }
                        else
                        {
                            act.args.Add("0,0");
                        }
                        XAttribute finishedEvent = action.Attribute("finishedEvent");
                        if (finishedEvent != null)
                        {
                            act.args.Add(finishedEvent.Value);
                        }
                        else
                        {
                            act.args.Add("");
                        }
                        XAttribute closeEvent = action.Attribute("closeEvent");
                        if (closeEvent != null)
                        {
                            act.args.Add(closeEvent.Value);
                        }
                        else
                        {
                            act.args.Add("");
                        }
                        newAction = act;
                    }
                    break;
                case "HighLight":
                    {
                        var act = new DictionaryAction();
                        XAttribute isHigh = action.Attribute("isHigh");
                        if (isHigh != null)
                        {
                            act.args.Add("isHigh", isHigh.Value);
                        }
                        XAttribute color = action.Attribute("color");
                        if (color != null)
                        {
                            act.args.Add("color", color.Value);
                        }
                        XAttribute deviceName = action.Attribute("deviceName");
                        if (deviceName != null)
                        {
                            act.args.Add("deviceName", deviceName.Value);
                        }
                        newAction = act;
                        XAttribute isIndependent = action.Attribute("isIndependent");
                        if (isIndependent != null)
                        {
                            act.args.Add("isIndependent", isIndependent.Value);
                        }
                        XAttribute visibility = action.Attribute("visibility");
                        if (visibility != null)
                        {
                            act.args.Add("visibility", visibility.Value);
                        }
                        newAction = act;
                    }
                    break;
                case "HighLightFlash":
                    {
                        var act = new DictionaryAction();
                        XAttribute isHigh = action.Attribute("isHigh");
                        if (isHigh != null)
                        {
                            act.args.Add("isHigh", isHigh.Value);
                        }
                        XAttribute color = action.Attribute("color");
                        if (color != null)
                        {
                            act.args.Add("color", color.Value);
                        }
                        XAttribute deviceName = action.Attribute("deviceName");
                        if (deviceName != null)
                        {
                            act.args.Add("deviceName", deviceName.Value);
                        }
                        newAction = act;
                        XAttribute isIndependent = action.Attribute("isIndependent");
                        if (isIndependent != null)
                        {
                            act.args.Add("isIndependent", isIndependent.Value);
                        }
                        XAttribute time = action.Attribute("time");
                        if (time != null)
                        {
                            act.args.Add("time", time.Value);
                        }
                        XAttribute count = action.Attribute("count");
                        if (count != null)
                        {
                            act.args.Add("count", count.Value);
                        }
                        XAttribute finishedEvent = action.Attribute("finishedEvent");
                        if (finishedEvent != null)
                        {
                            act.args.Add("finishedEvent", finishedEvent.Value);
                        }
                        XAttribute visibility = action.Attribute("visibility");
                        if (visibility != null)
                        {
                            act.args.Add("visibility", visibility.Value);
                        }
                        newAction = act;
                    }
                    break;
                case "LoadRes":
                    {
                        var act = new DictionaryAction();
                        XAttribute resType = action.Attribute("resType");
                        if (resType != null)
                        {
                            act.args.Add("resType", resType.Value);
                        }
                        XAttribute index = action.Attribute("index");
                        if (index != null)
                        {
                            act.args.Add("index", index.Value);
                        }
                        newAction = act;
                    }
                    break;
                case "Audio":
                    {
                        //string path, string audioType, string loop, string finishedEvent, string volume,
                        var act = new StringListAction();
                        XAttribute audioType = action.Attribute("audioType");
                        if (audioType != null)
                        {
                            act.args.Add(audioType.Value);
                        }
                        else
                        {
                            act.args.Add("Sound");
                        }
                        XAttribute loop = action.Attribute("loop");
                        if (loop != null)
                        {
                            act.args.Add(loop.Value);
                        }
                        else
                        {
                            act.args.Add("false");
                        }
                        XAttribute waitFinished = action.Attribute("waitFinished");
                        if (waitFinished != null)
                        {
                            act.args.Add(waitFinished.Value);
                        }
                        else
                        {
                            act.args.Add("");
                        }
                        XAttribute volume = action.Attribute("volume");
                        if (volume != null)
                        {
                            act.args.Add(volume.Value);
                        }
                        else
                        {
                            act.args.Add("");
                        }
                        XAttribute isPlay = action.Attribute("isPlay");
                        if (isPlay != null)
                        {
                            act.args.Add(isPlay.Value);
                        }
                        else
                        {
                            act.args.Add("true");
                        }
                        newAction = act;
                    }
                    break;
                case "Line":
                    {
                        var act = new StringListAction();
                        XAttribute color = action.Attribute("color");
                        if (color != null)
                        {
                            act.args.Add(color.Value);
                        }
                        else
                        {
                            act.args.Add("");
                        }
                        XAttribute width = action.Attribute("width");
                        if (width != null)
                        {
                            act.args.Add(width.Value);
                        }
                        else
                        {
                            act.args.Add("0.1");
                        }
                        XAttribute lineScale = action.Attribute("lineScale");
                        if (lineScale != null)
                        {
                            act.args.Add(lineScale.Value);
                        }
                        else
                        {
                            act.args.Add("1,1");
                        }
                        newAction = act;
                    }
                    break;
                case "ResultTip":
                    {
                        var act = new DictionaryAction();
                        XAttribute isRight = action.Attribute("isRight");
                        if (isRight != null)
                        {
                            act.args.Add("isRight", isRight.Value);
                        }
                        XAttribute finishedEvent = action.Attribute("finishedEvent");
                        if (finishedEvent != null)
                        {
                            act.args.Add("finishedEvent", finishedEvent.Value);
                        }
                        XAttribute autoHide = action.Attribute("autoHide");
                        if (autoHide != null)
                        {
                            act.args.Add("autoHide", autoHide.Value);
                        }
                        newAction = act;
                    }
                    break;
                case "Led":
                    {
                        var act = new StringListAction();
                        XAttribute number = action.Attribute("number");
                        if (number != null)
                        {
                            act.args.Add(number.Value);
                        }
                        else
                        {
                            act.args.Add("0");
                        }
                        XAttribute color = action.Attribute("color");
                        if (color != null)
                        {
                            act.args.Add(color.Value);
                        }
                        else
                        {
                            act.args.Add("255,255,255,255");
                        }
                        newAction = act;
                    }
                    break;
                case "Script":
                    {
                        var act = new StringListAction();
                        XAttribute finishedEvent = action.Attribute("finishedEvent");
                        if (finishedEvent != null)
                        {
                            act.args.Add(finishedEvent.Value);
                        }
                        else
                        {
                            act.args.Add("");
                        }
                        newAction = act;
                    }
                    break;
                case "Collider":
                    {
                        var act = new StringListAction();
                        XAttribute deviceName = action.Attribute("deviceName");
                        if (deviceName != null)
                        {
                            act.args.Add(deviceName.Value);
                        }
                        else
                        {
                            act.args.Add("");
                        }
                        XAttribute colliderType = action.Attribute("colliderType");
                        if (colliderType != null)
                        {
                            act.args.Add(colliderType.Value);
                        }
                        else
                        {
                            act.args.Add("空");
                        }
                        XAttribute arg = action.Attribute("args");
                        if (arg != null)
                        {
                            act.args.Add(arg.Value);
                        }
                        else
                        {
                            act.args.Add("");
                        }
                        newAction = act;
                    }
                    break;
                case "TimeTip":
                    {
                        var act = new DictionaryAction();
                        XAttribute time = action.Attribute("time");
                        if (time != null)
                        {
                            act.args.Add("time", time.Value);
                        }
                        else
                        {
                            act.args.Add("time", "0");
                        }

                        XAttribute values = action.Attribute("values");
                        if (values != null)
                        {
                            act.args.Add("values", values.Value);
                        }
                        XAttribute format = action.Attribute("format");
                        if (format != null)
                        {
                            act.args.Add("format", format.Value);
                        }

                        XAttribute finishedEvent = action.Attribute("finishedEvent");
                        if (finishedEvent != null)
                        {
                            act.args.Add("finishedEvent", finishedEvent.Value);
                        }

                        XAttribute needClick = action.Attribute("needClick");
                        if (needClick != null)
                        {
                            act.args.Add("needClick", needClick.Value);
                        }
                        XAttribute reverse = action.Attribute("reverse");
                        if (reverse != null)
                        {
                            act.args.Add("reverse", reverse.Value);
                        }
                        newAction = act;
                    }
                    break;
                case "SkinnedBake":
                    {
                        var act = new DictionaryAction();
                        XAttribute deviceName = action.Attribute("deviceName");
                        if (deviceName != null)
                        {
                            act.args.Add("deviceName", deviceName.Value);
                        }
                        newAction = act;
                    }
                    break;
                case "TimeLine":
                    {
                        var act = new DictionaryAction();
                        XAttribute deviceName = action.Attribute("deviceName");
                        if (deviceName != null)
                        {
                            act.args.Add("deviceName", deviceName.Value);
                        }
                        XAttribute isShow = action.Attribute("isShow");
                        if (isShow != null)
                        {
                            act.args.Add("isShow", isShow.Value);
                        }
                        XAttribute finishedEvent = action.Attribute("finishedEvent");
                        if (finishedEvent != null)
                        {
                            act.args.Add("finishedEvent", finishedEvent.Value);
                        }
                        XAttribute isWait = action.Attribute("isWait");
                        if (isWait != null)
                        {
                            act.args.Add("isWait", isWait.Value);
                        }
                        XAttribute frame = action.Attribute("frame");
                        if (frame != null)
                        {
                            act.args.Add("frame", frame.Value);
                        }
                        XAttribute endFrame = action.Attribute("endFrame");
                        if (endFrame != null)
                        {
                            act.args.Add("endFrame", endFrame.Value);
                        }
                        XAttribute speed = action.Attribute("speed");
                        if (speed != null)
                        {
                            act.args.Add("speed", speed.Value);
                        }
                        newAction = act;
                    }
                    break;
                case "Point3DQuestion":
                    {
                        var act = new Point3DQuestion();
                        var datas = action.Elements("Data");
                        foreach (var item in datas)
                        {
                            Point3DQuestion.Data data = new Point3DQuestion.Data();
                            data.name = item.Attribute("name")?.Value;
                            XAttribute atr = item.Attribute("deviceName");
                            if (atr != null)
                            {
                                data.deviceName = item.Attribute("deviceName").Value;
                            }
                            else
                            {
                                data.pos = Utility.GetVector3FromStrArray(item.Attribute("position")?.Value);
                                data.rotate = Utility.GetVector3FromStrArray(item.Attribute("rotate")?.Value);
                                data.scale = Utility.GetVector3FromStrArray(item.Attribute("scale")?.Value);
                            }
                            float.TryParse(item.Attribute("rotateSpeed")?.Value, out data.rotateSpeed);
                            var order = item.Attribute("order");
                            if (order != null)
                            {
                                int.TryParse(order.Value, out data.order);
                            }

                            data.clickEvent = item.Attribute("clickEvent")?.Value;
                            act.datas.Add(data);
                        }
                        newAction = act;
                    }
                    break;
                case "Mat":
                    {
                        var act = new DictionaryAction();
                        XAttribute value = action.Attribute("value");
                        if (value != null)
                        {
                            act.args.Add("value", value.Value);
                        }
                        XAttribute deviceName = action.Attribute("deviceName");
                        if (deviceName != null)
                        {
                            act.args.Add("deviceName", deviceName.Value);
                        }
                        XAttribute matName = action.Attribute("matName");
                        if (matName != null)
                        {
                            act.args.Add("matName", matName.Value);
                        }
                        XAttribute index = action.Attribute("index");
                        if (index != null)
                        {
                            act.args.Add("index", index.Value);
                        }
                        XAttribute mainTexture = action.Attribute("mainTexture");
                        if (mainTexture != null)
                        {
                            act.args.Add("mainTexture", mainTexture.Value);
                        }
                        newAction = act;
                    }
                    break;
                case "Input":
                    {
                        var act = new InputAction();
                        act.data = new UIInputData();
                        act.data.title = action.Attribute("title")?.Value;
                        act.data.finishedEvent = action.Attribute("finishedEvent")?.Value;
                        foreach (var item in action.Elements("Input"))
                        {
                            UIInputData.InputData inputData = new UIInputData.InputData();
                            inputData.answer = item.Attribute("answer")?.Value;
                            inputData.var = item.Attribute("var")?.Value;
                            inputData.name = item.Attribute("name")?.Value;
                            act.data.inputs.Add(inputData);
                        }
                        foreach (var item in action.Elements("Btn"))
                        {
                            UIInputData.BtnData btnData = new UIInputData.BtnData();
                            btnData.name = item.Attribute("name")?.Value;
                            btnData.clickEvent = item.Attribute("clickEvent")?.Value;
                            XAttribute checkAnswer = item.Attribute("checkAnswer");
                            if (checkAnswer != null)
                            {
                                bool.TryParse(checkAnswer.Value, out btnData.checkAnswer);
                            }
                            btnData.wrongLabel = item.Attribute("wrongLabel")?.Value;
                            btnData.wrongEvent = item.Attribute("wrongEvent")?.Value;
                            XAttribute wrongCount = item.Attribute("wrongCount");
                            if (wrongCount != null)
                            {
                                int.TryParse(wrongCount.Value, out btnData.wrongCount);
                            }
                            XAttribute autoHide = item.Attribute("autoHide");
                            if (autoHide != null)
                            {
                                float.TryParse(autoHide.Value, out btnData.autoHide);
                            }
                            btnData.scoreStepName = item.Attribute("scoreStepName")?.Value;
                            XAttribute rightScore = item.Attribute("rightScore");
                            if (rightScore != null)
                            {
                                float.TryParse(rightScore.Value, out btnData.rightScore);
                            }
                            XAttribute wrongScore = item.Attribute("wrongScore");
                            if (wrongScore != null)
                            {
                                float.TryParse(wrongScore.Value, out btnData.wrongScore);
                            }
                            act.data.btns.Add(btnData);
                        }
                        newAction = act;
                    }
                    break;
                case "ImageTip":
                    {
                        var act = new DictionaryAction();
                        XAttribute path = action.Attribute("path");
                        if (path != null)
                        {
                            act.args.Add("path", path.Value);
                        }
                        XAttribute size = action.Attribute("size");
                        if (size != null)
                        {
                            act.args.Add("size", size.Value);
                        }
                        XAttribute isDrag = action.Attribute("isDrag");
                        if (isDrag != null)
                        {
                            act.args.Add("isDrag", isDrag.Value);
                        }
                        XAttribute position = action.Attribute("position");
                        if (position != null)
                        {
                            act.args.Add("position", position.Value);
                        }
                        newAction = act;
                    }
                    break;
                case "3DObjShow":
                    {
                        var act = new Show3DAction();
                        act.data = new UI3DObjShowData();
                        act.data.datas = new List<UI3DObjShowData.ObjData>();
                        foreach (var item in action.Elements("Object"))
                        {
                            UI3DObjShowData.ObjData objData = new UI3DObjShowData.ObjData();
                            objData.deviceName = item.Attribute("deviceName")?.Value;

                            XAttribute position = item.Attribute("position");
                            if (position != null)
                            {
                                objData.position = Utility.GetVector3FromStrArray(position.Value);
                            }
                            XAttribute rotate = item.Attribute("rotate");
                            if (rotate != null)
                            {
                                objData.rotate = Utility.GetVector3FromStrArray(rotate.Value);
                            }
                            XAttribute scale = item.Attribute("scale");
                            if (scale != null)
                            {
                                objData.scale = Utility.GetVector3FromStrArray(scale.Value);
                            }
                            XAttribute rotateSpeed = item.Attribute("rotateSpeed");
                            if (rotateSpeed != null)
                            {
                                float.TryParse(rotateSpeed.Value, out objData.rotateSpeed);
                            }
                            XAttribute moveSpeed = item.Attribute("moveSpeed");
                            if (moveSpeed != null)
                            {
                                float.TryParse(moveSpeed.Value, out objData.moveSpeed);
                            }
                            XAttribute distance = item.Attribute("distance");
                            if (distance != null)
                            {
                                float.TryParse(distance.Value, out objData.distance);
                            }
                            XAttribute distanceMin = item.Attribute("distanceMin");
                            if (distanceMin != null)
                            {
                                float.TryParse(distanceMin.Value, out objData.distanceMin);
                            }
                            XAttribute distanceMax = item.Attribute("distanceMax");
                            if (distanceMax != null)
                            {
                                float.TryParse(distanceMax.Value, out objData.distanceMax);
                            }
                            XAttribute pitchMin = item.Attribute("pitchMin");
                            if (pitchMin != null)
                            {
                                float.TryParse(pitchMin.Value, out objData.pitchMin);
                            }
                            XAttribute pitchMax = item.Attribute("pitchMax");
                            if (pitchMax != null)
                            {
                                float.TryParse(pitchMax.Value, out objData.pitchMax);
                            }
                            act.data.datas.Add(objData);
                        }
                        newAction = act;
                    }
                    break;
                case "OperationChange":
                    {
                        var act = new DictionaryAction();
                        XAttribute name = action.Attribute("name");
                        if (name != null)
                        {
                            act.args.Add("name", name.Value);
                        }
                        newAction = act;
                    }
                    break;
                case "ShowScore":
                    {
                        var act = new DictionaryAction();
                        XAttribute onlyCurModule = action.Attribute("onlyCurModule");
                        if (onlyCurModule != null)
                        {
                            act.args.Add("onlyCurModule", onlyCurModule.Value);
                        }
                        newAction = act;
                    }
                    break;
                case "ImageSelectMap":
                    {
                        var act = new ImageSelectMapAction();
                        XAttribute scoreName = action.Attribute("scoreName");
                        if (scoreName != null)
                        {
                            act.args.Add("scoreName", scoreName.Value);
                        }
                        XAttribute totalScore = action.Attribute("totalScore");
                        if (totalScore != null)
                        {
                            act.args.Add("totalScore", totalScore.Value);
                        }
                        XAttribute rightScore = action.Attribute("rightScore");
                        if (rightScore != null)
                        {
                            act.args.Add("rightScore", rightScore.Value);
                        }
                        XAttribute wrongScore = action.Attribute("wrongScore");
                        if (wrongScore != null)
                        {
                            act.args.Add("wrongScore", wrongScore.Value);
                        }
                        XAttribute rightLabel = action.Attribute("rightLabel");
                        if (rightLabel != null)
                        {
                            act.args.Add("rightLabel", rightLabel.Value);
                        }
                        XAttribute wrongLabel = action.Attribute("wrongLabel");
                        if (wrongLabel != null)
                        {
                            act.args.Add("wrongLabel", wrongLabel.Value);
                        }
                        XAttribute finishedEvent = action.Attribute("finishedEvent");
                        if (finishedEvent != null)
                        {
                            act.args.Add("finishedEvent", finishedEvent.Value);
                        }
                        XAttribute rightBg = action.Attribute("rightBg");
                        if (rightBg != null)
                        {
                            act.args.Add("rightBg", rightBg.Value);
                        }
                        XAttribute random = action.Attribute("random");
                        if (random != null)
                        {
                            act.args.Add("random", random.Value);
                        }

                        foreach (var rowData in action.Elements("Row"))
                        {
                            var row = new ImageSelectMapAction.Row();
                            row.name = rowData.Attribute("name")?.Value;
                            act.rows.Add(row);
                            foreach (var itemData in rowData.Elements("Item"))
                            {
                                row.items.Add(new ImageSelectMapAction.Item()
                                {
                                    pic = itemData.Attribute("pic")?.Value,
                                    name = itemData.Attribute("name")?.Value
                                });
                            }
                        }
                        newAction = act;
                    }
                    break;

                case "UIGuideTip":
                    {
                        var act = new DictionaryAction();

                        XAttribute targetName = action.Attribute("targetName");
                        if (targetName != null)
                        {
                            act.args.Add("targetName", targetName.Value);

                        }
                        XAttribute showName = action.Attribute("showName");
                        if (showName != null)
                        {
                            act.args.Add("showName", showName.Value);

                        }
                        XAttribute offSet = action.Attribute("offSet");
                        if (offSet != null)
                        {
                            act.args.Add("offSet", offSet.Value);

                        }
                        XAttribute tiptext = action.Attribute("tiptext");
                        if (tiptext != null)
                        {
                            act.args.Add("tiptext", tiptext.Value);

                        }
                        XAttribute tipaudio = action.Attribute("tipaudio");
                        if (tipaudio != null)
                        {
                            act.args.Add("tipaudio", tipaudio.Value);

                        }
                        XAttribute tiptitle = action.Attribute("tiptitle");
                        if (tiptitle != null)
                        {
                            act.args.Add("tiptitle", tiptitle.Value);

                        }
                        newAction = act;
                    }


                    break;

                case "UISliderAnim":
                    {




                        var act = new DictionaryAction();
                        XAttribute title = action.Attribute("title");
                        if (title != null)
                        {
                            act.args.Add("title", title.Value);
                        }
                        XAttribute targetObj = action.Attribute("targetObj");
                        if (targetObj != null)
                        {
                            act.args.Add("targetObj", targetObj.Value);
                        }
                        newAction = act;

                    }
                    break;

                case "Greatbtns":
                    {

                        var act = new DictionaryAction();
                        XAttribute name = action.Attribute("name");
                        if (name != null)
                        {
                            act.args.Add("name", name.Value);

                        }
                        XAttribute pos = action.Attribute("pos");
                        if (pos != null)
                        {
                            act.args.Add("pos", pos.Value);


                        }
                        XAttribute size = action.Attribute("size");
                        if (size != null)
                        {
                            act.args.Add("size", size.Value);


                        }
                        XAttribute HieraName = action.Attribute("HieraName");
                        if (HieraName != null)
                        {
                            act.args.Add("HieraName", HieraName.Value);


                        }
                        newAction = act;

                    }
                    break;

                case "UIBtnAnim": {

                        var act = new DictionaryAction();
                        XAttribute title = action.Attribute("title");
                        if (title != null)
                        {
                            act.args.Add("title", title.Value);
                        }
                        XAttribute Obj = action.Attribute("Obj");
                        if (Obj != null)
                        {
                            act.args.Add("Obj", Obj.Value);
                        }

                        XAttribute AnimObj = action.Attribute("AnimObj");
                        if (AnimObj != null)
                        {
                            act.args.Add("AnimObj", AnimObj.Value);
                        }
                        XAttribute size = action.Attribute("size");
                        if (size != null)
                        {
                            act.args.Add("size", size.Value);
                        }
                        XAttribute pos = action.Attribute("pos");
                        if (pos != null)
                        {
                            act.args.Add("pos", pos.Value);
                        }

                        XAttribute animName = action.Attribute("animName");
                        if (animName != null)
                        {
                            act.args.Add("animName", animName.Value);
                        }
                        XAttribute speed = action.Attribute("speed");
                        if (speed != null)
                        {
                            act.args.Add("speed", speed.Value);
                        }
                        newAction = act;

                    }
                    break;

                case "DragJiHe":
                    {

                        var act = new DictionaryAction();
                        XAttribute DragItemName = action.Attribute("DragItemName");
                        if (DragItemName != null)
                        {
                            act.args.Add("DragItemName", DragItemName.Value);
                        }
                        XAttribute TargetObj = action.Attribute("TargetObj");
                        if (TargetObj != null)
                        {
                            act.args.Add("TargetObj", TargetObj.Value);
                        }

                        XAttribute ItemPath = action.Attribute("ItemPath");
                        if (ItemPath != null)
                        {
                            act.args.Add("ItemPath", ItemPath.Value);
                        }
                        newAction = act;


                    }
                    break;



                case "DragPanel":
                    {

                        var act = new DictionaryAction();
                        XAttribute DragItemName = action.Attribute("DragItemName");
                        if (DragItemName != null)
                        {
                            act.args.Add("DragItemName", DragItemName.Value);
                        }
                        XAttribute HieraNames = action.Attribute("HieraNames");
                        if (HieraNames != null)
                        {
                            act.args.Add("HieraNames", HieraNames.Value);
                        }
                        XAttribute TargetObjs = action.Attribute("TargetObjs");
                        if (TargetObjs != null)
                        {
                            act.args.Add("TargetObjs", TargetObjs.Value);
                        }
                        XAttribute FinishedEvent = action.Attribute("FinishedEvent");
                        if (FinishedEvent != null)
                        {
                            act.args.Add("FinishedEvent", FinishedEvent.Value);
                        }

                        newAction = act;


                    }
                    break;



                default:
                    newAction = new Action();
                    break;
            }

            newAction.Type = action.Attribute("type")?.Value;
            newAction.Name = action.Attribute("name")?.Value;
            newAction.Value = action.Attribute("value")?.Value;
            newAction.SubActions = ParseActions(action);
            return newAction;
        }



        public static Condition ParseCondition(XElement action)
        {
            if (action == null)
            {
                return null;
            }
            Condition newAction = null;
            string type = action.Attribute("type")?.Value;
            switch (type)
            {
                case "ObjClick":
                    {
                        var act = new DictionaryCondition();

                        XAttribute deviceName = action.Attribute("deviceName");
                        if (deviceName != null)
                        {
                            act.args.Add("deviceName", deviceName.Value);
                        }
                        XAttribute isRight = action.Attribute("isRight");
                        if (isRight != null)
                        {
                            act.args.Add("isRight", isRight.Value);
                        }
                        newAction = act;
                    }
                    break;
                case "ObjClickLong":
                    {
                        var act = new DictionaryCondition();
                        XAttribute deviceName = action.Attribute("deviceName");
                        if (deviceName != null)
                        {
                            act.args.Add("deviceName", deviceName.Value);
                        }
                        XAttribute time = action.Attribute("time");
                        if (time != null)
                        {
                            act.args.Add("time", time.Value);
                        }
                        newAction = act;
                    }
                    break;
                case "HasDevice":
                    {
                        var act = new DictionaryCondition();
                        XAttribute deviceName = action.Attribute("deviceName");
                        if (deviceName != null)
                        {
                            act.args.Add("deviceName", deviceName.Value);
                        }
                        XAttribute count = action.Attribute("count");
                        if (count != null)
                        {
                            act.args.Add("count", count.Value);
                        }
                        newAction = act;
                    }
                    break;
                case "Distance":
                    {
                        var act = new DictionaryCondition();
                        XAttribute targetPos = action.Attribute("targetPos");
                        if (targetPos != null)
                        {
                            act.args.Add("targetPos", targetPos.Value);
                        }
                        XAttribute ignoreY = action.Attribute("ignoreY");
                        if (ignoreY != null)
                        {
                            act.args.Add("ignoreY", ignoreY.Value);
                        }
                        newAction = act;
                    }
                    break;
                default:
                    newAction = new Condition();
                    break;
            }
            newAction.Type = type;
            newAction.Name = action.Attribute("name")?.Value;
            newAction.Value = action.Attribute("value")?.Value;
            newAction.SubActions = ParseActions(action);

            return newAction;

        }
        public static ActionItem ParserActionItem(XElement element)
        {

            ActionItem actItem = null;
            switch (element.Name.LocalName)
            {
                case "Action":
                    actItem = ParseAction(element);
                    break;
                case "Condition":
                    actItem = ParseCondition(element);
                    break;
            }

            return actItem;
        }
        private static List<ActionItem> ParseActions(XElement actionElement)
        {
            List<ActionItem> actions = new List<ActionItem>();

            foreach (XElement action in actionElement.Elements())
            {
                actions.Add(ParserActionItem(action));
            }

            return actions;
        }




    }




}