FrameObjectDictionary.cs

#region Header
/*
    ==============================================================================
      Author: Zoltan Hrabovszki <zh@openkeyword.de>

      Copyright © 2012, 2013, 2014, 2015 IT-Beratung Hrabovszki
      www.OpenKeyWord.de
    ============================================================================== 

    This file is part of OpenKeyWord.

    OpenKeyWord is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    OpenKeyWord is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with OpenKeyWord.  If not, see <http://www.gnu.org/licenses/>.

    Diese Datei ist Teil von OpenKeyWord.

    OpenKeyWord ist Freie Software: Sie können es unter den Bedingungen
    der GNU General Public License, wie von der Free Software Foundation,
    Version 3 der Lizenz oder (nach Ihrer Wahl) jeder späteren
    veröffentlichten Version, weiterverbreiten und/oder modifizieren.

    OpenKeyWord wird in der Hoffnung, dass es nützlich sein wird, aber
    OHNE JEDE GEWÄHRLEISTUNG, bereitgestellt; sogar ohne die implizite
    Gewährleistung der MARKTFÄHIGKEIT oder EIGNUNG FÜR EINEN BESTIMMTEN ZWECK.
    Siehe die GNU General Public License für weitere Details.

    Sie sollten eine Kopie der GNU General Public License zusammen mit 
    OpenKeyWord erhalten haben. Wenn nicht, siehe <http://www.gnu.org/licenses/>.
*/
#endregion Header

namespace OKW
{
    using System;
    using System.Collections.Generic;
    using System.Reflection;
    using System.Linq;
    using OKW;
    using OKW.Log;

    public class FrameObjectDictionary
    {
        #region Fields

        public Dictionary<string, object> __FrameObjectDictionary = new Dictionary<string, object>();

        private LogMessenger LM = null;

        #endregion Fields

        #region Constructors

        public FrameObjectDictionary()
        {
            Logger.Instance.LogFunctionStartDebug("FrameObjectDictionary.FrameObjectDictionary");

            this.Init();

            Logger.Instance.LogFunctionEndDebug();
        }

        #endregion Constructors

        #region Methods

        public object GetParentObjectByName(string fpsParentObject)
        {
            object lvo_Return = null;

            Logger.Instance.LogFunctionStartDebug("FrameObjectDictionary.GetParentObjectByName", "fpsFunctionalnameOfWindow", fpsParentObject);
            try {
                // Gibt es den Schlüssel im Dictinary? - D.h. Gibt es schon eine Instanz des Objektes im Speicher?
                Logger.Instance.LogPrintDebug(this.LM.GetMessage("GetParentObjectByName", "M1", fpsParentObject));
                if (this.__FrameObjectDictionary.ContainsKey(fpsParentObject))
                {
                    // Ja, das Objekt existiert.
                    Logger.Instance.LogPrintDebug(this.LM.GetMessage("GetParentObjectByName", "M2"));
                    lvo_Return = this.__FrameObjectDictionary[fpsParentObject];
                } else {
                    // Nein -> Frame zum Funtionalen NAme wurde nicht gefunden -> Exception auslösen...
                    // \todo TODO: Fehlermeldung einbauen...
                    Logger.Instance.LogPrintDebug(this.LM.GetMessage("GetParentObjectByName", "M3"));

                    string lvsMessage = this.LM.GetMessage("GetParentObjectByName", "OKWFrameObjectParentNotFoundException", fpsParentObject);
                    throw new OKWFrameObjectParentNotFoundException(lvsMessage);
                }
            } finally {
                Logger.Instance.LogFunctionEndDebug();
            }
            
            return lvo_Return;
        }

        public object GetChildObjectByName(string fps_ParentObject, string fps_ChildObject)
        {
            object lvo_Return = null;
            string lvs_ObjectName = fps_ParentObject + "." + fps_ChildObject;

            Logger.Instance.LogFunctionStartDebug("FrameObjectDictionary.GetChildObjectByName", "fps_ParentObject", fps_ParentObject, "fps_ChildObject", fps_ChildObject);

            // Gibt es den Schlüssel im Dictinary?
            Logger.Instance.LogPrintDebug(this.LM.GetMessage("GetChildObjectByName", "M1", fps_ChildObject, fps_ParentObject));

            if (this.__FrameObjectDictionary.ContainsKey(lvs_ObjectName)) {
                // Ja, das Objekt existiert.
                Logger.Instance.LogPrintDebug(this.LM.GetMessage("GetChildObjectByName", "M2"));
                // Hole refarenc auf des Objekt im Dictionary
                lvo_Return = this.__FrameObjectDictionary[lvs_ObjectName];
            } else {
                // Nein -> Frame zum Funtionalen Name wurde nicht gefunden -> Exception OKWFrameObjectChildNotFoundException auslösen...
                // \todo TODO: Fehlermeldung einbauen...
                Logger.Instance.LogPrintDebug(this.LM.GetMessage("GetChildObjectByName", "M3"));

                string lvsMessage = this.LM.GetMessage("GetChildObjectByName", "OKWFrameObjectChildNotFoundException", lvs_ObjectName );
                throw new OKWFrameObjectChildNotFoundException(lvsMessage);
            }

            Logger.Instance.LogFunctionEndDebug();
            return lvo_Return;
        }

        public void Init()
        {
            Logger.Instance.LogFunctionStartDebug("FrameObjectDictionary.Init");

            
            try {
                this.LM = new LogMessenger("FrameObjectDictionary");

                Logger.Instance.LogPrint(this.LM.GetMessage("Init", "InitClear", this.GetType().Name));
                this.__FrameObjectDictionary.Clear();
                
                List<Type> lvOKWGuiClasses = GetListOfOKWGuiClasses();
                
                this.AddFrameInstancesToDictionary(lvOKWGuiClasses);
            } finally {
                Logger.Instance.LogFunctionEndDebug();
            }
        }

        public List<Type> GetListOfOKWGuiClasses()
        {
            string @namespace = "OKW.Frames";
            var lvLsReturn = new List<Type>();

            Type[] myTypes;
                                    
            Assembly[] appAssemblies = AppDomain.CurrentDomain.GetAssemblies();

            for (int i = 0; i < appAssemblies.Length; i++) {
                Logger.Instance.LogPrint("-------------------------------------------------------------------------------------------");
                Logger.Instance.LogPrint(string.Format("Assambly {0}: {1}\n", i, appAssemblies[i].FullName));
                Logger.Instance.LogPrint("-------------------------------------------------------------------------------------------");
                
                Assembly myAssembly = appAssemblies[i];
                myTypes = myAssembly.GetTypes();
       
                var q = from t in myTypes
                                where t.IsClass && t.Namespace == @namespace
                                select t;
            
                foreach (Type t in q) {
                    if (t.GetCustomAttributes(typeof(OKWGUIAttribute), true).Length > 0) {
                        lvLsReturn.Add(t);
                    }
                }
            }
            return lvLsReturn;
        }
        

        private void AddFrameInstancesToDictionary(List<Type> fpListOfOKWGuiTypes)
        {
            object lvTypeInstanceAsObject = null;

            Logger.Instance.LogFunctionStartDebug("FrameObjectDictionary.AddFrameInstancesToDictionary");

            try {
                // Für jede Klasse...
                foreach (Type lvOKWGuiClass in fpListOfOKWGuiTypes) {
                    lvTypeInstanceAsObject = CreateInstanceByType(lvOKWGuiClass);
                    
                    // Funktionalenname der Klasse aus dem Attribute OKWGUI auslesen.
                    string lvFunktionalname = this.GetFunktionlanameFromObjekt(lvTypeInstanceAsObject);
                    
                    // Wenn Attribute vorhanden (!=null) und nicht Leer dann ins Dictionary einfügen.
                    if (!string.IsNullOrEmpty(lvFunktionalname)) {
                        string lvsKey = lvFunktionalname;
                        System.Console.WriteLine("\n Window Frame: >>" + lvsKey + "<<");
                        System.Console.WriteLine("     Technisches Objekt: >>" + lvTypeInstanceAsObject.GetType().FullName + "<<");

                        this.__FrameObjectDictionary.Add(lvFunktionalname, lvTypeInstanceAsObject);
                        
                        Logger.Instance.LogPrintDebug(this.LM.GetMessage("CreateInstanceByObjectName", "InstanceWasCreated", lvTypeInstanceAsObject.GetType().FullName));
                        
                        //nun Rekursive die Kinder (=Felder) des Frames durgehen und ins einlesen.
                        Scanfields(lvOKWGuiClass, lvTypeInstanceAsObject, lvFunktionalname);
                    }
                }
            } finally {
                Logger.Instance.LogFunctionEndDebug();
            }
            
            return;
        }

        
        public void Scanfields(Type fpType, object fpsWindowAsObject, string fpsWindowName)
        {
            Type myType = fpType;
            
            try {
                // Get the FieldInfo of MyClass.
                FieldInfo[] myFields = myType.GetFields(BindingFlags.Public | BindingFlags.Instance);
                
                foreach (FieldInfo myField in myFields) {
                    object[] myAttribute = myField.GetCustomAttributes(typeof(OKWGUIAttribute), false);
                    
                    object lvoChildObjekt = fpsWindowAsObject.GetType().InvokeMember(
                                                               myField.Name,
                                                               BindingFlags.GetField,
                                                               null,
                                                               fpsWindowAsObject,
                                                               null);
                    
                    if (myAttribute.Length > 0) {
                        OKWGUIAttribute myOKWGUI = (OKWGUIAttribute)myAttribute[0];
                        // Get the value from property.
                        
                        string lvsKey = fpsWindowName + "." + myOKWGUI.FunctionalName;
                        System.Console.WriteLine("\n   Child: >>" + lvsKey + "<<");
                        System.Console.WriteLine("        Technisches Objekt: >>" + lvoChildObjekt.GetType().FullName + "<<");
                        
                        __FrameObjectDictionary.Add(fpsWindowName + "." + myOKWGUI.FunctionalName, lvoChildObjekt);
                        
                        // Dann im Bojket weiter Scannen...
                        Scanfields(myField.FieldType, lvoChildObjekt, fpsWindowName);
                    } else {
                        Scanfields(myField.FieldType, lvoChildObjekt, fpsWindowName);
                    }
                }
            } catch (Exception e) {
                Console.WriteLine("Exception : {0}", e.Message);
            }
        }


        private string GetFunktionlanameFromObjekt(object fpObject)
        {
            string lvsReturn = "";

            Attribute[] attrs = System.Attribute.GetCustomAttributes(fpObject.GetType());  // Reflection.

            // Displaying output.
            foreach (System.Attribute attr in attrs) {
                if (attr is OKWGUIAttribute) {
                    OKWGUIAttribute a = (OKWGUIAttribute)attr;
                    lvsReturn = a.FunctionalName;
                }
            }
            
            return lvsReturn;
        }


        private object CreateInstanceByType(Type fpParentType)
        {
            object lvo_Obj = null;
            bool bOK = false;

            Logger.Instance.LogFunctionStartDebug("FrameObjectDictionary.CreateInstanceByObjectName", "fpParentClass", fpParentType.FullName);

            try {
                lvo_Obj = Activator.CreateInstance(fpParentType, null);
                
                Logger.Instance.LogPrintDebug(this.LM.GetMessage("CreateInstanceByObjectName", "InstanceWasCreated", lvo_Obj.GetType().FullName));
                bOK = true;
            } catch (TargetInvocationException e) {
                // EXCEPTION: Pürfen was hier genau passiert. Exception weitergeben
                throw new OKWFrameObjectParentNotFoundException(this.LM.GetMessage("CreateInstanceByObjectName", "InstanceWasCreated", fpParentType.FullName), e);
            } finally {
                if (bOK) {
                    // Wir sind ohne Exception durchgekommen und wir nehmen an,
                    // dass lvo_Obj != null
                    // -> wir geben den Namen des Objektes zurück...
                    Logger.Instance.LogFunctionEndDebug(lvo_Obj.GetType().FullName);
                } else {
                    // Irgend etwas ist faul wir rufen nur LogFunctionEndDebug auf...
                    Logger.Instance.LogFunctionEndDebug();
                }
            }
            
            return lvo_Obj;
        }

        private object __CreateInstanceByObjectName(string fps_ParentObject, string fps_ChildObject)
        {
            Logger.Instance.LogFunctionStartDebug("FrameObjectDictionary.CreateInstanceByObjectName", "fps_ParentObject", fps_ParentObject, "fps_ChildObject", fps_ChildObject);

            object myParentObject = null;
            object myChildObject = null;
            bool bOK = false;

            try {
                // PerentObject holen und ggf. als instanz anlegen
                myParentObject = this.GetParentObjectByName(fps_ParentObject);

                // Kindobjekt aufrufen...
                // aber nur wenn Paretobjekt gefunden worden ist.
                if (myParentObject != null) {
                    // FIXME: was ist wenn das myChildObject = null ist??Checken
                    myChildObject = this.GetChildObjectByName(myParentObject, fps_ChildObject);
                } else {
                    // LANGUAGE: Log Schreiben..
                    throw new OKWFrameObjectParentNotFoundException("Frame Objekt des Fensters");
                }

                bOK = true;
            } finally {
                if (bOK) {
                    // Wir sind ohne Exception durchgekommen und wir nehmen an,
                    // dass lvo_Obj != null
                    // -> wir geben den Namen des Objektes zurück...
                    Logger.Instance.LogFunctionEndDebug(myChildObject.GetType().FullName);
                } else {
                    // Irgend etwas ist faul wir rufen nur LogFunctionEndDebug auf...
                    Logger.Instance.LogFunctionEndDebug();
                }
            }
            
            return myChildObject;
        }

        private object GetChildObjectByName(object fpo_ParentObject, string fps_ChildName)
        {
            object lvo_Return = null;

            Logger.Instance.LogFunctionStartDebug("FrameObjectDictionary.GetChildObjectByName", "fpo_ParentObject", fpo_ParentObject.ToString(), "fps_ChildName", fps_ChildName);

            try {
                FieldInfo fieldInfoObj = fpo_ParentObject.GetType().GetField(fps_ChildName);

                // Existiert es das Kindobjekt >>{0:}<< im Objekt >>{1:}<<?
                Logger.Instance.LogPrintDebug(this.LM.GetMessage("GetChildObjectByName", "M1", fps_ChildName, fpo_ParentObject.GetType().Name));
                if (fieldInfoObj == null) {
                    // Nein -> Exception auslösen und alles beenden!
                    Logger.Instance.LogPrintDebug(this.LM.GetMessage("GetChildObjectByName", "M3"));
                    throw new OKWFrameObjectChildNotFoundException(this.LM.GetMessage("GetChildObjectByName", "ChildIsNotDefined_Exception", fps_ChildName, fpo_ParentObject.GetType().Name));
                } else {
                    // Ja, das Objekt existiert.
                    Logger.Instance.LogPrintDebug(this.LM.GetMessage("GetChildObjectByName", "M2"));

                    // Get the value from property.
                    lvo_Return = fpo_ParentObject.GetType().InvokeMember(
                        fieldInfoObj.Name,
                        BindingFlags.GetField,
                        null,
                        fpo_ParentObject,
                        null);
                }
            } finally {
                Logger.Instance.LogFunctionEndDebug();
            }

            return lvo_Return;
        }

        #endregion Methods
    }
}