//
//  Class:			Util
//	Current CLR:	4.0.30319.34209
//	System:			Microsoft Visual Studio 10.0
//	Author:			dani
// 	Created:		4/13/2015 10:42:13 PM
//
//	Copyright (c) 2015 Informatikbüro Daniel Schick. All rights reserved.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using log4net;

using bsmd.database;

namespace bsmd.herberg.FormService
{
    public static class Util
    {
        private static ILog _log = LogManager.GetLogger(typeof(Util));

        internal static void UpdateFormCore(MessageCore aMessageCore, WebReference.GetFormDataResponseData formResponse)
        {
            ReportingParty bsmdParty = null;
            Dictionary<Guid, ReportingParty> repDict = DBManager.Instance.GetReportingPartyDict();
            foreach (Guid key in repDict.Keys)
            {
                if (repDict[key].Name.Equals("BSMD"))
                {
                    bsmdParty = repDict[key];
                    break;
                }
            }


            for (int i = 0; i < formResponse.formDatasets.Length; i++)
            {
                Dictionary<string, Dictionary<string, string>> groupedVals = new Dictionary<string, Dictionary<string, string>>();
                Dictionary<string, Dictionary<int, Dictionary<string, string>>> groupedRowVals = new Dictionary<string, Dictionary<int, Dictionary<string, string>>>();

                WebReference.FormDataset fds = formResponse.formDatasets[i];

                if (fds.startPeriodSpecified)
                    Trace.WriteLine(fds.startPeriod);
                Trace.WriteLine(string.Format("Dataset {0}", i));
                foreach (WebReference.FormData formData in fds.formData)
                {
                    string[] nElems = formData.name.Split('.');
                    if (nElems.Length != 2)
                    {
                        _log.WarnFormat("Field name {0} has wrong format!", formData.name);
                        continue;
                    }

                    // create dictionaries on demand
                    if (!groupedVals.ContainsKey(nElems[0]))
                        groupedVals[nElems[0]] = new Dictionary<string, string>();
                    if (!groupedRowVals.ContainsKey(nElems[0]))
                        groupedRowVals[nElems[0]] = new Dictionary<int, Dictionary<string, string>>();
                    if (!groupedRowVals[nElems[0]].ContainsKey(formData.rowNo))
                        groupedRowVals[nElems[0]][formData.rowNo] = new Dictionary<string, string>();

                    if (formData.rowNoSpecified == false)
                    {
                        // "normale" Felder werden pro Nachrichtentyp in einem Dict abgespeichert                        

                        groupedVals[nElems[0]][nElems[1]] = formData.value;
                    }
                    else
                    {
                        // "1:n" Felder (mit Zeilennummer) werden in einem Dict<Dict .. abgespeichert. Erster
                        // Schlüssel ist die Row-Id, damit Datensätze aus derselben Zeile zusammenfinden

                        groupedRowVals[nElems[0]][formData.rowNo][nElems[1]] = formData.value;
                    }
                }

                // jetzt können wir die Felder nach Nachrichtentyp abarbeiten
                Dictionary<string, Message> messages = Util.PrepareMessageDict(aMessageCore);

                List<DatabaseEntity> saveMessages = new List<DatabaseEntity>(); // 1:n messages

                foreach (string messageType in groupedVals.Keys)
                {
                    Dictionary<string, string> vDict = groupedVals[messageType];
                    Dictionary<int, Dictionary<string, string>> nDict = groupedRowVals[messageType];

                    DatabaseEntity derivedMessage = null;
                    saveMessages.Clear();

                    Message theMessage = null;
                    if (!messages.ContainsKey(messageType.ToUpper()))
                    {
                        theMessage = new Message();
                        if (messageType.Equals("HAZ")) continue; // HE spezial, sollte HAZA o. HAZD sein
                        if (messageType.Equals("Agency"))
                        {
                            if (aMessageCore.Customer == null) aMessageCore.Customer = new Customer();

                            if (vDict.ContainsKey("Name")) aMessageCore.Customer.Name = vDict["Name"];
                            if (vDict.ContainsKey("Phone")) aMessageCore.Customer.Phone = vDict["Phone"];
                            if (vDict.ContainsKey("Email")) aMessageCore.Customer.Email = vDict["Email"];
                            if (vDict.ContainsKey("ContactFirstName")) aMessageCore.Customer.ContactFirstName = vDict["ContactFirstName"];
                            if (vDict.ContainsKey("ContactLastName")) aMessageCore.Customer.ContactLastName = vDict["ContactLastName"];

                            continue; // das Zeug verhält sich wie eine Not. Class
                        }
                        theMessage.MessageNotificationClass = (Message.NotificationClass)Enum.Parse(typeof(Message.NotificationClass), messageType, true);
                        theMessage.MessageCoreId = aMessageCore.Id;
                        theMessage.MessageCore = aMessageCore;
                        if (bsmdParty != null)
                            theMessage.ReportingParty = bsmdParty;
                    }
                    else
                    {
                        _log.InfoFormat("found message type {0}", messageType);
                        theMessage = messages[messageType.ToUpper()];
                    }

                    switch (messageType)
                    {
                        #region ATA
                        case "ATA":
                            {
                                if (theMessage.Elements.Count == 0)
                                {
                                    ATA newATA = new ATA();
                                    newATA.MessageHeader = theMessage;
                                    theMessage.MessageNotificationClass = Message.NotificationClass.ATA;
                                    theMessage.Elements.Add(newATA);
                                }
                                ATA ata = theMessage.Elements[0] as ATA;
                                derivedMessage = ata;
                                if (ata != null)
                                {
                                    try
                                    {
                                        if (vDict.ContainsKey("ATAPortOfCall")) ata.ATAPortOfCall = DateTime.Parse(vDict["ATAPortOfCall"]);
                                    }
                                    catch (Exception ex)
                                    {
                                        _log.ErrorFormat("Error reading ATA fields: {0}", ex.Message);
                                    }
                                }
                            }
                            break;
                        #endregion

                        #region ATD
                        case "ATD":
                            {
                                if (theMessage.Elements.Count == 0)
                                {
                                    ATD newATD = new ATD();
                                    newATD.MessageHeader = theMessage;
                                    theMessage.MessageNotificationClass = Message.NotificationClass.ATD;
                                    theMessage.Elements.Add(newATD);
                                }
                                ATD atd = theMessage.Elements[0] as ATD;
                                derivedMessage = atd;
                                if (atd != null)
                                {
                                    try
                                    {
                                        if (vDict.ContainsKey("ATDPortOfCall")) atd.ATDPortOfCall = DateTime.Parse(vDict["ATDPortOfCall"]);
                                    }
                                    catch (Exception ex)
                                    {
                                        _log.ErrorFormat("Error reading ATD fields: {0}", ex.Message);
                                    }
                                }
                            }
                            break;
                        #endregion

                        #region NAME
                        case "NAME":
                            {
                                if (theMessage.Elements.Count == 0)
                                {
                                    NAME newName = new NAME();
                                    newName.MessageHeader = theMessage;
                                    theMessage.MessageNotificationClass = Message.NotificationClass.NAME;
                                    theMessage.Elements.Add(newName);
                                }
                                NAME name = theMessage.Elements[0] as NAME;
                                derivedMessage = name;
                                if (name != null)
                                {
                                    try
                                    {
                                        if (vDict.ContainsKey("NameOfMaster")) name.NameOfMaster = vDict["NameOfMaster"];
                                    }
                                    catch (Exception ex)
                                    {
                                        _log.ErrorFormat("Error reading NAME fields: {0}", ex.Message);
                                    }
                                }
                            }
                            break;
                        #endregion

                        #region NOA_NOD
                        case "NOA_NOD":
                            {
                                if (theMessage.Elements.Count == 0)
                                {
                                    NOA_NOD newNOA_NOD = new NOA_NOD();
                                    newNOA_NOD.MessageHeader = theMessage;
                                    theMessage.MessageNotificationClass = Message.NotificationClass.NOA_NOD;
                                    theMessage.Elements.Add(newNOA_NOD);
                                }
                                NOA_NOD noa_nod = theMessage.Elements[0] as NOA_NOD;
                                derivedMessage = noa_nod;
                                if (noa_nod != null)
                                {
                                    try
                                    {
                                        // if (vDict.ContainsKey("CallPurposeCode")) noa_nod.CallPurposeCode = Int32.Parse(vDict["CallPurposeCode"]);
                                        if (vDict.ContainsKey("ETAToNextPort")) noa_nod.ETAToNextPort = DateTime.Parse(vDict["ETAToNextPort"]);
                                        if (vDict.ContainsKey("ETDFromLastPort")) noa_nod.ETDFromLastPort = DateTime.Parse(vDict["ETDFromLastPort"]);
                                        if (vDict.ContainsKey("ETAToPortOfCall")) noa_nod.ETAToPortOfCall = DateTime.Parse(vDict["ETAToPortOfCall"]);
                                        if (vDict.ContainsKey("ETDFromPortOfCall")) noa_nod.ETDFromPortOfCall = DateTime.Parse(vDict["ETDFromPortOfCall"]);
                                        // if (vDict.ContainsKey("CallPurposeDescription")) noa_nod.CallPurposeDescription = vDict["CallPurposeDescription"];
                                        // if(vDict.ContainsKey("CountryOfNextPort")) noa_nod. nicht relevant
                                        if (vDict.ContainsKey("ETAToKielCanal")) noa_nod.ETAToKielCanal = DateTime.Parse(vDict["ETAToKielCanal"]);
                                        if (vDict.ContainsKey("ETDFromKielCanal")) noa_nod.ETDFromKielCanal = DateTime.Parse(vDict["ETDFromKielCanal"]);
                                        if (vDict.ContainsKey("CountryCodeOfLastPort") && vDict.ContainsKey("LastPortCode"))
                                            noa_nod.LastPort = vDict["CountryCodeOfLastPort"] + vDict["LastPortCode"];
                                        if (vDict.ContainsKey("CountryCodeOfNextPort") && vDict.ContainsKey("NextPortCode"))
                                            noa_nod.NextPort = vDict["CountryCodeOfNextPort"] + vDict["NextPortCode"];

                                        foreach (int key in nDict.Keys)
                                        {
                                            Dictionary<string, string> subvDict = nDict[key];
                                            CallPurpose cp = noa_nod.GetSublistElementWithIdentifier(key.ToString()) as CallPurpose;
                                            if (cp == null)
                                            {
                                                cp = new CallPurpose();
                                                cp.Identifier = key.ToString();
                                                cp.NOA_NOD = noa_nod;
                                                noa_nod.CallPurposes.Add(cp);
                                            }

                                            if (subvDict.ContainsKey("CallPurposeCode")) cp.CallPurposeCode = Int32.Parse(subvDict["CallPurposeCode"]);
                                            if (subvDict.ContainsKey("CallPurposeDescription")) cp.CallPurposeDescription = subvDict["CallPurposeDescription"];

                                            saveMessages.Add(cp);
                                        }

                                    }
                                    catch (Exception ex)
                                    {
                                        _log.ErrorFormat("Error reading NOA_NOD fields: {0}", ex.Message);
                                    }
                                }
                            }
                            break;
                        #endregion

                        #region STAT
                        case "STAT":
                            if (theMessage.Elements.Count == 0)
                            {
                                STAT newStat = new STAT();
                                newStat.MessageHeader = theMessage;
                                theMessage.MessageNotificationClass = Message.NotificationClass.STAT;
                                theMessage.Elements.Add(newStat);
                            }
                            STAT stat = theMessage.Elements[0] as STAT;
                            derivedMessage = stat;
                            if (stat != null)
                            {
                                try
                                {
                                    if (vDict.ContainsKey("ShipName")) stat.ShipName = vDict["ShipName"];
                                    if (vDict.ContainsKey("CallSign")) stat.CallSign = vDict["CallSign"];
                                    if (vDict.ContainsKey("MMSINumber")) stat.MMSINumber = vDict["MMSINumber"];
                                    if (vDict.ContainsKey("Flag")) stat.Flag = vDict["Flag"];
                                    if (vDict.ContainsKey("ShipType")) stat.ShipType = vDict["ShipType"];
                                    if (vDict.ContainsKey("LengthOverall_MTR")) stat.LengthOverall_MTR = (float)Double.Parse(vDict["LengthOverall_MTR"]);
                                    if (vDict.ContainsKey("Beam_MTR")) stat.Beam_MTR = (float)Double.Parse(vDict["Beam_MTR"]);
                                    if (vDict.ContainsKey("GrossTonnage")) stat.GrossTonnage = Int32.Parse(vDict["GrossTonnage"]);
                                    // if (vDict.ContainsKey("PortNameOfRegistry")) stat.PortOfRegistry = vDict["PortNameOfRegistry"]; // existiert nicht
                                    if (vDict.ContainsKey("InmarsatCallNumber")) stat.InmarsatCallNumber = vDict["InmarsatCallNumber"];
                                    // if(vDict.ContainsKey("CountryOfRegistry")) stat.r // existiert nicht in spec
                                    if (vDict.ContainsKey("PortCodeOfRegistry") && vDict.ContainsKey("CountryCodeOfRegistry"))
                                        stat.PortOfRegistry = vDict["CountryCodeOfRegistry"] + vDict["PortCodeOfRegistry"];
                                    if (vDict.ContainsKey("ShipTypeCode")) stat.ShipType = vDict["ShipTypeCode"];
                                    if (vDict.ContainsKey("ISMCompanyName")) stat.ISMCompanyName = vDict["ISMCompanyName"];
                                    if (vDict.ContainsKey("ISMCompanyId")) stat.ISMCompanyId = vDict["ISMCompanyId"];
                                    if (vDict.ContainsKey("ISMCompanyStreetAndNumber")) stat.ISMCompanyStreetAndNumber = vDict["ISMCompanyStreetAndNumber"];
                                    if (vDict.ContainsKey("ISMCompanyPostalCode")) stat.ISMCompanyPostalCode = vDict["ISMCompanyPostalCode"];
                                    if (vDict.ContainsKey("ISMCompanyCity")) stat.ISMCompanyCity = vDict["ISMCompanyCity"];
                                    if (vDict.ContainsKey("ISMCompanyCountry")) stat.ISMCompanyCountry = vDict["ISMCompanyCountry"];
                                }
                                catch (Exception ex)
                                {
                                    _log.ErrorFormat("Error reading STAT fields: {0}", ex.Message);
                                }
                            }
                            break;
                        #endregion

                        #region MDH
                        case "MDH":
                            {
                                if (theMessage.Elements.Count == 0)
                                {
                                    MDH newMDH = new MDH();
                                    newMDH.MessageHeader = theMessage;
                                    theMessage.MessageNotificationClass = Message.NotificationClass.MDH;
                                    theMessage.Elements.Add(newMDH);
                                }
                                MDH mdh = theMessage.Elements[0] as MDH;
                                derivedMessage = mdh;
                                if (mdh != null)
                                {
                                    try
                                    {                                        
                                        if (vDict.ContainsKey("Simplification")) mdh.MDHSimplification = vDict["Simplification"].Equals("Y");
                                        if (vDict.ContainsKey("PortOfCallWhereCompleteMDHNotified")) mdh.PortOfCallWhereCompleteMDHNotified = vDict["PortOfCallWhereCompleteMDHNotified"];
                                        if (vDict.ContainsKey("NonAccidentialDeathsDuringVoyage")) mdh.NonAccidentalDeathsDuringVoyage = vDict["NonAccidentialDeathsDuringVoyage"].Equals("Y");
                                        if (vDict.ContainsKey("NonAccidentialDeathsDuringVoyageCount")) mdh.NonAccidentalDeathsDuringVoyageCount = Int32.Parse(vDict["NonAccidentialDeathsDuringVoyageCount"]);
                                        if (vDict.ContainsKey("SuspisionInfectiousNature")) mdh.SuspisionInfectiousNature = vDict["SuspisionInfectiousNature"].Equals("Y");
                                        if (vDict.ContainsKey("NumberOfIllPersonsHigherThanExpected")) mdh.NumberOfIllPersonsHigherThanExpected = vDict["NumberOfIllPersonsHigherThanExpected"].Equals("Y");
                                        if (vDict.ContainsKey("NumberOfIllPersons")) mdh.NumberOfIllPersons = Int32.Parse(vDict["NumberOfIllPersons"]);
                                        if (vDict.ContainsKey("SickPersonsOnBoard")) mdh.SickPersonsOnBoard = vDict["SickPersonsOnBoard"].Equals("Y");
                                        if (vDict.ContainsKey("MedicalConsulted")) mdh.MedicalConsulted = vDict["MedicalConsulted"].Equals("Y");
                                        if (vDict.ContainsKey("AwareOfConditionsForFurtherInfections")) mdh.AwareOfFurtherInfections = vDict["AwareOfConditionsForFurtherInfections"].Equals("Y");
                                        if (vDict.ContainsKey("SanitaryMeasuresApplied")) mdh.SanitaryMeasuresApplied = vDict["SanitaryMeasuresApplied"].Equals("Y");
                                        if (vDict.ContainsKey("SanitaryMeasuresType")) mdh.SanitaryMeasuresType = vDict["SanitaryMeasuresType"];
                                        if (vDict.ContainsKey("SanitaryMeasuresLocation")) mdh.SanitaryMeasuresLocation = vDict["SanitaryMeasuresLocation"];
                                        if (vDict.ContainsKey("SanitaryMeasuresDate")) mdh.SanitaryMeasuresDate = DateTime.Parse(vDict["SanitaryMeasuresDate"]);
                                        if (vDict.ContainsKey("StowawaysDetected")) mdh.StowawaysDetected = vDict["StowawaysDetected"].Equals("Y");
                                        if (vDict.ContainsKey("StowawaysJoiningLocation")) mdh.StowawaysJoiningLocation = vDict["StowawaysJoiningLocation"];
                                        if (vDict.ContainsKey("SickAnimalOrPetOnBoard")) mdh.SickAnimalOrPetOnBoard = vDict["SickAnimalOrPetOnBoard"].Equals("Y");                                        
                                        if (vDict.ContainsKey("ValidSanitaryControlExemptionOrCertificateOnBoard")) mdh.ValidSanitaryControlExemptionOrCertificateOnBoard = vDict["ValidSanitaryControlExemptionOrCertificateOnBoard"].Equals("Y");
                                        if (vDict.ContainsKey("SanitaryControlCertPlaceOfIssue")) mdh.PlaceOfIssue = vDict["SanitaryControlCertPlaceOfIssue"];
                                        if (vDict.ContainsKey("SanitaryControlCertDateOfIssue")) mdh.DateOfIssue = DateTime.Parse(vDict["SanitaryControlCertDateOfIssue"]);
                                        if (vDict.ContainsKey("SanitaryControlReinspectionRequired")) mdh.SanitaryControlReinspectionRequired = vDict["SanitaryControlReinspectionRequired"].Equals("Y");
                                        if (vDict.ContainsKey("InfectedAreaVisited")) mdh.InfectedAreaVisited = vDict["InfectedAreaVisited"].Equals("Y");
                                        if (vDict.ContainsKey("InfectedAreaPort")) mdh.InfectedAreaPort = vDict["InfectedAreaPort"];
                                        if (vDict.ContainsKey("InfectedAreaDate")) mdh.InfectedAreaDate = DateTime.Parse(vDict["InfectedAreaDate"]);

                                        // sublisten
                                        foreach (int key in nDict.Keys)
                                        {
                                            Dictionary<string, string> pDict = nDict[key];
                                            PortOfCallLast30Days poc30 = mdh.GetSublistElementWithIdentifier(key.ToString()) as PortOfCallLast30Days;
                                            if (poc30 == null)
                                            {
                                                poc30 = new PortOfCallLast30Days();
                                                poc30.Identifier = key.ToString();
                                                mdh.PortOfCallLast30Days.Add(poc30);
                                                poc30.MDH = mdh;
                                            }

                                            if (pDict.ContainsKey("PortOfCallLast30DaysDateOfDeparture")) poc30.PortOfCallLast30DaysDateOfDeparture = DateTime.Parse(pDict["PortOfCallLast30DaysDateOfDeparture"]);
                                            if (pDict.ContainsKey("PortOfCallLast30DaysCrewMembersJoined")) poc30.PortOfCallLast30DaysCrewMembersJoined = pDict["PortOfCallLast30DaysCrewMembersJoined"].Equals("Y");
                                            if (pDict.ContainsKey("PortOfCallLast30DaysPortCode") && pDict.ContainsKey("PortOfCallLast30DaysCountryCode"))
                                                poc30.PortOfCallLast30DaysLocode = pDict["PortOfCallLast30DaysCountryCode"] + pDict["PortOfCallLast30DaysPortCode"];



                                            saveMessages.Add(poc30);

                                            // lookup / crew members (Identifier hier der Name! (vereinfachung, ich habe keine rowid))
                                            if (pDict.ContainsKey("PortOfCallLast30DaysCrewMemberNamesJoined"))
                                            {
                                                string[] names = pDict["PortOfCallLast30DaysCrewMemberNamesJoined"].Split(',');
                                                for (int k = 0; k < names.Length; k++)
                                                {
                                                    string crewname = names[k].Trim();
                                                    PortOfCallLast30DaysCrewJoinedShip poc30Crew = poc30.GetSublistElementWithIdentifier(crewname) as PortOfCallLast30DaysCrewJoinedShip;
                                                    if (poc30Crew == null)
                                                    {
                                                        poc30Crew = new PortOfCallLast30DaysCrewJoinedShip();
                                                        poc30Crew.Identifier = crewname;
                                                        poc30Crew.PortOfCallLast30Days = poc30;
                                                        poc30Crew.PortOfCallLast30DaysCrewJoinedShipName = crewname;
                                                        poc30.CrewJoinedShip.Add(poc30Crew);
                                                        saveMessages.Add(poc30Crew);
                                                    }
                                                }                                                
                                            }
                                        }
                                    }
                                    catch (Exception ex)
                                    {
                                        _log.ErrorFormat("Error reading MDH fields: {0}", ex.Message);
                                    }
                                }
                            }
                            break;
                        #endregion

                        #region POBA
                        case "POBA":
                            {
                                if (theMessage.Elements.Count == 0)
                                {
                                    POBA newPOBA = new POBA();
                                    newPOBA.MessageHeader = theMessage;
                                    theMessage.MessageNotificationClass = Message.NotificationClass.POBA;
                                    theMessage.Elements.Add(newPOBA);
                                }
                                POBA poba = theMessage.Elements[0] as POBA;
                                derivedMessage = poba;
                                if (poba != null)
                                {
                                    try
                                    {
                                        if (vDict.ContainsKey("TotalPersonsOnBoardUponArrival")) poba.TotalPersonsOnBoardUponArrival = Int32.Parse(vDict["TotalPersonsOnBoardUponArrival"]);
                                        if (vDict.ContainsKey("TotalCrewMembersOnBoardUponArrival")) poba.TotalCrewMembersOnBoardUponArrival = Int32.Parse(vDict["TotalCrewMembersOnBoardUponArrival"]);
                                        if (vDict.ContainsKey("TotalPassengersOnBoardUponArrival")) poba.TotalPassengersOnBoardUponArrival = Int32.Parse(vDict["TotalPassengersOnBoardUponArrival"]);
                                        if (vDict.ContainsKey("TotalStowawaysOnBoardUponArrival")) poba.TotalStowawaysOnBoardUponArrival = Int32.Parse(vDict["TotalStowawaysOnBoardUponArrival"]);
                                    }
                                    catch (Exception ex)
                                    {
                                        _log.ErrorFormat("Error reading POBA fields: {0}", ex.Message);
                                    }
                                }
                            }
                            break;
                        #endregion

                        #region POBD
                        case "POBD":
                            {
                                if (theMessage.Elements.Count == 0)
                                {
                                    POBD newPOBD = new POBD();
                                    newPOBD.MessageHeader = theMessage;
                                    theMessage.MessageNotificationClass = Message.NotificationClass.POBD;
                                    theMessage.Elements.Add(newPOBD);
                                }
                                POBD pobd = theMessage.Elements[0] as POBD;
                                derivedMessage = pobd;
                                if (pobd != null)
                                {
                                    try
                                    {
                                        if (vDict.ContainsKey("TotalPersonsOnBoardUponDeparture")) pobd.TotalPersonsOnBoardUponDeparture = Int32.Parse(vDict["TotalPersonsOnBoardUponDeparture"]);
                                        if (vDict.ContainsKey("TotalCrewMembersOnBoardUponDeparture")) pobd.TotalCrewMembersOnBoardUponDeparture = Int32.Parse(vDict["TotalCrewMembersOnBoardUponDeparture"]);
                                        if (vDict.ContainsKey("TotalPassengersOnBoardUponDeparture")) pobd.TotalPassengersOnBoardUponDeparture = Int32.Parse(vDict["TotalPassengersOnBoardUponDeparture"]);
                                        if (vDict.ContainsKey("TotalStowawaysOnBoardUponDeparture")) pobd.TotalStowawaysOnBoardUponDeparture = Int32.Parse(vDict["TotalStowawaysOnBoardUponDeparture"]);
                                    }
                                    catch (Exception ex)
                                    {
                                        _log.ErrorFormat("Error reading POBA fields: {0}", ex.Message);
                                    }
                                }
                            }
                            break;
                        #endregion

                        #region BPOL
                        case "BPOL":
                            {
                                if (theMessage.Elements.Count == 0)
                                {
                                    BPOL newBPOL = new BPOL();
                                    newBPOL.MessageHeader = theMessage;
                                    theMessage.MessageNotificationClass = Message.NotificationClass.BPOL;
                                    theMessage.Elements.Add(newBPOL);
                                }
                                BPOL bpol = theMessage.Elements[0] as BPOL;
                                derivedMessage = bpol;
                                if (bpol != null)
                                {
                                    try
                                    {
                                        if (vDict.ContainsKey("StowawayOnBoard")) bpol.StowawaysOnBoard = vDict["StowawayOnBoard"].Equals("Y");
                                        foreach (int key in nDict.Keys)
                                        {
                                            PortOfItinerary poi = bpol.GetSublistElementWithIdentifier(key.ToString()) as PortOfItinerary;
                                            Dictionary<string, string> ppDict = nDict[key];
                                            if (poi == null)
                                            {
                                                poi = new PortOfItinerary();
                                                poi.Identifier = key.ToString();
                                                poi.BPOL = bpol;
                                                bpol.PortOfItineraries.Add(poi);
                                            }

                                            if (ppDict.ContainsKey("PortOfItineraryName")) poi.PortOfItineraryName = ppDict["PortOfItineraryName"];
                                            if (ppDict.ContainsKey("PortOfItineraryETA")) poi.PortOfItineraryETA = DateTime.Parse(ppDict["PortOfItineraryETA"]);

                                            saveMessages.Add(poi);
                                        }
                                    }
                                    catch (Exception ex)
                                    {
                                        _log.ErrorFormat("Error reading BPOL fields: {0}", ex.Message);
                                    }
                                }
                            }
                            break;
                        #endregion

                        #region BKRA
                        case "BKRA":
                            {
                                foreach (int key in nDict.Keys)
                                {
                                    Dictionary<string, string> bDict = nDict[key];
                                    BRKA bkra = theMessage.GetSublistElementWithIdentifier(key.ToString()) as BRKA;
                                    if (bkra == null)
                                    {
                                        bkra = new BRKA();
                                        bkra.MessageHeader = theMessage;
                                        bkra.Identifier = key.ToString();
                                        theMessage.MessageNotificationClass = Message.NotificationClass.BKRA;
                                        theMessage.Elements.Add(bkra);
                                    }

                                    try
                                    {
                                        if (bDict.ContainsKey("BunkerFuelType")) bkra.BunkerFuelType = bDict["BunkerFuelType"];
                                        if (bDict.ContainsKey("BunkerFuelQuantity_TNE")) bkra.BunkerFuelQuantity_TNE = (float)Double.Parse(bDict["BunkerFuelQuantity_TNE"]);
                                    }
                                    catch (Exception ex)
                                    {
                                        _log.ErrorFormat("Error reading BKRA fields: {0}", ex.Message);
                                    }
                                    saveMessages.Add(bkra);
                                }                                
                            }
                            break;
                        #endregion

                        #region SERV
                        case "SERV":
                            {
                                foreach (int key in nDict.Keys)
                                {
                                    Dictionary<string, string> pDict = nDict[key];
                                    SERV serv = theMessage.GetSublistElementWithIdentifier(key.ToString()) as SERV;
                                    if (serv == null)
                                    {
                                        serv = new SERV();
                                        serv.MessageHeader = theMessage;
                                        serv.Identifier = key.ToString();
                                        theMessage.MessageNotificationClass = Message.NotificationClass.SERV;
                                        theMessage.Elements.Add(serv);
                                    }
                                    try
                                    {
                                        if (pDict.ContainsKey("ServiceName")) serv.ServiceName = pDict["ServiceName"];
                                        if (pDict.ContainsKey("ServiceBenificiary")) serv.ServiceBeneficiary = pDict["ServiceBenificiary"];
                                        if (pDict.ContainsKey("ServiceInvoiceRecipient")) serv.ServiceInvoiceRecipient = pDict["ServiceInvoiceRecipient"];
                                    }
                                    catch (Exception ex)
                                    {
                                        _log.ErrorFormat("Error reading SERV fields: {0}", ex.Message);
                                    }

                                    saveMessages.Add(serv);
                                }
                            }
                            break;
                        #endregion

                        #region CREW
                        case "CREW":
                            {
                                foreach (int key in nDict.Keys)
                                {
                                    Dictionary<string, string> pDict = nDict[key];
                                    CREW crew = theMessage.GetSublistElementWithIdentifier(key.ToString()) as CREW;
                                    if (crew == null)
                                    {
                                        crew = new CREW();
                                        crew.MessageHeader = theMessage;
                                        crew.Identifier = key.ToString();
                                        theMessage.MessageNotificationClass = Message.NotificationClass.CREW;
                                        theMessage.Elements.Add(crew);
                                    }
                                    try
                                    {
                                        if (pDict.ContainsKey("CrewMemberLastName")) crew.CrewMemberLastName = pDict["CrewMemberLastName"];
                                        if (pDict.ContainsKey("CrewMemberFirstName")) crew.CrewMemberFirstName = pDict["CrewMemberFirstName"];
                                        if (pDict.ContainsKey("CrewMemberPlaceOfBirth")) crew.CrewMemberPlaceOfBirth = pDict["CrewMemberPlaceOfBirth"];
                                        if (pDict.ContainsKey("CrewMemberDateOfBirth")) crew.CrewMemberDateOfBirth = DateTime.Parse(pDict["CrewMemberDateOfBirth"]);
                                        if (pDict.ContainsKey("CrewMemberGender")) crew.CrewMemberGender = (byte)Enum.Parse(typeof(Enums.PassengerGender), pDict["CrewMemberGender"], true);
                                        if (pDict.ContainsKey("CrewMemberNationalityCode")) crew.CrewMemberNationality = pDict["CrewMemberNationalityCode"];
                                        if (pDict.ContainsKey("CrewMemberIdentityDocumentType")) crew.CrewMemberIdentityDocumentType = (byte)Enum.Parse(typeof(Enums.PassengerIdentityDocumentType), pDict["CrewMemberIdentityDocumentType"], true);
                                        if (pDict.ContainsKey("CrewMemberIdentityDocumentId")) crew.CrewMemberIdentityDocumentId = pDict["CrewMemberIdentityDocumentId"];
                                        if (pDict.ContainsKey("CrewMemberVisaNumber")) crew.CrewMemberVisaNumber = pDict["CrewMemberVisaNumber"];
                                        if (pDict.ContainsKey("CrewMemberDuty")) crew.CrewMemberDuty = pDict["CrewMemberDuty"];
                                    }
                                    catch (Exception ex)
                                    {
                                        _log.ErrorFormat("Error reading CREW fields: {0}", ex.Message);
                                    }

                                    saveMessages.Add(crew);
                                }                               
                            }
                            break;
                        #endregion

                        #region BKRD
                        case "BKRD":
                            {
                                foreach (int key in nDict.Keys)
                                {
                                    Dictionary<string, string> bDict = nDict[key];
                                    BRKD bkrd = theMessage.GetSublistElementWithIdentifier(key.ToString()) as BRKD;
                                    if (bkrd == null)
                                    {
                                        bkrd = new BRKD();
                                        bkrd.MessageHeader = theMessage;
                                        bkrd.Identifier = key.ToString();
                                        theMessage.MessageNotificationClass = Message.NotificationClass.BKRD;
                                        theMessage.Elements.Add(bkrd);
                                    }

                                    try
                                    {
                                        if (bDict.ContainsKey("BunkerFuelType")) bkrd.BunkerFuelType = bDict["BunkerFuelType"];
                                        if (bDict.ContainsKey("BunkerFuelQuantity_TNE")) bkrd.BunkerFuelQuantity_TNE = (float)Double.Parse(bDict["BunkerFuelQuantity_TNE"]);
                                    }
                                    catch (Exception ex)
                                    {
                                        _log.ErrorFormat("Error reading BKRD fields: {0}", ex.Message);
                                    }

                                    saveMessages.Add(bkrd);
                                }
                            }
                            break;
                        #endregion

                        #region INFO
                        case "INFO":
                            {
                                if(theMessage.Elements.Count == 0)
                                {
                                    INFO newInfo = new INFO();
                                    newInfo.MessageHeader = theMessage;
                                    theMessage.MessageNotificationClass = Message.NotificationClass.INFO;
                                    theMessage.Elements.Add(newInfo);
                                }
                                INFO info = theMessage.Elements[0] as INFO;
                                derivedMessage = info;
                                if (info != null)
                                {
                                    try
                                    {
                                        if (vDict.ContainsKey("ShippingArea")) info.ShippingArea = (byte) Enum.Parse(typeof(Enums.ShippingArea), vDict["ShippingArea"]);
                                        if (vDict.ContainsKey("RequestedPositionInPortOfCall")) info.RequestedPositionInPortOfCall = vDict["RequestedPositionInPortOfCall"];
                                        if (vDict.ContainsKey("SpecialRequirementsOfShipAtBerth")) info.SpecialRequirementsOfShipAtBerth = vDict["SpecialRequirementsOfShipAtBerth"];
                                        if (vDict.ContainsKey("ConstructionCharacteristicsOfShip")) info.ConstructionCharacteristicsOfShip = vDict["ConstructionCharacteristicsOfShip"];
                                        if (vDict.ContainsKey("FumigatedBulkCargo")) info.FumigatedBulkCargo = (byte)Enum.Parse(typeof(Enums.FumigatedBulkCargo), vDict["FumigatedBulkCargo"]);
                                    }
                                    catch(Exception ex)
                                    {
                                        _log.ErrorFormat("Error reading INFO fields: {0}", ex.Message);
                                    }
                                }
                            }
                            break;
                        #endregion

                        #region PRE72H
                        case "PRE72H":
                            {
                                if (theMessage.Elements.Count == 0)
                                {
                                    PRE72H newp = new PRE72H();
                                    newp.MessageHeader = theMessage;
                                    theMessage.MessageNotificationClass = Message.NotificationClass.PRE72H;
                                    theMessage.Elements.Add(newp);
                                }
                                PRE72H pre72h = theMessage.Elements[0] as PRE72H;
                                derivedMessage = pre72h;
                                if (pre72h != null)
                                {
                                    try
                                    {
                                        if (vDict.ContainsKey("Tanker")) pre72h.Tanker = vDict["Tanker"].Equals("Y");
                                        if (vDict.ContainsKey("TankerHullConfiguration")) pre72h.TankerHullConfiguration = (byte)Enum.Parse(typeof(Enums.TankerHullConfiguration), vDict["TankerHullConfiguration"]);
                                        if (vDict.ContainsKey("ConditionCargoBallastTanks")) pre72h.ConditionCargoBallastTanks = (byte)Enum.Parse(typeof(Enums.ConditionCargoBallastTanks), vDict["ConditionCargoBallastTanks"]);
                                        if (vDict.ContainsKey("NatureOfCargo")) pre72h.NatureOfCargo = vDict["NatureOfCargo"];
                                        if (vDict.ContainsKey("VolumeOfCargo_TNE")) pre72h.VolumeOfCargo = (float)Double.Parse(vDict["VolumeOfCargo_TNE"]);
                                        if (vDict.ContainsKey("PlannedOperations")) pre72h.PlannedOperations = vDict["PlannedOperations"];
                                        if (vDict.ContainsKey("PlannedWorks")) pre72h.PlannedWorks = vDict["PlannedWorks"];
                                        if (vDict.ContainsKey("DateOfLastExpandedInspection")) pre72h.DateOfLastExpandedInspection = DateTime.Parse(vDict["DateOfLastExpandedInspection"], DateTimeFormatInfo.InvariantInfo);
                                        if (vDict.ContainsKey("PlannedPeriodOfStay_HUR")) pre72h.PlannedPeriodOfStay_HUR = (float)Double.Parse(vDict["PlannedPeriodOfStay_HUR"]);
                                    }
                                    catch (Exception ex)
                                    {
                                        _log.ErrorFormat("Error reading PRE72H fields: {0}", ex.Message);
                                    }
                                }
                            }
                            break;
                        #endregion

                        #region LADG
                        case "LADG":
                            {
                                foreach (int key in nDict.Keys)
                                {
                                    Dictionary<string, string> lDict = nDict[key];
                                    LADG ladg = theMessage.GetSublistElementWithIdentifier(key.ToString()) as LADG;
                                    if (ladg == null)
                                    {
                                        ladg = new LADG();
                                        ladg.MessageHeader = theMessage;
                                        ladg.Identifier = key.ToString();
                                        theMessage.MessageNotificationClass = Message.NotificationClass.LADG;
                                        theMessage.Elements.Add(ladg);
                                    }
                                    if (lDict.ContainsKey("CargoGrossQuantity_TNE")) ladg.CargoGrossQuantity_TNE = (float)Double.Parse(lDict["CargoGrossQuantity_TNE"]);
                                    if (lDict.ContainsKey("CargoNumberOfItems")) ladg.CargoNumberOfItems = Int32.Parse(lDict["CargoNumberOfItems"]);
                                    if (lDict.ContainsKey("CargoCodeNST")) ladg.CargoCodeNST = lDict["CargoCodeNST"];
                                    if (lDict.ContainsKey("CargoHandlingType")) ladg.CargoHandlingType = (byte) Enum.Parse(typeof(Enums.CargoHandlingType), lDict["CargoHandlingType"]);

                                    saveMessages.Add(ladg);
                                }
                            }
                            break;
                        #endregion

                        #region PAS
                        case "PAS":
                            {
                                foreach (int key in nDict.Keys)
                                {
                                    Dictionary<string, string> pDict = nDict[key];
                                    PAS pas = theMessage.GetSublistElementWithIdentifier(key.ToString()) as PAS;
                                    if (pas == null)
                                    {
                                        pas = new PAS();
                                        pas.MessageHeader = theMessage;
                                        pas.Identifier = key.ToString();
                                        theMessage.MessageNotificationClass = Message.NotificationClass.PAS;
                                        theMessage.Elements.Add(pas);
                                    }
                                    try
                                    {
                                        if (pDict.ContainsKey("PassengerLastName")) pas.PassengerLastName = pDict["PassengerLastName"];
                                        if (pDict.ContainsKey("PassengerFirstName")) pas.PassengerFirstName = pDict["PassengerFirstName"];
                                        if (pDict.ContainsKey("PassengerPlaceOfBirth")) pas.PassengerPlaceOfBirth = pDict["PassengerPlaceOfBirth"];
                                        if (pDict.ContainsKey("PassengerDateOfBirth")) pas.PassengerDateOfBirth = DateTime.Parse(pDict["PassengerDateOfBirth"]);
                                        if (pDict.ContainsKey("PassengerGender")) pas.PassengerGender = (byte)Enum.Parse(typeof(Enums.PassengerGender), pDict["PassengerGender"], true);
                                        if (pDict.ContainsKey("PassengerNationalityCode")) pas.PassengerNationality = pDict["PassengerNationalityCode"];
                                        if (pDict.ContainsKey("PassengerIdentityDocumentType")) pas.PassengerIdentityDocumentType = (byte)Enum.Parse(typeof(Enums.PassengerIdentityDocumentType), pDict["PassengerIdentityDocumentType"]);
                                        if (pDict.ContainsKey("PassengerIdentityDocumentId")) pas.PassengerIdentityDocumentId = pDict["PassengerIdentityDocumentId"];
                                        if (pDict.ContainsKey("PassengerVisaNumber")) pas.PassengerVisaNumber = pDict["PassengerVisaNumber"];
                                        if (pDict.ContainsKey("PassengerPortCodeOfEmbarkation") && pDict.ContainsKey("PassengerCountryCodeOfEmbarkation"))
                                            pas.PassengerPortOfEmbarkation = pDict["PassengerCountryCodeOfEmbarkation"] + pDict["PassengerPortCodeOfEmbarkation"];
                                        if (pDict.ContainsKey("PassengerPortCodeOfDisembarkation") && pDict.ContainsKey("PassengerCountryCodeOfDisembarkation"))
                                            pas.PassengerPortOfDisembarkation = pDict["PassengerCountryCodeOfEmbarkation"] + pDict["PassengerPortCodeOfDisembarkation"];
                                        if (pDict.ContainsKey("PassengerInTransit")) pas.PassengerInTransit = pDict["PassengerInTransit"].Equals("Y");
                                    }
                                    catch (Exception ex)
                                    {
                                        _log.ErrorFormat("Error reading PAS fields: {0}", ex.Message);
                                    }

                                    saveMessages.Add(pas);
                                }
                            }
                            break;
                        #endregion

                        #region WAS
                        case "WAS":
                            {
                                if (theMessage.Elements.Count == 0)
                                {
                                    WAS newWAS = new WAS();
                                    newWAS.MessageHeader = theMessage;
                                    theMessage.MessageNotificationClass = Message.NotificationClass.WAS;
                                    theMessage.Elements.Add(newWAS);
                                }
                                WAS was = theMessage.Elements[0] as WAS;
                                derivedMessage = was;
                                if (was != null)
                                {
                                    try
                                    {
                                        if (vDict.ContainsKey("WasteDisposalValidExemption")) was.WasteDisposalValidExemption = vDict["WasteDisposalValidExemption"].Equals("Y");
                                        if (vDict.ContainsKey("LastWasteDisposalDate")) was.LastWasteDisposalDate = DateTime.Parse(vDict["LastWasteDisposalDate"]);

                                        if (vDict.ContainsKey("LastWasteDisposalPortCode") && vDict.ContainsKey("LastWasteDisposalCountryCode"))
                                            was.LastWasteDisposalPort = vDict["LastWasteDisposalCountryCode"] + vDict["LastWasteDisposalPortCode"];
                                        if (vDict.ContainsKey("WasteDisposalDelivery")) was.WasteDisposalDelivery = (byte) Enum.Parse(typeof(Enums.WasteDisposalDelivery), vDict["WasteDisposalDelivery"], true);                                        
                                        if (vDict.ContainsKey("ConfirmationOfCorrectness")) was.ConfirmationOfCorrectness = vDict["ConfirmationOfCorrectness"].Equals("Y");

                                        // parse given waste
                                        foreach(int key in nDict.Keys) {
                                            Dictionary<string, string> wDict = nDict[key];
                                            Waste waste = was.GetSublistElementWithIdentifier(key.ToString()) as Waste;
                                            if (waste == null)
                                            {
                                                waste = new Waste();
                                                waste.Identifier = key.ToString();
                                                waste.WAS = was;
                                                was.Waste.Add(waste);
                                            }

                                            if(wDict.ContainsKey("WasteAmountGeneratedTillNextPort_MTQ")) waste.WasteAmountGeneratedTillNextPort_MTQ = (float) Double.Parse(wDict["WasteAmountGeneratedTillNextPort_MTQ"]);
                                            if(wDict.ContainsKey("WasteAmountRetained_MTQ")) waste.WasteAmountRetained_MTQ = (float) Double.Parse(wDict["WasteAmountRetained_MTQ"]);
                                            if(wDict.ContainsKey("WasteCapacity_MTQ")) waste.WasteCapacity_MTQ = (float) Double.Parse(wDict["WasteCapacity_MTQ"]);
                                            if(wDict.ContainsKey("WasteDisposalAmount_MTQ")) waste.WasteDisposalAmount_MTQ = (float) Double.Parse(wDict["WasteDisposalAmount_MTQ"]);
                                            if(wDict.ContainsKey("WasteDescription")) waste.WasteDescription = wDict["WasteDescription"];
                                            if(wDict.ContainsKey("WasteType")) waste.WasteType = Enums.ParseWasteType(wDict["WasteType"]);
                                            if(wDict.ContainsKey("WasteDisposalPort")) waste.WasteDisposalPort = wDict["WasteDisposalPort"];

                                            saveMessages.Add(waste);
                                        }

                                        if (vDict.ContainsKey("WasteDisposalServiceProviderName"))
                                        {
                                            WasteDisposalServiceProvider wdsp = null;
                                            if (was.WasteDisposalServiceProvider.Count == 0)
                                            {
                                                wdsp = new WasteDisposalServiceProvider();
                                                wdsp.WAS = was;
                                                was.WasteDisposalServiceProvider.Add(wdsp);
                                            }
                                            else
                                            {
                                                wdsp = was.WasteDisposalServiceProvider[0];
                                            }
                                            wdsp.WasteDisposalServiceProviderName = vDict["WasteDisposalServiceProviderName"];
                                            saveMessages.Add(wdsp);
                                        }

                                    }
                                    catch (Exception ex)
                                    {
                                        _log.ErrorFormat("Error reading WAS fields: {0}", ex.Message);
                                    }
                                }
                            }
                            break;
                        #endregion

                        #region SEC
                        case "SEC":
                            {
                                if (theMessage.Elements.Count == 0)
                                {
                                    SEC newSEC = new SEC();
                                    newSEC.MessageHeader = theMessage;
                                    theMessage.MessageNotificationClass = Message.NotificationClass.SEC;
                                    theMessage.Elements.Add(newSEC);
                                }
                                SEC sec = theMessage.Elements[0] as SEC;
                                derivedMessage = sec;
                                if (sec != null)
                                {
                                    try
                                    {
                                        if (vDict.ContainsKey("Simplification")) sec.SECSimplification = vDict["Simplification"].Equals("Y");
                                        if (vDict.ContainsKey("PortOfCallWhereCompleteSECNotified")) sec.PortOfCallWhereCompleteSECNotified = vDict["PortOfCallWhereCompleteSECNotified"];
                                        if (vDict.ContainsKey("CSOLastName")) sec.CSOLastName = vDict["CSOLastName"];
                                        if (vDict.ContainsKey("CSOFirstName")) sec.CSOFirstName = vDict["CSOFirstName"];
                                        if (vDict.ContainsKey("CSOPhone")) sec.CSOPhone = vDict["CSOPhone"];
                                        if (vDict.ContainsKey("CSOFax")) sec.CSOFax = vDict["CSOFax"];
                                        if (vDict.ContainsKey("CSOEMail")) sec.CSOEMail = vDict["CSOEMail"];
                                        if (vDict.ContainsKey("ValidISSCOnBoard")) sec.ValidISSCOnBoard = vDict["ValidISSCOnBoard"].Equals("Y");
                                        if (vDict.ContainsKey("ReasonsForNoValidISSC")) sec.ReasonsForNoValidISSC = vDict["ReasonsForNoValidISSC"];
                                        if (vDict.ContainsKey("ISSCType")) sec.ISSCType = (byte)Enum.Parse(typeof(Enums.ISSCType), vDict["ISSCType"]);
                                        if (vDict.ContainsKey("ISSCIssuerType")) sec.ISSCIssuerType = (byte)Enum.Parse(typeof(Enums.ISSCIssuerType), vDict["ISSCIssuerType"]);
                                        if (vDict.ContainsKey("ISSCIssuerName")) sec.ISSCIssuerName = vDict["ISSCIssuerName"];
                                        if (vDict.ContainsKey("ISSCDateOfExpiration")) sec.ISSCDateOfExpiration = DateTime.Parse(vDict["ISSCDateOfExpiration"]);
                                        if (vDict.ContainsKey("ApprovedSecurityPlanOnBoard")) sec.ApprovedSecurityPlanOnBoard = vDict["ApprovedSecurityPlanOnBoard"].Equals("Y");
                                        if (vDict.ContainsKey("CurrentShipSecurityLevel")) sec.CurrentShipSecurityLevel = Byte.Parse(vDict["CurrentShipSecurityLevel"]);
                                        if (vDict.ContainsKey("PortFacilityOfArrival")) sec.PortFacilityOfArrival = vDict["PortFacilityOfArrival"];
                                        if (vDict.ContainsKey("GeneralDescriptionOfCargo")) sec.GeneralDescriptionOfCargo = (byte)Enum.Parse(typeof(Enums.GeneralDescriptionOfCargo), vDict["GeneralDescriptionOfCargo"]);
                                        
                                        // process sublists

                                        foreach (int key in nDict.Keys)
                                        {
                                            Dictionary<string, string> sDict = nDict[key];
                                            bool changedPfC = false;
                                            bool changedStS = false;

                                            ShipToShipActivitiesDuringLastTenPortFacilitiesCalled sts = sec.GetShipToShipWithIdentifier(key.ToString());
                                            if(sts == null)
                                            {
                                                sts = new ShipToShipActivitiesDuringLastTenPortFacilitiesCalled();
                                                sts.SEC = sec;
                                                sts.Identifier = key.ToString();
                                                sec.ShipToShipActivitiesDuringLastTenPortFacilitiesCalled.Add(sts);
                                            }

                                            LastTenPortFacilitiesCalled poc = sec.GetPortFacilityWithIdentifier(key.ToString());
                                            if (poc == null)
                                            {
                                                poc = new LastTenPortFacilitiesCalled();
                                                poc.SEC = sec;
                                                poc.Identifier = key.ToString();
                                                sec.LastTenPortFacilitesCalled.Add(poc);
                                            }

                                            if (sDict.ContainsKey("PortFacilityPortName")) { poc.PortFacilityPortName = sDict["PortFacilityPortName"]; changedPfC = true; }
                                            if (sDict.ContainsKey("PortFacilityPortCountry")) { poc.PortFacilityPortCountry = sDict["PortFacilityPortCountry"]; changedPfC = true; }
                                            if (sDict.ContainsKey("PortFacilityPortLoCode") && sDict.ContainsKey("PortFacilityPortCountryCode"))
                                            {
                                                poc.PortFacilityPortLoCode = sDict["PortFacilityPortCountryCode"] + sDict["PortFacilityPortLoCode"]; 
                                                changedPfC = true;
                                            }
                                            if (sDict.ContainsKey("PortFacilityDateOfArrival")) { poc.PortFacilityDateOfArrival = DateTime.Parse(sDict["PortFacilityDateOfArrival"]); changedPfC = true; }
                                            if (sDict.ContainsKey("PortFacilityDateOfDeparture")) { poc.PortFacilityDateOfDeparture = DateTime.Parse(sDict["PortFacilityDateOfDeparture"]); changedPfC = true; }
                                            if (sDict.ContainsKey("PortFacilityShipSecurityLevel")) { poc.PortFacilityShipSecurityLevel = Byte.Parse(sDict["PortFacilityShipSecurityLevel"]); changedPfC = true; }
                                            if (sDict.ContainsKey("PortFacilitySecurityMattersToReport")) { poc.PortFacilitySecurityMattersToReport = sDict["PortFacilitySecurityMattersToReport"]; changedPfC = true; }
                                            if (sDict.ContainsKey("PortFacilityGISISCode")) { poc.PortFacilityGISISCode = sDict["PortFacilityGISISCode"]; changedPfC = true; }

                                            if (sDict.ContainsKey("ShipToShipActivityLocationName")) { sts.ShipToShipActivityLocationName = sDict["ShipToShipActivityLocationName"]; changedStS = true; }
                                            if (sDict.ContainsKey("ShipToShipActivityLocationLoCode") && sDict.ContainsKey("ShipToShipActivityCountryCode"))
                                            {
                                                sts.ShipToShipActivityLocationLoCode = sDict["ShipToShipActivityCountryCode"] + sDict["ShipToShipActivityLocationLoCode"];
                                                changedStS = true;
                                            }
                                            if (sDict.ContainsKey("ShipToShipActivityLocationCoordinatesLatitude")) { sts.ShipToShipActivityLocationCoordinatesLatitude = Int32.Parse(sDict["ShipToShipActivityLocationCoordinatesLatitude"]); changedStS = true; }
                                            if (sDict.ContainsKey("ShipToShipActivityLocationCoordinatesLongitude")) { sts.ShipToShipActivityLocationCoordinatesLongitude = Int32.Parse(sDict["ShipToShipActivityLocationCoordinatesLongitude"]); changedStS = true; }
                                            if (sDict.ContainsKey("ShipToShipActivityDateFrom")) { sts.ShipToShipActivityDateFrom = DateTime.Parse(sDict["ShipToShipActivityDateFrom"]); changedStS = true; }
                                            if (sDict.ContainsKey("ShipToShipActivityDateTo")) { sts.ShipToShipActivityDateTo = DateTime.Parse(sDict["ShipToShipActivityDateTo"]); changedStS = true; }
                                            if (sDict.ContainsKey("ShipToShipActivityType")) { sts.ShipToShipActivityType = sDict["ShipToShipActivityType"]; changedStS = true; }
                                            if (sDict.ContainsKey("ShipToShipActivitySecurityMattersToReport")) { sts.ShipToShipActivitySecurityMattersToReport = sDict["ShipToShipActivitySecurityMattersToReport"]; changedStS = true; }

                                            if (changedPfC) saveMessages.Add(poc);
                                            if (changedStS) saveMessages.Add(sts);
                                        }
                                    }
                                    catch (Exception ex)
                                    {
                                        _log.ErrorFormat("Error reading SEC fields: {0}", ex.Message);
                                    }
                                }
                            }
                            break;
                        #endregion

                        #region Visit
                        case "Visit":
                            {
                                theMessage.MessageNotificationClass = Message.NotificationClass.VISIT;
                                if (vDict.ContainsKey("PortNameOfCall")) aMessageCore.Portname = vDict["PortNameOfCall"];
                                if (vDict.ContainsKey("PortOfCall")) aMessageCore.PoC = "DE" + vDict["PortOfCall"];
                                if (vDict.ContainsKey("TransitKielCanal")) aMessageCore.IsTransit = vDict["TransitKielCanal"].Equals("Y");
                                if (vDict.ContainsKey("ETAPortOfCall")) aMessageCore.ETA = DateTime.Parse(vDict["ETAPortOfCall"]);
                                if (vDict.ContainsKey("ETAKielCanal")) aMessageCore.ETAKielCanal = DateTime.Parse(vDict["ETAKielCanal"]);
                            }
                            break;
                        #endregion

                        #region Transit
                        case "Transit":
                            {
                                theMessage.MessageNotificationClass = Message.NotificationClass.TRANSIT;
                                if (vDict.ContainsKey("ETAKielCanal")) aMessageCore.ETAKielCanal = DateTime.Parse(vDict["ETAKielCanal"]);
                            }
                            break;
                        #endregion

                        #region TOWA
                        case "TOWA":
                            foreach (int key in nDict.Keys)
                            {
                                Dictionary<string, string> pDict = nDict[key];
                                TOWA towa = theMessage.GetSublistElementWithIdentifier(key.ToString()) as TOWA;
                                if (towa == null)
                                {
                                    towa = new TOWA();
                                    towa.MessageHeader = theMessage;
                                    towa.Identifier = key.ToString();
                                    theMessage.MessageNotificationClass = Message.NotificationClass.TOWA;
                                    theMessage.Elements.Add(towa);
                                }
                                try
                                {
                                    if (pDict.ContainsKey("TowageOnArrivalBeam_MTR")) towa.TowageOnArrivalBeam_MTR = (float)Double.Parse(pDict["TowageOnArrivalBeam_MTR"]);
                                    if (pDict.ContainsKey("TowageOnArrivalDraught_DMT")) towa.TowageOnArrivalDraught_DMT = (float)Double.Parse(pDict["TowageOnArrivalDraught_DMT"]);
                                    if (pDict.ContainsKey("TowageOnArrivalLengthOverall_MTR")) towa.TowageOnArrivalLengthOverall_MTR = (float)Double.Parse(pDict["TowageOnArrivalLengthOverall_MTR"]);
                                    if (pDict.ContainsKey("TowageOnArrivalGrossTonnage")) towa.TowageOnArrivalGrossTonnage = Int32.Parse(pDict["TowageOnArrivalGrossTonnage"]);
                                    if (pDict.ContainsKey("TowageOnArrivalOperatorCountry")) towa.TowageOnArrivalOperatorCountry = pDict["TowageOnArrivalOperatorCountry"];
                                    if (pDict.ContainsKey("TowageOnArrivalPurposeOfCall")) towa.TowageOnArrivalPurposeOfCall = pDict["TowageOnArrivalPurposeOfCall"];
                                    if (pDict.ContainsKey("TowageOnArrivalName")) towa.TowageOnArrivalName = pDict["TowageOnArrivalName"];
                                    if (pDict.ContainsKey("TowageOnArrivalFlag")) towa.TowageOnArrivalFlag = pDict["TowageOnArrivalFlag"];
                                    if (pDict.ContainsKey("TowageOnArrivalOperatorCompanyName")) towa.TowageOnArrivalOperatorCompanyName = pDict["TowageOnArrivalOperatorCompanyName"];
                                    if (pDict.ContainsKey("TowageOnArrivalOperatorStreetAndNumber")) towa.TowageOnArrivalOperatorStreetNameAndNumber = pDict["TowageOnArrivalOperatorStreetAndNumber"];
                                    if (pDict.ContainsKey("TowageOnArrivalOperatorPostalCode")) towa.TowageOnArrivalOperatorPostalCode = pDict["TowageOnArrivalOperatorPostalCode"];
                                    if (pDict.ContainsKey("TowageOnArrivalOperatorCity")) towa.TowageOnArrivalOperatorCity = pDict["TowageOnArrivalOperatorCity"];
                                    if (pDict.ContainsKey("TowageOnArrivalOperatorPhone")) towa.TowageOnArrivalOperatorPhone = pDict["TowageOnArrivalOperatorPhone"];
                                    if (pDict.ContainsKey("TowageOnArrivalOperatorFax")) towa.TowageOnArrivalOperatorFax = pDict["TowageOnArrivalOperatorFax"];
                                    if (pDict.ContainsKey("TowageOnArrivalOperatorEmail")) towa.TowageOnArrivalOperatorEmail = pDict["TowageOnArrivalOperatorEmail"];
                                    if (pDict.ContainsKey("TowageOnArrivalRemarks")) towa.TowageOnArrivalRemarks = pDict["TowageOnArrivalRemarks"];
                                }
                                catch (Exception ex)
                                {
                                    _log.ErrorFormat("Error reading TOWA fields: {0}", ex.Message);
                                }
                                saveMessages.Add(towa);
                            }
                            break;
                        #endregion

                        #region TOWD
                        case "TOWD":
                            foreach (int key in nDict.Keys)
                            {
                                Dictionary<string, string> pDict = nDict[key];
                                TOWD towd = theMessage.GetSublistElementWithIdentifier(key.ToString()) as TOWD;
                                if (towd == null)
                                {
                                    towd = new TOWD();
                                    towd.MessageHeader = theMessage;
                                    towd.Identifier = key.ToString();
                                    theMessage.MessageNotificationClass = Message.NotificationClass.TOWD;
                                    theMessage.Elements.Add(towd);
                                }
                                try
                                {
                                    if (pDict.ContainsKey("TowageOnDepartureBeam_MTR")) towd.TowageOnDepartureBeam_MTR = (float)Double.Parse(pDict["TowageOnDepartureBeam_MTR"]);
                                    if (pDict.ContainsKey("TowageOnDepartureDraught_DMT")) towd.TowageOnDepartureDraught_DMT = (float)Double.Parse(pDict["TowageOnDepartureDraught_DMT"]);
                                    if (pDict.ContainsKey("TowageOnDepartureLengthOverall_MTR")) towd.TowageOnDepartureLengthOverall_MTR = (float)Double.Parse(pDict["TowageOnDepartureLengthOverall_MTR"]);                                    
                                    if (pDict.ContainsKey("TowageOnDepartureOperatorCountry")) towd.TowageOnDepartureOperatorCountry = pDict["TowageOnDepartureOperatorCountry"];                                    
                                    if (pDict.ContainsKey("TowageOnDepartureName")) towd.TowageOnDepartureName = pDict["TowageOnDepartureName"];
                                    if (pDict.ContainsKey("TowageOnDepartureFlag")) towd.TowageOnDepartureFlag = pDict["TowageOnDepartureFlag"];
                                    if (pDict.ContainsKey("TowageOnDepartureOperatorCompanyName")) towd.TowageOnDepartureOperatorCompanyName = pDict["TowageOnDepartureOperatorCompanyName"];
                                    if (pDict.ContainsKey("TowageOnDepartureOperatorStreetAndNumber")) towd.TowageOnDepartureOperatorStreetNameAndNumber = pDict["TowageOnDepartureOperatorStreetAndNumber"];
                                    if (pDict.ContainsKey("TowageOnDepartureOperatorPostalCode")) towd.TowageOnDepartureOperatorPostalCode = pDict["TowageOnDepartureOperatorPostalCode"];
                                    if (pDict.ContainsKey("TowageOnDepartureOperatorCity")) towd.TowageOnDepartureOperatorCity = pDict["TowageOnDepartureOperatorCity"];
                                    if (pDict.ContainsKey("TowageOnDepartureOperatorPhone")) towd.TowageOnDepartureOperatorPhone = pDict["TowageOnDepartureOperatorPhone"];
                                    if (pDict.ContainsKey("TowageOnDepartureOperatorFax")) towd.TowageOnDepartureOperatorFax = pDict["TowageOnDepartureOperatorFax"];
                                    if (pDict.ContainsKey("TowageOnDepartureOperatorEmail")) towd.TowageOnDepartureOperatorEmail = pDict["TowageOnDepartureOperatorEmail"];
                                    if (pDict.ContainsKey("TowageOnDepartureRemarks")) towd.TowageOnDepartureRemarks = pDict["TowageOnDepartureRemarks"];
                                }
                                catch (Exception ex)
                                {
                                    _log.ErrorFormat("Error reading TOWA fields: {0}", ex.Message);
                                }
                                saveMessages.Add(towd);
                            }
                            break;
                        #endregion

                        #region TIEFA
                        case "TIEFA":
                            {
                                if (theMessage.Elements.Count == 0)
                                {
                                    TIEFA newTIEFA = new TIEFA();
                                    newTIEFA.MessageHeader = theMessage;
                                    theMessage.MessageNotificationClass = Message.NotificationClass.TIEFA;
                                    theMessage.Elements.Add(newTIEFA);
                                }
                                TIEFA tiefa = theMessage.Elements[0] as TIEFA;
                                derivedMessage = tiefa;
                                if (tiefa != null)
                                {
                                    try
                                    {
                                        if (vDict.ContainsKey("DraughtUponArrival_DMT")) tiefa.DraughtUponArrival_DMT = (float)Double.Parse(vDict["DraughtUponArrival_DMT"]);
                                    }
                                    catch (Exception ex)
                                    {
                                        _log.ErrorFormat("Error reading TIEFA fields: {0}", ex.Message);
                                    }
                                }
                                break;
                            }
                        #endregion

                        #region TIEFD
                        case "TIEFD":
                            {
                                if (theMessage.Elements.Count == 0)
                                {
                                    TIEFD newTIEFD = new TIEFD();
                                    newTIEFD.MessageHeader = theMessage;
                                    theMessage.MessageNotificationClass = Message.NotificationClass.TIEFD;
                                    theMessage.Elements.Add(newTIEFD);
                                }
                                TIEFD tiefd = theMessage.Elements[0] as TIEFD;
                                derivedMessage = tiefd;
                                if (tiefd != null)
                                {
                                    try
                                    {
                                        if (vDict.ContainsKey("DraughtUponDeparture_DMT")) tiefd.DraughtUponDeparture_DMT = (float)Double.Parse(vDict["DraughtUponDeparture_DMT"]);
                                    }
                                    catch (Exception ex)
                                    {
                                        _log.ErrorFormat("Error reading TIEFD fields: {0}", ex.Message);
                                    }
                                }
                                break;
                            }
                        #endregion

                    }

                    // Die Logik dient dazu, dass bei "leeren" Nachrichten (also z.B. MDH ohne MDH Infos) nicht nur der
                    // Header gespeichert wird und danach in der Luft hängt
                    if ((theMessage.MessageNotificationClass == Message.NotificationClass.VISIT) ||
                        (theMessage.MessageNotificationClass == Message.NotificationClass.TRANSIT) ||
                        (derivedMessage != null) ||
                        (saveMessages.Count > 0)                        
                        )
                    {
                        DBManager.Instance.Save(theMessage);
                        if (derivedMessage != null)
                            DBManager.Instance.Save(derivedMessage);
                        foreach (DatabaseEntity saveEntity in saveMessages)
                            DBManager.Instance.Save(saveEntity);
                    }
                }

                DBManager.Instance.Save(aMessageCore); // warum?
            }
        }

        /// <summary>
        /// Aufbereitung eines Dictionaries: Nachrichtentyp (aus Feld-Präfixen) zu eigentlichen Nachrichten
        /// </summary>
        private static Dictionary<string, Message> PrepareMessageDict(MessageCore aMessageCore)
        {
            List<Message> messages = DBManager.Instance.GetMessagesForCore(aMessageCore);
            Dictionary<string, Message> result = new Dictionary<string, Message>();
            _log.InfoFormat("Core has {0} messages", messages.Count);
            foreach (Message message in messages)
            {
                if (!result.ContainsKey(message.MessageNotificationClass.ToString()))
                {
                    result.Add(message.MessageNotificationClass.ToString(), message);
                }
                else
                {
                    // es gibt schon einen Nachricht mit diesem Typ. 
                    // Das kann nur der Fall sein wenn es schon eine Cancel/Reset Nachricht gegeben hat. In diesem Fall wird eine
                    // Nachricht überschrieben, wenn beide Flags nicht gesetzt sind
                    if (!message.Reset && !message.Cancel)
                    {
                        result[message.MessageNotificationClass.ToString()] = message;
                    }
                }
            }
            return result;
        }
    }
}