using System;
using System.Collections.Generic;
using System.Linq;
using System.Xml.Linq;
using AK.Wwise;
using Wwise.Wooduan.Components;
using UnityEngine;
using Event = AK.Wwise.Event;

namespace Wwise.Wooduan.Tools
{
    internal partial class AkWooduanComponentBackup
    {
        private void OnEnable()
        {                                    
            RegisterComponent<AkBank>(AkBankImporter, AkBankExporter);
            RegisterComponent<AnimationSound>(ImportSpatialSettings, ExportSpatialSettings);
            RegisterComponent<AkAudioListener>(AkAudioListenerImporter, AkAudioListenerExporter);
            RegisterComponent<AkEffect>(AkEffectImporter, AkEffectExporter);
            RegisterComponent<AkRoom>(AkRoomImporter, AkRoomExporter);     
            RegisterComponent<AkRoof>(AkRoofImporter, AkRoofExporter);      
            RegisterComponent<AkAmbient>(AkAmbientImporter, AkAmbientExporter);
            RegisterComponent<ParticleSound>(ParticleSoundImporter, ParticleSoundExporter);
            RegisterComponent<AkState>(AkStateImporter, AkStateExporter);
            RegisterComponent<AkSwitch>(AkSwitchImporter, AkSwitchExporter);
            RegisterComponent<AkSurfaceReflector>(AkSurfaceReflectorImporter, AkSurfaceReflectorExporter);
        }

        #region FieldImporters                               
        private static T XmlToWwiseObject<T>(XElement xEvent) where T : BaseType, new()
        {
            var guid = AkWooduanScriptingTools.StringToGuid(AkWooduanScriptingTools.GetXmlAttribute(xEvent, "Guid"));
            var objectByGuid = AkWwiseProjectInfo.GetData().FindWwiseObject<T>(guid);
            if (objectByGuid != null)
            {
                var n = new T();
                n.SetupReference(objectByGuid.Name, guid);
                return n;
            } 
            var name = AkWooduanScriptingTools.GetXmlAttribute(xEvent, "Name");                         
            var objectByName = AkWwiseProjectInfo.GetData().FindWwiseObject<T>(name);
            if (objectByName != null)
            {
                var n = new T();
                n.SetupReference(name, objectByName.Guid);
                return n;
            }                
            return null;
        }
		
        private static Event XmlToAudioEventExt(XElement xEvent)
        {
            var evt = XmlToWwiseObject<Event>(xEvent);
            if (evt == null) return null;
            var n = new Event();
            n.SetupReference(evt.Name, evt.ObjectReference.Guid);
            return n;
        }

        private static bool ImportEvent(ref Event audioEvent, XElement xComponent)
        {
            var x = xComponent.Element("AudioEvent");
            if (x == null)
            {
                if (!audioEvent.IsValid()) return false;
                audioEvent = new Event();
                return true;
            }
            var temp = XmlToWwiseObject<Event>(x);                           
            if (!audioEvent.Equals(temp))
            {
                audioEvent = temp;
                return true;
            }
            return false;
        }

        private static bool ImportEvent(ref Event audioEvent, XElement xComponent, string trigger)
        {
            var xEvents = xComponent.Element("AudioEvents");
            if (xEvents == null) return false;
            var temp = new Event();          
            foreach (var xEvent in xEvents.Elements())
            {
                if (AkWooduanScriptingTools.GetXmlAttribute(xEvent, "Trigger") == trigger)
                {
                    temp = XmlToWwiseObject<Event>(xEvent);
                    break;
                }                                                                                                                                  
            }            
            if (!audioEvent.Equals(temp))
            {
                audioEvent = temp;
                return true;
            }
            return false;
        }

        private static bool ImportEvents(ref Event[] audioEvents, XElement xComponent, string trigger = "")
        {            
            var xEvents = xComponent.Element("AudioEvents");
            if (xEvents == null) return false;
            var audioEventsTemp = new List<Event>();
            foreach (var xEvent in xEvents.Elements())
            {
                if (string.IsNullOrEmpty(trigger))
                    audioEventsTemp.Add(XmlToWwiseObject<Event>(xEvent));
                else
                {
                    if (AkWooduanScriptingTools.GetXmlAttribute(xEvent, "Trigger") == trigger)
                        audioEventsTemp.Add(XmlToWwiseObject<Event>(xEvent));
                }
            }
            if (!audioEvents.ToList().SequenceEqual(audioEventsTemp))
            {
                audioEvents = audioEventsTemp.ToArray();
                return true;
            }                         
            return false;
        }

        private static bool ImportAudioEventsExt(ref Event[] audioEventExts, XElement xComponent, string trigger)
        {            
            var xEvents = xComponent.Element("AudioEvents");
            if (xEvents == null) return false;       
            var audioEventExtsTemp = new List<Event>();
            foreach (var xEvent in xEvents.Elements())
            {
                if (AkWooduanScriptingTools.GetXmlAttribute(xEvent, "Trigger") == trigger)
                    audioEventExtsTemp.Add(XmlToAudioEventExt(xEvent));
            }
            if (!audioEventExts.ToList().SequenceEqual(audioEventExtsTemp))
            {
                audioEventExts = audioEventExtsTemp.ToArray();
                return true;
            }                         
            return false;
        }

        private static T XmlToWwiseGroupObject<T>(XElement xComponent) where T : BaseGroupType, new()
        {
            var groupGuid = AkWooduanScriptingTools.StringToGuid(AkWooduanScriptingTools.GetXmlAttribute(xComponent, "GroupGuid"));
            var groupObjectByGuid = AkWwiseProjectInfo.GetData().FindWwiseGroupUnit<T>(groupGuid);
            if (groupObjectByGuid != null)
            {
                var childGuid = AkWooduanScriptingTools.StringToGuid(AkWooduanScriptingTools.GetXmlAttribute(xComponent, "Guid"));
                var childName = AkWwiseProjectData.FindWwiseGroupObjectChildName(childGuid, groupObjectByGuid);
                if (string.IsNullOrEmpty(childName)) return null;
                var n = new T();  
                n.SetupReference(childName, childGuid);
                var groupRef = n.ObjectReference as WwiseGroupValueObjectReference;
                if (groupRef)
                {
                    groupRef.SetupGroupObjectReference(groupObjectByGuid.Name, groupGuid);
                    n.ObjectReference = groupRef;
                }
                return n;
            }
            
            var groupName = AkWooduanScriptingTools.GetXmlAttribute(xComponent, "GroupName");
            var groupObjectByName = AkWwiseProjectInfo.GetData().FindWwiseGroupUnit<T>(groupName);
            if (groupObjectByName != null)
            {
                var childName = AkWooduanScriptingTools.GetXmlAttribute(xComponent, "Name");
                var childGuid = AkWwiseProjectData.FindWwiseGroupObjectChildGuid(childName, groupObjectByName);
                if (childGuid == Guid.Empty) return null;
                var n = new T(); 
                n.SetupReference(childName, childGuid);
                var groupRef = n.ObjectReference as WwiseGroupValueObjectReference;
                if (groupRef)
                {
                    groupRef.SetupGroupObjectReference(groupName, groupObjectByName.Guid);
                    n.ObjectReference = groupRef;
                }
                return n;
            }              
            
            return null;
        }
        
        private static State XmlToState(XElement xState)
        {
            var state = XmlToWwiseGroupObject<State>(xState);
            if (state == null) return null;
            var n = new State();
            n.SetupReference(state.ChildName, state.ObjectReference.Guid);
            var groupRef = n.ObjectReference as WwiseGroupValueObjectReference;
            if (groupRef)
            {
                groupRef.SetupGroupObjectReference(state.GroupName, state.GroupGuid);
                n.ObjectReference = groupRef;
            }
            return n;
        }

        private static bool ImportStates(ref State[] states, XElement xComponent, string trigger = "")
        {
            var ss = xComponent.Element("States");
            if (ss == null) return false;
            var xStates = ss.Elements("State");            
            var statesTemp = new List<State>();
            foreach (var xState in xStates)
            {
                if (trigger != "")
                {
                    if (AkWooduanScriptingTools.GetXmlAttribute(xState, "Trigger") == trigger)
                        statesTemp.Add(XmlToWwiseGroupObject<State>(xState));
                }
                else
                {
                    statesTemp.Add(XmlToWwiseGroupObject<State>(xState));
                }                                                                                                                     
            }
            if (!states.ToList().SequenceEqual(statesTemp))
            {
                states = statesTemp.ToArray();
                return true;
            }                         
            return false;
        }
        
        private static bool ImportStatesExt(ref State[] states, XElement xComponent, string trigger = "")
        {
            var ss = xComponent.Element("States");
            if (ss == null) return false;
            var xStates = ss.Elements("State");            
            var statesTemp = new List<State>();
            foreach (var xState in xStates)
            {
                if (trigger != "")
                {
                    if (AkWooduanScriptingTools.GetXmlAttribute(xState, "Trigger") == trigger)
                        statesTemp.Add(XmlToState(xState));
                }
                else
                    statesTemp.Add(XmlToState(xState));
            }
            if (!states.ToList().SequenceEqual(statesTemp))
            {
                states = statesTemp.ToArray();
                return true;
            }                         
            return false;
        }

        private static bool ImportSwitches(ref Switch[] switches, XElement xComponent, string trigger = "")
        {            
            var ss = xComponent.Element("Switches");
            if (ss == null) return false;
            var xSwitches = ss.Elements("Switch");            
            var switchesTemp = new List<Switch>();
            foreach (var xSwitch in xSwitches)
            {
                if (trigger != "")
                {
                    if (AkWooduanScriptingTools.GetXmlAttribute(xSwitch, "Trigger") == trigger)
                        switchesTemp.Add(XmlToWwiseGroupObject<Switch>(xSwitch));
                }
                else
                    switchesTemp.Add(XmlToWwiseGroupObject<Switch>(xSwitch));
            }
            if (!switches.ToList().SequenceEqual(switchesTemp))
            {
                switches = switchesTemp.ToArray();
                return true;
            }                         
            return false;
        }

        private static bool ImportRTPC(ref RTPC rtpc, out float valueScale, XElement xComponent)
        {
            var x = xComponent.Element("RTPC");	        
            if (x == null)
            {
                valueScale = 1f;
                if (!rtpc.IsValid()) return false;
                rtpc = new RTPC();
                return true;
            }
            valueScale = AkWooduanScriptingTools.StringToFloat(AkWooduanScriptingTools.GetXmlAttribute(x, "ValueScale"));
            var temp = XmlToWwiseObject<RTPC>(x);                      
            if (!rtpc.Equals(temp))
            {
                rtpc = temp;
                return true;
            }
            return false;
        }

        private static bool ImportTrigger(ref Trigger tgr, XElement xComponent, string trigger)
        {
            var xTriggers = xComponent.Element("MusicTriggers");
            if (xTriggers == null) return false;
            var temp = new Trigger();          
            foreach (var xTrigger in xTriggers.Elements())
            {
                if (AkWooduanScriptingTools.GetXmlAttribute(xTrigger, "Trigger") == trigger)
                {
                    temp = XmlToWwiseObject<Trigger>(xTrigger);
                    break;
                }                                                                                                                                  
            }            
            if (!tgr.Equals(temp))
            {
                tgr = temp;
                return true;
            }
            return false;
        }

        private static Bank XmlToBank(XElement xBank)
        {
            var bank = XmlToWwiseObject<Bank>(xBank);
            if (bank == null) return null;
            var n = new Bank();
            n.SetupReference(bank.Name, bank.ObjectReference.Guid);
            return n;
        }

        private static bool ImportBank(ref Bank bank, XElement xComponent)
        {
            var xBank = xComponent.Element("Bank");
            if (xBank == null) return false;
            var bankTemp = XmlToBank(xBank);
            if (bank != bankTemp)
            {
                bank = bankTemp;
                return true;
            }
            return false;
        }

        private static AuxBus XmlToAuxBus(XElement xAuxBus)
        {
            var bus = XmlToWwiseObject<AuxBus>(xAuxBus);
            if (bus == null) return null;
            var n = new AuxBus();
            n.SetupReference(bus.Name, bus.ObjectReference.Guid);
            return n;
        }

        private static bool ImportAuxBus(ref AuxBus bus, XElement xComponent)
        {
            var x = xComponent.Element("AuxBus");	        
            if (x == null)
            {
                if (!bus.IsValid()) return false;
                bus = new AuxBus();
                return true;
            }
            var temp = XmlToAuxBus(x);                      
            if (!bus.Equals(temp))
            {
                bus = temp;
                return true;
            }
            return false;
        }
        
        private static bool ImportAuxBusesExt(ref AuxBus[] buses, XElement xComponent)
        {
            var abs = xComponent.Element("AuxBuses");
            if (abs == null) return false; 	         
            var xBuses = abs.Elements("AuxBus");              
            var busesTemp = xBuses.Select(XmlToAuxBus).ToList();
            if (!buses.ToList().SequenceEqual(busesTemp))
            {
                buses = busesTemp.ToArray();
                return true;
            }
            return false;
        }

        private static bool ImportAcousticTexture(ref AcousticTexture texture, XElement xComponent)
        {
            var xTexture = xComponent.Element("AcousticTexture");
            if (xTexture == null) return false;
            var temp = XmlToWwiseObject<AcousticTexture>(xTexture);
            if (!texture.Equals(temp))
            {
                texture = temp;
                return true;
            }
            return false;
        }

        private static bool ImportTriggerSettings(AkTriggerHandler handler, XElement xComponent)
        {
            var xSettings = xComponent.Element("TriggerSettings");
            var modified = ImportBool(ref handler.useOtherObject, AkWooduanScriptingTools.GetXmlAttribute(xSettings, "useOtherObject"));
            //modified |= ImportInt(ref handler.triggerList, AkWooduanScriptingTools.GetXmlAttribute(xSettings, "triggerList"));
            return modified;
        }

        private static bool ImportSpatialSettings(Component component, XElement xComponent)
        {
            var emitter = (AkGameObj) component;
            var xSettings = xComponent.Element("SpatialSettings");
            var modified = ImportBool(ref emitter.autoUpdatePosition, AkWooduanScriptingTools.GetXmlAttribute(xSettings, "autoUpdatePosition"));
            modified |= ImportBool(ref emitter.isEnvironmentAware, AkWooduanScriptingTools.GetXmlAttribute(xSettings, "isEnvironmentAware"));
            modified |= ImportBool(ref emitter.useSpotReflector, AkWooduanScriptingTools.GetXmlAttribute(xSettings, "useSpotReflector"));
            modified |= ImportBool(ref emitter.enableOccObsRTPC, AkWooduanScriptingTools.GetXmlAttribute(xSettings, "enableOccObsRTPC"));
            modified |= ImportVector3(ref emitter.m_positionOffsetData.positionOffset, AkWooduanScriptingTools.GetXmlAttribute(xSettings, "positionOffset"));
            return modified;
        }

        private static bool ImportGameObjects(GameObject parent, ref GameObject[] gameObjects, XElement xGameObjects)
        {
            var gameObjectsTemp = xGameObjects.Elements("GameObject").Select
                (xGameObject => GetGameObject(parent, AkWooduanScriptingTools.GetXmlAttribute(xGameObject, "Path"))).Where(gameObject => gameObject).ToList();
            if (!gameObjects.ToList().SequenceEqual(gameObjectsTemp))
            {
                gameObjects = gameObjectsTemp.ToArray();
                return true;
            }
            return false;
        }
        #endregion
        
        #region FieldExporters
        private static string ExportVector3(Vector3 vector)
        {
            return vector.x.ToString("n3") + ", " + vector.y.ToString("n3") + ", " + vector.z.ToString("n3");
        }

        private static void ExportGameObjects(GameObject parent, GameObject[] gameObjects, XElement xGameObjects)
        {
            foreach (var gameObject in gameObjects)
            {
                if (!gameObject) continue;
                var xGameObject = new XElement("GameObject"); 
                xGameObject.SetAttributeValue("Path", GetGameObjectPath(gameObject.transform, parent.transform));
                xGameObjects.Add(xGameObject);
            }
        }

        private static void ExportSpatialSettings(Component component, XElement xComponent)
        {
            var emitter = (AkGameObj) component;
            var xSettings = new XElement("SpatialSettings");
            xSettings.SetAttributeValue("autoUpdatePosition", emitter.autoUpdatePosition);            
            xSettings.SetAttributeValue("useSpotReflector", emitter.useSpotReflector);
            xSettings.SetAttributeValue("positionOffset", ExportVector3(emitter.m_positionOffsetData.positionOffset));
            xSettings.SetAttributeValue("isEnvironmentAware", emitter.isEnvironmentAware);
            xSettings.SetAttributeValue("enableOccObsRTPC", emitter.enableOccObsRTPC);
            xComponent.Add(xSettings);
        }

        private static void ExportTriggerSettings(AkTriggerHandler component, XElement xComponent)
        {
            var xSettings = new XElement("TriggerSettings");
            xSettings.SetAttributeValue("SetOn", component.triggerList);
            xSettings.SetAttributeValue("useOtherObject", component.useOtherObject);
            xComponent.Add(xSettings);
        }

        private static void ExportWwiseObject(BaseType obj, XElement xComponent)
        {
            if (!obj.IsValid()) return;
            var xObj = new XElement(obj.GetType().Name);                
            xObj.SetAttributeValue("Name", obj.Name);
            xObj.SetAttributeValue("Guid", obj.ObjectReference.Guid);
            xComponent.Add(xObj);  
        }

        private static void ExportWwiseGroupObject(BaseGroupType obj, XElement xComponent)
        {            
            if (!obj.IsValid()) return;
            var xObj = new XElement(obj.GetType().Name); 
            xObj.SetAttributeValue("Name", obj.ChildName);
            xObj.SetAttributeValue("Guid", obj.ObjectReference.Guid);
            xObj.SetAttributeValue("GroupName", obj.GroupName);
            xObj.SetAttributeValue("GroupGuid", obj.GroupGuid);
            xComponent.Add(xObj);
        }
        #endregion
        
        #region ComponentExporters               
        private static void AkRoofExporter(Component component, XElement xComponent)
        {
            var s = (AkRoof) component; 
            var xSettings = new XElement("Settings");
            xSettings.SetAttributeValue("Tags", s.floor); 
            xComponent.Add(xSettings);
        }
        
        private static void AkEffectExporter(Component component, XElement xComponent)
        {
            var s = (AkEffect) component; 
            var xSettings = new XElement("Settings");
            xSettings.SetAttributeValue("busName", s.busName);
            xSettings.SetAttributeValue("effectShareSet", s.effectShareSet);
            xSettings.SetAttributeValue("slotIndex", s.slotIndex);
            xSettings.SetAttributeValue("clearOnDisable", s.clearOnDisable);
            xComponent.Add(xSettings);
        }
        
        private static void AkAudioListenerExporter(Component component, XElement xComponent)
        {
            var s = (AkAudioListener) component;
            var xSettings = new XElement("Settings");
            xSettings.SetAttributeValue("index", s.index);
            xSettings.SetAttributeValue("lockYaw", s.lockYaw);            
            xSettings.SetAttributeValue("lockPitch", s.lockPitch);     
            xSettings.SetAttributeValue("lockRoll", s.lockRoll);
            xComponent.Add(xSettings);
        }
        
        private static void AkRoomExporter(Component component, XElement xComponent)
        {
            var s = (AkRoom) component;
            var xSettings = new XElement("Settings");
            xSettings.SetAttributeValue("wallOcclusion", s.wallOcclusion);
            xSettings.SetAttributeValue("priority", s.priority);
            xComponent.Add(xSettings);
            ExportWwiseObject(s.roomToneEvent, xComponent);
            ExportWwiseObject(s.reverbAuxBus, xComponent);
        }
        
        private static void AkAmbientExporter(Component component, XElement xComponent)
        {
            var s = (AkAmbient) component;
            ExportWwiseObject(s.data, xComponent);
            var xSettings = new XElement("Settings");
            xSettings.SetAttributeValue("positionMode", s.positionMode);
            var xPositions = new XElement("Positions");
            foreach (var position in s.LargeModePositions)
            {
                xPositions.Add(ExportVector3(position.Position));
            }
            xComponent.Add(xSettings);
        }

        private static void ParticleSoundExporter(Component component, XElement xComponent)
        {
            var s = (ParticleSound) component;
            ExportWwiseObject(s.audioEvent, xComponent);
            var xSettings = new XElement("Settings");
            xSettings.SetAttributeValue("notifyTime", s.notifyTime);
            xSettings.SetAttributeValue("syncWithMultiPositionEvent", s.syncWithMultiPositionEvent);
            xComponent.Add(xSettings);
        }

        private static void AkBankExporter(Component component, XElement xComponent)
        {
            var s = (AkBank) component;
            ExportTriggerSettings(s, xComponent);
            ExportWwiseObject(s.data, xComponent);
        }

        private static void AkStateExporter(Component component, XElement xComponent)
        {
            var s = (AkState) component;
            ExportTriggerSettings(s, xComponent);
            ExportWwiseGroupObject(s.data, xComponent);
        }  
        
        private static void AkSwitchExporter(Component component, XElement xComponent)
        {
            var s = (AkSwitch) component;                    
            ExportTriggerSettings(s, xComponent);
            ExportWwiseGroupObject(s.data, xComponent);
        }

        private static void AkSurfaceReflectorExporter(Component component, XElement xComponent)
        {
            var s = (AkSurfaceReflector) component;
            var xSettings = new XElement("Settings");			
            xSettings.SetAttributeValue("Diffraction", s.EnableDiffraction);						            
            xSettings.SetAttributeValue("OnBoundaryEdges", s.EnableDiffractionOnBoundaryEdges);
            xComponent.Add(xSettings);      
            //ExportAcousticTexture(s.AcousticTexture, xComponent);
        }

        #endregion 
        
        #region ComponentImporters
        private static bool AkBankImporter(Component component, XElement xComponent)
        {
            var s = (AkBank) component;    
            var xSettings = xComponent.Element("Settings");
            var modified = ImportBool(ref s.decodeBank, AkWooduanScriptingTools.GetXmlAttribute(xSettings, "decodeBank"));
            modified |= ImportBool(ref s.IgnoreRefCount, AkWooduanScriptingTools.GetXmlAttribute(xSettings, "IgnoreRefCount"));
            modified |= ImportBank(ref s.data, xComponent);
            return modified;            
        }
        
        private static bool AkEffectImporter(Component component, XElement xComponent)
        {
            var s = (AkEffect) component;    
            var xSettings = xComponent.Element("Settings");
            var modified = ImportBool(ref s.clearOnDisable, AkWooduanScriptingTools.GetXmlAttribute(xSettings, "clearOnDisable"));
            modified |= ImportString(ref s.busName, AkWooduanScriptingTools.GetXmlAttribute(xSettings, "busName"));
            modified |= ImportString(ref s.effectShareSet, AkWooduanScriptingTools.GetXmlAttribute(xSettings, "effectShareSet"));
            modified |= ImportInt(ref s.slotIndex, AkWooduanScriptingTools.GetXmlAttribute(xSettings, "slotIndex"));
            return modified;            
        }
        
        private static bool AkRoofImporter(Component component, XElement xComponent)
        {
            var s = (AkRoof) component;    
            var xSettings = xComponent.Element("Settings");
            return ImportInt(ref s.floor, AkWooduanScriptingTools.GetXmlAttribute(xSettings, "Floor"));            
        }

        private static bool AkAudioListenerImporter(Component component, XElement xComponent)
        {
            var s = (AkAudioListener) component;
            var xSettings = xComponent.Element("Settings");
            var modified = ImportByte(ref s.index, AkWooduanScriptingTools.GetXmlAttribute(xSettings, "index"));
            modified |= ImportBool(ref s.lockYaw, AkWooduanScriptingTools.GetXmlAttribute(xSettings, "lockYaw"));
            modified |= ImportBool(ref s.lockPitch, AkWooduanScriptingTools.GetXmlAttribute(xSettings, "lockPitch"));
            modified |= ImportBool(ref s.lockRoll, AkWooduanScriptingTools.GetXmlAttribute(xSettings, "lockRoll"));      
            return modified;
        }
        
        private static bool AkRoomImporter(Component component, XElement xComponent)
        {
            var s = (AkRoom) component;
            var xSettings = xComponent.Element("Settings");
            var modified = ImportFloat(ref s.transmissionLoss, AkWooduanScriptingTools.GetXmlAttribute(xSettings, "transmissionLoss"));
            modified |= ImportInt(ref s.priority, AkWooduanScriptingTools.GetXmlAttribute(xSettings, "priority"));
            modified |= ImportEvent(ref s.roomToneEvent, xComponent);
            modified |= ImportAuxBus(ref s.reverbAuxBus, xComponent);
            return modified;
        }
        
        private static bool AkAmbientImporter(Component component, XElement xComponent)
        {
            var s = (AkAmbient) component;
            var modified = ImportEnum(ref s.positionMode, AkWooduanScriptingTools.GetXmlAttribute(xComponent, "MultiPositionType"));
            modified |= ImportEvent(ref s.data, xComponent);
            return modified;
        }

        private static bool ParticleSoundImporter(Component component, XElement xComponent)
        {
            var s = (ParticleSound) component;            
            var modified = ImportFloat(ref s.notifyTime, AkWooduanScriptingTools.GetXmlAttribute(xComponent, "notifyTime"));
            modified |= ImportBool(ref s.syncWithMultiPositionEvent, AkWooduanScriptingTools.GetXmlAttribute(xComponent, "syncWithMultiPositionEvent"));
            modified |= ImportEvent(ref s.audioEvent, xComponent);
            return modified;
        }

        private static bool AkStateImporter(Component component, XElement xComponent)
        {
            var s = (AkState) component;     
            var modified = ImportTriggerSettings(s, xComponent);
            //modified |= ImportState(ref s.data, xComponent);
            return modified;
        }  
        
        private static bool AkSwitchImporter(Component component, XElement xComponent)
        {
            var s = (AkSwitch) component;                    
            var modified = ImportTriggerSettings(s, xComponent);
            //modified |= ImportSwitch(ref s.data, xComponent);
            return modified;           
        }

        private static bool AkSurfaceReflectorImporter(Component component, XElement xComponent)
        {
            var s = (AkSurfaceReflector) component;            
            var xSettings = xComponent.Element("Settings");
            var modified = ImportBool(ref s.EnableDiffraction, AkWooduanScriptingTools.GetXmlAttribute(xSettings, "Diffraction"));
            modified |= ImportBool(ref s.EnableDiffractionOnBoundaryEdges, AkWooduanScriptingTools.GetXmlAttribute(xSettings, "OnBoundaryEdges"));
            return modified;
        }
        #endregion
    }
}