// Copyright (c) 2017- schick Informatik
// Description: Helper class to read data from "Dakosy"-Style Excel Sheets
//

using log4net;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using bsmd.database;

namespace ENI2.Excel
{
    internal static class DakosyUtil
    {
        private static readonly ILog _log = LogManager.GetLogger(typeof(DakosyUtil));

        internal static bool ProcessSheet(ExcelReader reader, out string readMessage, MessageCore messageCore, List<Message.NotificationClass> notificationClasses)
        {
            bool result = true;
            readMessage = "";

            // Test if an Id is found in the sheet. If so, it has to match the id of the current core
            string visitTransitId = reader.ReadCellAsText("main", "C12");
            if (visitTransitId != null)
            {
                MessageCore aMessageCore = null;
                if (bsmd.database.Util.IsVisitId(visitTransitId))
                {
                    aMessageCore = DBManager.Instance.GetMessageCoreByVisitId(visitTransitId);
                }
                else if (bsmd.database.Util.IsTransitId(visitTransitId))
                {
                    aMessageCore = DBManager.Instance.GetMessageCoreByTransitId(visitTransitId);
                }

                if ((aMessageCore == null) || (aMessageCore.Id.Value != messageCore.Id.Value))
                {
                    readMessage = "Id not matching in import sheet";
                    return false;
                }
            }            

            // load messages if already present
            List<Message> messages = DBManager.Instance.GetMessagesForCore(messageCore, DBManager.MessageLoad.ALL);
            messages.Sort();

            // now parse all data into the message classes            
            try
            {

                foreach (Message message in messages)
                {
                    if ((message.MessageNotificationClass == Message.NotificationClass.AGNT) && notificationClasses.Contains(Message.NotificationClass.AGNT))
                    { if (ScanAGNT(message, reader)) ExcelReader.SaveMessage(message); continue; }
                    if ((message.MessageNotificationClass == Message.NotificationClass.ATA) && notificationClasses.Contains(Message.NotificationClass.ATA))
                    { if (ScanATA(message, reader)) ExcelReader.SaveMessage(message); continue; }
                    if ((message.MessageNotificationClass == Message.NotificationClass.ATD) && notificationClasses.Contains(Message.NotificationClass.ATD))
                    { if (ScanATD(message, reader)) ExcelReader.SaveMessage(message); continue; }
                    if ((message.MessageNotificationClass == Message.NotificationClass.BKRA) && notificationClasses.Contains(Message.NotificationClass.BKRA))
                    { if (ScanBKRA(message, reader)) ExcelReader.SaveMessage(message); continue; }
                    if ((message.MessageNotificationClass == Message.NotificationClass.BKRD) && notificationClasses.Contains(Message.NotificationClass.BKRD))
                    { if (ScanBKRD(message, reader)) ExcelReader.SaveMessage(message); continue; }
                    if ((message.MessageNotificationClass == Message.NotificationClass.BPOL) && notificationClasses.Contains(Message.NotificationClass.BPOL))
                    { if (ScanBPOL(message, messages, messageCore, reader)) ExcelReader.SaveMessage(message); }
                    if ((message.MessageNotificationClass == Message.NotificationClass.CREW) && notificationClasses.Contains(Message.NotificationClass.CREW))
                    { if (ScanCREW(message, reader)) ExcelReader.SaveMessage(message); continue; }
                    if ((message.MessageNotificationClass == Message.NotificationClass.CREWD) && notificationClasses.Contains(Message.NotificationClass.CREWD))
                    { if (ScanCREWD(message, reader)) ExcelReader.SaveMessage(message); continue; }
                    if ((message.MessageNotificationClass == Message.NotificationClass.HAZA) && notificationClasses.Contains(Message.NotificationClass.HAZA))
                    { if (ScanHAZA(message, reader)) ExcelReader.SaveMessage(message); continue; }
                    if ((message.MessageNotificationClass == Message.NotificationClass.HAZD) && notificationClasses.Contains(Message.NotificationClass.HAZD))
                    { if (ScanHAZD(message, reader)) ExcelReader.SaveMessage(message); continue; }
                    if ((message.MessageNotificationClass == Message.NotificationClass.INFO) && notificationClasses.Contains(Message.NotificationClass.INFO))
                    { if (ScanINFO(message, reader)) ExcelReader.SaveMessage(message); continue; }
                    if ((message.MessageNotificationClass == Message.NotificationClass.LADG) && notificationClasses.Contains(Message.NotificationClass.LADG))
                    { if (ScanLADG(message, reader)) ExcelReader.SaveMessage(message); continue; }
                    if ((message.MessageNotificationClass == Message.NotificationClass.MDH) && notificationClasses.Contains(Message.NotificationClass.MDH))
                    { if (ScanMDH(message, reader)) ExcelReader.SaveMessage(message); continue; }
                    if ((message.MessageNotificationClass == Message.NotificationClass.NAME) && notificationClasses.Contains(Message.NotificationClass.NAME))
                    { if (ScanNAME(message, reader)) ExcelReader.SaveMessage(message); continue; }
                    if ((message.MessageNotificationClass == Message.NotificationClass.NOA_NOD) && notificationClasses.Contains(Message.NotificationClass.NOA_NOD))
                    { if (ScanNOA_NOD(message, reader)) ExcelReader.SaveMessage(message); continue; }
                    if ((message.MessageNotificationClass == Message.NotificationClass.PAS) && notificationClasses.Contains(Message.NotificationClass.PAS))
                    { if (ScanPAS(message, reader)) ExcelReader.SaveMessage(message); continue; }
                    if ((message.MessageNotificationClass == Message.NotificationClass.PASD) && notificationClasses.Contains(Message.NotificationClass.PASD))
                    { if (ScanPASD(message, reader)) ExcelReader.SaveMessage(message); continue; }
                    if ((message.MessageNotificationClass == Message.NotificationClass.POBA) && notificationClasses.Contains(Message.NotificationClass.POBA))
                    { if (ScanPOBA(message, reader)) ExcelReader.SaveMessage(message); continue; }
                    if ((message.MessageNotificationClass == Message.NotificationClass.POBD) && notificationClasses.Contains(Message.NotificationClass.POBD))
                    { if (ScanPOBD(message, reader)) ExcelReader.SaveMessage(message); continue; }
                    if ((message.MessageNotificationClass == Message.NotificationClass.PRE72H) && notificationClasses.Contains(Message.NotificationClass.PRE72H))
                    { if (ScanPRE72H(message, reader)) ExcelReader.SaveMessage(message); continue; }
                    if ((message.MessageNotificationClass == Message.NotificationClass.SEC) && notificationClasses.Contains(Message.NotificationClass.SEC))
                    { if (ScanSEC(message, reader)) ExcelReader.SaveMessage(message); continue; }
                    if ((message.MessageNotificationClass == Message.NotificationClass.SERV) && notificationClasses.Contains(Message.NotificationClass.SERV))
                    { if (ScanSERV(message, reader)) ExcelReader.SaveMessage(message); continue; }
                    if ((message.MessageNotificationClass == Message.NotificationClass.STAT) && notificationClasses.Contains(Message.NotificationClass.STAT))
                    { if (ScanSTAT(message, messageCore, reader)) ExcelReader.SaveMessage(message); continue; }
                    if ((message.MessageNotificationClass == Message.NotificationClass.STO) && notificationClasses.Contains(Message.NotificationClass.STO))
                    { if (ScanSTO(message, reader)) ExcelReader.SaveMessage(message); continue; }
                    if ((message.MessageNotificationClass == Message.NotificationClass.TIEFA) && notificationClasses.Contains(Message.NotificationClass.TIEFA))
                    { if (ScanTIEFA(message, reader)) ExcelReader.SaveMessage(message); continue; }
                    if ((message.MessageNotificationClass == Message.NotificationClass.TIEFD) && notificationClasses.Contains(Message.NotificationClass.TIEFD))
                    { if (ScanTIEFD(message, reader)) ExcelReader.SaveMessage(message); continue; }
                    if ((message.MessageNotificationClass == Message.NotificationClass.TOWA) && notificationClasses.Contains(Message.NotificationClass.TOWA))
                    { if (ScanTOWA(message, reader)) ExcelReader.SaveMessage(message); continue; }
                    if ((message.MessageNotificationClass == Message.NotificationClass.TOWD) && notificationClasses.Contains(Message.NotificationClass.TOWD))
                    { if (ScanTOWD(message, reader)) ExcelReader.SaveMessage(message); continue; }
                    if ((message.MessageNotificationClass == Message.NotificationClass.WAS) && notificationClasses.Contains(Message.NotificationClass.WAS))
                    { if (ScanWAS(message, reader)) ExcelReader.SaveMessage(message); continue; }
                    if ((message.MessageNotificationClass == Message.NotificationClass.WAS_RCPT) && notificationClasses.Contains(Message.NotificationClass.WAS_RCPT))
                    { if (ScanWAS_RCPT(message, reader)) ExcelReader.SaveMessage(message); continue; }

                }

                DBManager.Instance.Save(messageCore);            // muss das eigentlich sein?
            }
            catch (Exception ex)
            {
                readMessage = ex.Message;
                result = false;
            }

            return result;
        }

        private static bool ScanWAS_RCPT(Message message, ExcelReader reader)
        {
            throw new NotImplementedException();
        }

        private static bool ScanWAS(Message message, ExcelReader reader)
        {
            throw new NotImplementedException();
        }

        private static bool ScanTOWD(Message message, ExcelReader reader)
        {
            throw new NotImplementedException();
        }

        private static bool ScanTOWA(Message message, ExcelReader reader)
        {
            throw new NotImplementedException();
        }

        private static bool ScanTIEFD(Message tiefdMessage, ExcelReader reader)
        {
            if (tiefdMessage.Elements.Count == 0)
            {
                TIEFD newTIEFD = new TIEFD();
                newTIEFD.MessageHeader = tiefdMessage;
                tiefdMessage.Elements.Add(newTIEFD);
            }
            TIEFD tiefd = tiefdMessage.Elements[0] as TIEFD;
            tiefd.DraughtUponDeparture_DMT = reader.ReadCellAsDecimal("traffic message on departure", "C14");
            return tiefd.DraughtUponDeparture_DMT.HasValue;
        }

        private static bool ScanTIEFA(Message tiefaMessage, ExcelReader reader)
        {
            if (tiefaMessage.Elements.Count == 0)
            {
                TIEFA newTIEFA = new TIEFA();
                newTIEFA.MessageHeader = tiefaMessage;
                tiefaMessage.Elements.Add(newTIEFA);
            }
            TIEFA tiefa = tiefaMessage.Elements[0] as TIEFA;
            tiefa.DraughtUponArrival_DMT = reader.ReadCellAsDecimal("traffic message on arrival", "C14");
            return tiefa.DraughtUponArrival_DMT.HasValue;
        }

        private static bool ScanSTO(Message message, ExcelReader reader)
        {
            throw new NotImplementedException();
        }

        private static bool ScanSTAT(Message statMessage, MessageCore core, ExcelReader reader)
        {
            if (statMessage.Elements.Count == 0)
            {
                STAT newSTAT = new STAT();
                newSTAT.MessageHeader = statMessage;
                statMessage.Elements.Add(newSTAT);
            }
            STAT stat = statMessage.Elements[0] as STAT;
            stat.ShipName = reader.ReadCellAsText("ship", "C8");
            stat.CallSign = reader.ReadCellAsText("ship", "C9");
            core.IMO = reader.ReadCellAsText("ship", "C10");
            core.ENI = reader.ReadCellAsText("ship", "C11");
            core.PoC = reader.ReadCellAsText("port message", "C8");
            DBManager.Instance.Save(core);
            stat.MMSINumber = reader.ReadCellAsText("ship", "C12");
            stat.Flag = reader.ReadCellAsText("ship", "C13");
            stat.LengthOverall_MTR = reader.ReadCellAsDecimal("ship", "C14");
            stat.Beam_MTR = reader.ReadCellAsDecimal("ship", "C15");
            stat.GrossTonnage = (int?) reader.ReadCellAsDecimal("ship", "C16");
            stat.PortOfRegistry = reader.ReadCellAsText("ship", "C17");
            stat.InmarsatCallNumber = string.Format("{0} {1} {2} {3} {4}",
                reader.ReadCellAsText("ship", "C18"),
                reader.ReadCellAsText("ship", "C19"),
                reader.ReadCellAsText("ship", "C20"),
                reader.ReadCellAsText("ship", "C21"),
                reader.ReadCellAsText("ship", "C22")
                ).Trim();
            stat.ShipType = reader.ReadCellAsText("ship", "C23");
            stat.TransportMode = reader.ReadCellAsText("ship", "C24");
            
            stat.ISMCompanyName = reader.ReadCellAsText("ship", "C26");
            stat.ISMCompanyId = reader.ReadCellAsText("ship", "C27");
            string street = reader.ReadCellAsText("ship", "C28");
            string number = reader.ReadCellAsText("ship", "C29");
            stat.ISMCompanyStreetAndNumber = string.Format("{0} {1}", street, number).Trim();
            stat.ISMCompanyPostalCode = reader.ReadCellAsText("ship", "C30");
            stat.ISMCompanyCity = reader.ReadCellAsText("ship", "C31");
            stat.ISMCompanyCountry = reader.ReadCellAsText("ship", "C32");

            return true;
        }

        private static bool ScanSERV(Message servMessage, ExcelReader reader)
        {
            bool result = false;

            for(int i=0;i<10000;i++)
            {
                string serviceName = reader.ReadCellAsText("port message", string.Format("B{0}", i + 50));
                string serviceBeneficiary = reader.ReadCellAsText("port message", string.Format("C{0}", i + 50));
                string serviceInvoiceRecipient = reader.ReadCellAsText("port message", string.Format("D{0}", i + 50));
                if (serviceName.IsNullOrEmpty() && serviceBeneficiary.IsNullOrEmpty()) break;

                if (!(servMessage.GetSublistElementWithIdentifier((i + 1).ToString()) is SERV serv))
                {
                    serv = new SERV();
                    serv.MessageHeader = servMessage;
                    serv.Identifier = (i + 1).ToString();
                    servMessage.Elements.Add(serv);
                }
                serv.ServiceName = serviceName;
                serv.ServiceBeneficiary = serviceBeneficiary;
                serv.ServiceInvoiceRecipient = serviceInvoiceRecipient;
                result = true;
            }
           
            return result;
        }

        private static bool ScanSEC(Message secMessage, ExcelReader reader)
        {
            if (secMessage.Elements.Count == 0)
            {
                SEC newSEC = new SEC();
                newSEC.MessageHeader = secMessage;
                secMessage.Elements.Add(newSEC);
            }
            SEC sec = secMessage.Elements[0] as SEC;
            sec.CurrentShipSecurityLevel = (byte?)reader.ReadCellAsDecimal("security", "D7");
            sec.SECSimplification = reader.ReadCellAsBool("security", "D9");

            sec.KielCanalPassagePlanned = reader.ReadCellAsBool("security", "I7");
            if(sec.KielCanalPassagePlanned ?? false)
            {
                sec.KielCanalPassagePlannedIncomming = reader.ReadCellAsDateTime("security", "I9");
                sec.KielCanalPassagePlannedOutgoing = reader.ReadCellAsDateTime("security", "I12");
            }

            if(sec.SECSimplification ?? false)
            {
                sec.PortOfCallWhereCompleteSECNotified = reader.ReadCellAsText("security", "D10")?.Substring(0, 5);
            } 
            else
            {
                sec.CSOLastName = reader.ReadCellAsText("security", "D12");
                sec.CSOFirstName = reader.ReadCellAsText("security", "D13");
                sec.CSOPhone = reader.ReadCellAsText("security", "D14");
                sec.CSOFax = reader.ReadCellAsText("security", "D15");
                sec.CSOEMail = reader.ReadCellAsText("security", "D16");
                sec.ValidISSCOnBoard = reader.ReadCellAsBool("security", "D17");
                sec.ReasonsForNoValidISSC = reader.ReadCellAsText("security", "D18");
                string isscType = reader.ReadCellAsText("security", "D19");
                if(!isscType.IsNullOrEmpty())
                {
                    if (isscType.Equals("full", StringComparison.OrdinalIgnoreCase)) sec.ISSCType = 0;
                    if (isscType.Equals("interim", StringComparison.OrdinalIgnoreCase)) sec.ISSCType = 1;
                }
                string issuerType = reader.ReadCellAsText("security", "D20");
                if(!issuerType.IsNullOrEmpty())
                {
                    if (isscType.Equals("ADMINISTRATION", StringComparison.OrdinalIgnoreCase)) sec.ISSCIssuerType = 0;
                    if (isscType.Equals("RSO", StringComparison.OrdinalIgnoreCase)) sec.ISSCIssuerType = 1;
                }
                sec.ISSCIssuerName = reader.ReadCellAsText("security", "D21");
                sec.ISSCDateOfExpiration = reader.ReadCellAsDateTime("security", "D22");
                sec.ApprovedSecurityPlanOnBoard = reader.ReadCellAsBool("security", "D23");
                sec.PortFacilityOfArrival = reader.ReadCellAsText("security", "D24");
                string generalDoC = reader.ReadCellAsText("security", "D25");
                if(!generalDoC.IsNullOrEmpty())
                {
                    if(generalDoC.Equals("container", StringComparison.OrdinalIgnoreCase)) sec.GeneralDescriptionOfCargo = 0;
                    if (generalDoC.Equals("vehicles", StringComparison.OrdinalIgnoreCase)) sec.GeneralDescriptionOfCargo = 1;
                    if (generalDoC.Equals("conventional_general_cargo", StringComparison.OrdinalIgnoreCase)) sec.GeneralDescriptionOfCargo = 2;
                    if (generalDoC.Equals("dry_cargo_in_bulk", StringComparison.OrdinalIgnoreCase)) sec.GeneralDescriptionOfCargo = 3;
                    if (generalDoC.Equals("liquid_cargo_in_bulk", StringComparison.OrdinalIgnoreCase)) sec.GeneralDescriptionOfCargo = 4;
                    if (generalDoC.Equals("empty", StringComparison.OrdinalIgnoreCase)) sec.GeneralDescriptionOfCargo = 5;
                }

                for (int i = 1; i <= 10; i++)
                {
                    if (!(sec.GetPortFacilityWithIdentifier(i.ToString()) is LastTenPortFacilitiesCalled l10fc))
                    {
                        l10fc = new LastTenPortFacilitiesCalled();
                        l10fc.Identifier = i.ToString();
                        l10fc.SEC = sec;
                        sec.LastTenPortFacilitesCalled.Add(l10fc);
                    }

                    l10fc.PortFacilityPortName = reader.ReadCellAsText("security", String.Format("B{0}", i + 30));
                    l10fc.PortFacilityPortCountry = reader.ReadCellAsText("security", String.Format("C{0}", i + 30));
                    l10fc.PortFacilityPortLoCode = reader.ReadCellAsText("security", String.Format("D{0}", i + 30));
                    l10fc.PortFacilityDateOfArrival = reader.ReadCellAsDateTime("security", String.Format("E{0}", i + 30));
                    l10fc.PortFacilityDateOfDeparture = reader.ReadCellAsDateTime("security", String.Format("F{0}", i + 30));
                    l10fc.PortFacilityShipSecurityLevel = (byte?) reader.ReadCellAsDecimal("security", String.Format("G{0}", i + 30));
                    l10fc.PortFacilitySecurityMattersToReport = reader.ReadCellAsText("security", String.Format("H{0}", i + 30));
                    l10fc.PortFacilityGISISCode = reader.ReadCellAsText("security", String.Format("I{0}", i + 30));
                    l10fc.PortFacilityGISISCodeLocode = reader.ReadCellAsText("security", String.Format("J{0}", i + 30));

                    // keinen "leeren" Hafen anlegen, wenn der Eintrag leer war (trifft anscheinend bei Neubauten zu, siehe E-Mail Christin vom 20./22.6.17
                    if (l10fc.PortFacilityPortName.IsNullOrEmpty() && l10fc.PortFacilityPortLoCode.IsNullOrEmpty() && l10fc.PortFacilityPortCountry.IsNullOrEmpty())
                        sec.LastTenPortFacilitesCalled.Remove(l10fc);
                }

                for (int i = 1; i <= 10; i++)
                {
                    if (!(sec.GetShipToShipWithIdentifier(i.ToString()) is ShipToShipActivitiesDuringLastTenPortFacilitiesCalled s2sActivity))
                    {
                        s2sActivity = new ShipToShipActivitiesDuringLastTenPortFacilitiesCalled();
                        s2sActivity.Identifier = i.ToString();
                        s2sActivity.SEC = sec;
                        sec.ShipToShipActivitiesDuringLastTenPortFacilitiesCalled.Add(s2sActivity);
                    }

                    s2sActivity.ShipToShipActivityLocationName = reader.ReadCellAsText("security", string.Format("B{0}", i + 45));
                    s2sActivity.ShipToShipActivityLocationLoCode = reader.ReadCellAsText("security", string.Format("C{0}", i + 45));
                    s2sActivity.ShipToShipActivityLocationCoordinatesLatitude = (int?) reader.ReadCellAsDecimal("security", string.Format("D{0}", i + 45));
                    s2sActivity.ShipToShipActivityLocationCoordinatesLongitude = (int?) reader.ReadCellAsDecimal("security", string.Format("E{0}", i + 45));
                    s2sActivity.ShipToShipActivityDateFrom = reader.ReadCellAsDateTime("security", string.Format("F{0}", i + 45));
                    s2sActivity.ShipToShipActivityDateTo = reader.ReadCellAsDateTime("security", string.Format("G{0}", i + 45));
                    s2sActivity.ShipToShipActivityTypeCode = (int?) reader.ReadCellAsDecimal("security", string.Format("H{0}", i + 45));
                    s2sActivity.ShipToShipActivitySecurityMattersToReport = reader.ReadCellAsText("security", string.Format("I{0}", i + 45));

                    if (s2sActivity.ShipToShipActivityLocationName.IsNullOrEmpty() && s2sActivity.ShipToShipActivityLocationLoCode.IsNullOrEmpty() &&
                        !(s2sActivity.ShipToShipActivityLocationCoordinatesLatitude.HasValue && s2sActivity.ShipToShipActivityLocationCoordinatesLongitude.HasValue))
                        sec.ShipToShipActivitiesDuringLastTenPortFacilitiesCalled.Remove(s2sActivity);
                }

            }

            return true;
        }

        private static bool ScanPRE72H(Message message, ExcelReader reader)
        {
            throw new NotImplementedException();
        }

        private static bool ScanPOBD(Message pobdMessage, ExcelReader reader)
        {
            if (pobdMessage.Elements.Count == 0)
            {
                POBD newPOBD = new POBD();
                newPOBD.MessageHeader = pobdMessage;
                pobdMessage.Elements.Add(newPOBD);
            }

            POBD pobd = pobdMessage.Elements[0] as POBD;
            pobd.TotalPersonsOnBoardUponDeparture = (int?)reader.ReadCellAsDecimal("traffic message on departure", "C8");
            pobd.TotalCrewMembersOnBoardUponDeparture = (int?)reader.ReadCellAsDecimal("traffic message on departure", "C9");
            pobd.TotalPassengersOnBoardUponDeparture = (int?)reader.ReadCellAsDecimal("traffic message on departure", "C10");
            pobd.TotalStowawaysOnBoardUponDeparture = (int?)reader.ReadCellAsDecimal("traffic message on departure", "C11");

            return true;
        }

        private static bool ScanPOBA(Message pobaMessage, ExcelReader reader)
        {
            if (pobaMessage.Elements.Count == 0)
            {
                POBA newPOBA = new POBA();
                newPOBA.MessageHeader = pobaMessage;
                pobaMessage.Elements.Add(newPOBA);
            }

            POBA poba = pobaMessage.Elements[0] as POBA;
            poba.TotalPersonsOnBoardUponArrival = (int?) reader.ReadCellAsDecimal("traffic message on arrival", "C8");
            poba.TotalCrewMembersOnBoardUponArrival = (int?) reader.ReadCellAsDecimal("traffic message on arrival", "C9");
            poba.TotalPassengersOnBoardUponArrival = (int?) reader.ReadCellAsDecimal("traffic message on arrival", "C10");
            poba.TotalStowawaysOnBoardUponArrival = (int?) reader.ReadCellAsDecimal("traffic message on arrival", "C11");

            return true;
        }

        private static bool ScanPASD(Message message, ExcelReader reader)
        {
            throw new NotImplementedException();
        }

        private static bool ScanPAS(Message message, ExcelReader reader)
        {
            throw new NotImplementedException();
        }

        private static bool ScanNOA_NOD(Message noa_nodMessage, ExcelReader reader)
        {
            if (noa_nodMessage.Elements.Count == 0)
            {
                NOA_NOD newNAME = new NOA_NOD();
                newNAME.MessageHeader = noa_nodMessage;
                noa_nodMessage.Elements.Add(newNAME);
            }

            NOA_NOD noa_nod = noa_nodMessage.Elements[0] as NOA_NOD;
            noa_nod.ETAToPortOfCall = reader.ReadCellAsDateTime("port message", "C26");
            noa_nod.ETDFromPortOfCall = reader.ReadCellAsDateTime("port message", "C27");
            // read call purposes
            for (int i = 0; i < 9; i++)
            {
                int? callPurposeCode = (int?) reader.ReadCellAsDecimal("port message", string.Format("B{0}", 29 + i));
                string callPurposeDescription = reader.ReadCellAsText("port message", string.Format("C{0}", 29 + i));

                if (callPurposeCode.HasValue)
                {
                    if (!(noa_nod.GetSublistElementWithIdentifier(i.ToString()) is CallPurpose callPurpose))
                    {
                        callPurpose = new CallPurpose();
                        callPurpose.NOA_NOD = noa_nod;
                        callPurpose.Identifier = i.ToString();
                        noa_nod.CallPurposes.Add(callPurpose);
                    }
                    callPurpose.CallPurposeCode = callPurposeCode.Value;
                    callPurpose.CallPurposeDescription = callPurposeDescription;
                }
            }
            noa_nod.ETAToKielCanal = reader.ReadCellAsDateTime("port message", "C39");
            noa_nod.ETDFromKielCanal = reader.ReadCellAsDateTime("port message", "C40");

            noa_nod.LastPort = reader.ReadCellAsText("port message", "C42");
            noa_nod.ETDFromLastPort = reader.ReadCellAsDateTime("port message", "C43");
            noa_nod.NextPort = reader.ReadCellAsText("port message", "C44");
            noa_nod.ETAToNextPort = reader.ReadCellAsDateTime("port message", "C45");

            return true;
        }

        #region NAME

        private static bool ScanNAME(Message nameMessage, ExcelReader reader)
        {
            if (nameMessage.Elements.Count == 0)
            {
                NAME newNAME = new NAME();
                newNAME.MessageHeader = nameMessage;
                nameMessage.Elements.Add(newNAME);
            }
            NAME name = nameMessage.Elements[0] as NAME;
            name.NameOfMaster = reader.ReadCellAsText("port message", "C11");
            if (name.NameOfMaster.IsNullOrEmpty() && name.IsNew)
                return false;
            return true;
        }

        #endregion

        #region MDH

        private static bool ScanMDH(Message mdhMessage, ExcelReader reader)
        {
            if (mdhMessage.Elements.Count == 0)
            {
                MDH newMDH = new MDH();
                newMDH.MessageHeader = mdhMessage;
                mdhMessage.Elements.Add(newMDH);
            }
            MDH mdh = mdhMessage.Elements[0] as MDH;
            mdh.MDHSimplification = reader.ReadCellAsBool("health", "D8");
            if(mdh.MDHSimplification ?? false)
            {
                mdh.PortOfCallWhereCompleteMDHNotified = reader.ReadCellAsText("health", "D9");
            }
            else
            {

                // general fields

                mdh.NonAccidentalDeathsDuringVoyage = reader.ReadCellAsBool("health", "D11");
                if (mdh.NonAccidentalDeathsDuringVoyage ?? false)
                    mdh.NonAccidentalDeathsDuringVoyageCount = (int?)reader.ReadCellAsDecimal("health", "D12");
                mdh.SuspisionInfectiousNature = reader.ReadCellAsBool("health", "D13");
                mdh.NumberOfIllPersonsHigherThanExpected = reader.ReadCellAsBool("health", "D14");
                if (mdh.NumberOfIllPersonsHigherThanExpected ?? false)
                    mdh.NumberOfIllPersons = (int?)reader.ReadCellAsDecimal("health", "D15");
                mdh.SickPersonsOnBoard = reader.ReadCellAsBool("health", "D16");
                mdh.MedicalConsulted = reader.ReadCellAsBool("health", "D17");
                mdh.AwareOfFurtherInfections = reader.ReadCellAsBool("health", "D18");
                mdh.SickAnimalOrPetOnBoard = reader.ReadCellAsBool("health", "D20");
                mdh.ValidSanitaryControlExemptionOrCertificateOnBoard = reader.ReadCellAsBool("health", "D22");
                if(mdh.ValidSanitaryControlExemptionOrCertificateOnBoard ?? false)
                {
                    mdh.PlaceOfIssue = reader.ReadCellAsText("health", "D23");
                    mdh.DateOfIssue = reader.ReadCellAsDateTime("health", "D24");
                }
                mdh.SanitaryControlReinspectionRequired = reader.ReadCellAsBool("health", "D25");

                // sanitary measures
                mdh.SanitaryMeasuresApplied = reader.ReadCellAsBool("health", "J8");
                if (mdh.SanitaryMeasuresApplied ?? false)
                {
                    for (int i = 1; i <= 10; i++)
                    {
                        if (!(mdh.GetSanitaryMeasuresDetailWithIdentifier(i.ToString()) is SanitaryMeasuresDetail snd))
                        {
                            snd = new SanitaryMeasuresDetail();
                            snd.Identifier = i.ToString();
                            snd.MDH = mdh;
                            mdh.SanitaryMeasuresDetails.Add(snd);
                        }
                        snd.SanitaryMeasuresType = reader.ReadCellAsText("health", string.Format("H{0}", i + 9));
                        if (snd.SanitaryMeasuresType.IsNullOrEmpty())
                        {
                            mdh.SanitaryMeasuresDetails.Remove(snd);
                            continue;
                        }
                        snd.SanitaryMeasuresLocation = reader.ReadCellAsText("health", string.Format("I{0}", i + 9));
                        snd.SanitaryMeasuresDate = reader.ReadCellAsDateTime("health", string.Format("J{0}", i + 9));                        
                    }
                }

                // stowaways
                mdh.StowawaysDetected = reader.ReadCellAsBool("health", "I22");
                if (mdh.StowawaysDetected ?? false)
                {
                    for (int i = 1; i <= 10; i++)
                    {
                        string stowawayLocation = reader.ReadCellAsText("health", string.Format("H{0}", i + 23));
                        if(!stowawayLocation.IsNullOrEmpty())
                        {
                            if(!(mdh.GetStowawaysJoiningLocationWithIdentifier(i.ToString()) is StowawaysJoiningLocation sjl))
                            {
                                sjl = new StowawaysJoiningLocation();
                                sjl.Identifier = i.ToString();
                                sjl.MDH = mdh;
                                mdh.StowawaysJoiningLocations.Add(sjl);
                            }
                            sjl.StowawayJoiningLocation = stowawayLocation;
                        }
                    }
                }

                // infected area
                mdh.InfectedAreaVisited = reader.ReadCellAsBool("health", "L22");
                if (mdh.InfectedAreaVisited ?? false)
                {
                    for (int i = 1; i <= 10; i++)
                    {
                        string iaPort = reader.ReadCellAsText("health", string.Format("K{0}", i + 23));
                        if(!iaPort.IsNullOrEmpty())
                        {
                            if(!(mdh.GetInfectedAreaWithIdentifier(i.ToString()) is InfectedArea ia))
                            {
                                ia = new InfectedArea();
                                ia.Identifier = i.ToString();
                                ia.MDH = mdh;
                                mdh.InfectedAreas.Add(ia);
                            }
                            ia.InfectedAreaPort = iaPort;
                            ia.InfectedAreaDate = reader.ReadCellAsDateTime("health", string.Format("L{0}", i + 23));
                        }
                    }
                }



                // PoC last 30 days
                // this crazy logic is necessary to interpret the double tables in the dakosy sheet

                // collect all crew members
                Dictionary<string, List<string>> crewmembers = new Dictionary<string, List<string>>();
                for (int i = 1; i <= 1000; i++)
                {
                    string posRef = reader.ReadCellAsText("health", string.Format("G{0}", i + 45));
                    if(posRef.IsNullOrEmpty())
                        posRef = reader.ReadCellAsText("health", string.Format("H{0}", i + 45));
                    if (posRef.IsNullOrEmpty()) break; // we are done with this loop
                    string crewMember = reader.ReadCellAsText("health", string.Format("I{0}", i + 45));
                    if (!crewMember.IsNullOrEmpty())
                    {
                        if(!crewmembers.ContainsKey(posRef))
                            crewmembers.Add(posRef, new List<string>());
                        crewmembers[posRef].Add(crewMember);
                    }
                }

                for (int i = 1; i <= 1000; i++)
                {
                    string posRef = reader.ReadCellAsText("health", string.Format("B{0}", i + 45));
                    string locode = reader.ReadCellAsText("health", string.Format("C{0}", i + 45));
                    if (locode.IsNullOrEmpty()) break;
                    if (!(mdh.GetSublistElementWithIdentifier((i + 1).ToString()) is PortOfCallLast30Days poc30d))
                    {
                        poc30d = new PortOfCallLast30Days();
                        poc30d.Identifier = (i + 1).ToString();
                        poc30d.MDH = mdh;
                        mdh.PortOfCallLast30Days.Add(poc30d);
                    }
                    poc30d.PortOfCallLast30DaysLocode = locode;
                    poc30d.PortOfCallLast30DaysDateOfDeparture = reader.ReadCellAsDateTime("health", string.Format("D{0}", i + 45));
                    poc30d.PortOfCallLast30DaysCrewMembersJoined = reader.ReadCellAsBool("health", string.Format("E{0}", i + 45));
                    poc30d.CrewJoinedShip.Clear();
                    List<string> crewJoined = new List<string>();
                    if (crewmembers.ContainsKey(posRef)) {
                        crewJoined = crewmembers[posRef];
                    }
                    else if (crewmembers.ContainsKey(locode))
                    {
                        crewJoined = crewmembers[locode];
                    }
                    for(int j = 0; j < crewJoined.Count; j++)
                    {
                        PortOfCallLast30DaysCrewJoinedShip p = new PortOfCallLast30DaysCrewJoinedShip();
                        p.PortOfCallLast30Days = poc30d;
                        p.Identifier = (j + 1).ToString();
                        poc30d.CrewJoinedShip.Add(p);
                        p.PortOfCallLast30DaysCrewJoinedShipName = crewJoined[j];
                    }
                }
            }
            
            return true;
        }

        #endregion

        #region LADG

        private static bool ScanLADG(Message ladgMessage, ExcelReader reader)
        {
            bool result = false;

            for (int i = 0; i < 10000; i++)
            {
                string operation = reader.ReadCellAsText("cargo", string.Format("B{0}", i + 9));
                byte? ladgOperation = null;
                if (operation.Equals("LOAD", StringComparison.OrdinalIgnoreCase)) ladgOperation = 0;
                if (operation.Equals("DISCHARGE", StringComparison.OrdinalIgnoreCase)) ladgOperation = 1;
                if (operation.Equals("TRANSIT", StringComparison.OrdinalIgnoreCase)) ladgOperation = 2;
                if (!ladgOperation.HasValue) break;

                if (!(ladgMessage.GetSublistElementWithIdentifier((i + 1).ToString()) is LADG ladg))
                {
                    ladg = new LADG();
                    ladg.MessageHeader = ladgMessage;
                    ladg.Identifier = (i + 1).ToString();
                    ladgMessage.Elements.Add(ladg);
                }
                ladg.CargoHandlingType = ladgOperation;
                ladg.CargoLACode = (int?) reader.ReadCellAsDecimal("cargo", string.Format("C{0}", i + 9));
                ladg.CargoCodeNST = reader.ReadCellAsText("cargo", string.Format("D{0}", i + 9))?.Substring(0, 2);
                ladg.CargoCodeNST_3 = reader.ReadCellAsText("cargo", string.Format("E{0}", i + 9));
                ladg.CargoNumberOfItems = (int?)reader.ReadCellAsDecimal("cargo", string.Format("F{0}", i + 9));
                ladg.CargoGrossQuantity_TNE = reader.ReadCellAsDecimal("cargo", string.Format("G{0}", i + 9));
                ladg.PortOfLoading = reader.ReadCellAsText("cargo", string.Format("H{0}", i + 9));
                ladg.PortOfDischarge = reader.ReadCellAsText("cargo", string.Format("I{0}", i + 9));

                result = true;
            }

            return result;
        }

        #endregion

        #region INFO

        private static bool ScanINFO(Message infoMessage, ExcelReader reader)
        {
            if (infoMessage.Elements.Count == 0)
            {
                INFO newINFO = new INFO();
                newINFO.MessageHeader = infoMessage;
                infoMessage.Elements.Add(newINFO);
            }

            INFO info = infoMessage.Elements[0] as INFO;
            string shippingArea = reader.ReadCellAsText("port message", "C14");
            if (shippingArea.Equals("NORTH_BALTIC_SEA", StringComparison.OrdinalIgnoreCase)) info.ShippingArea = 0;
            if (shippingArea.Equals("EUROPE", StringComparison.OrdinalIgnoreCase)) info.ShippingArea = 1;
            if (shippingArea.Equals("OVERSEAS", StringComparison.OrdinalIgnoreCase)) info.ShippingArea = 2;
            info.RequestedPositionInPortOfCall = reader.ReadCellAsText("port message", "C15");
            info.SpecialRequirementsOfShipAtBerth = reader.ReadCellAsText("port message", "C16");
            info.ConstructionCharacteristicsOfShip = reader.ReadCellAsText("port message", "C17");
            info.BowThrusterPower = reader.ReadCellAsText("port message", "C18");
            info.SternThrusterPower = reader.ReadCellAsText("port message", "C19");
            info.FumigatedBulkCargoBool = reader.ReadCellAsBool("port message", "C20");
            info.DeplacementSummerDraught_TNE = reader.ReadCellAsDecimal("port message", "C21");
            string portArea = reader.ReadCellAsText("port message", "C22")?.Trim().ToUpper();
            if (!portArea.IsNullOrEmpty() && DBManager.Instance.GetPortAreaDict().ContainsKey(portArea))
                info.PortArea = portArea;
            else
                info.PortArea = "";            

            return true;
        }

        #endregion

        private static bool ScanHAZD(Message message, ExcelReader reader)
        {
            throw new NotImplementedException();
        }

        private static bool ScanHAZA(Message message, ExcelReader reader)
        {
            throw new NotImplementedException();
        }

        private static bool ScanCREWD(Message message, ExcelReader reader)
        {
            throw new NotImplementedException();
        }

        private static bool ScanCREW(Message message, ExcelReader reader)
        {
            throw new NotImplementedException();
        }

        private static bool ScanBPOL(Message message, List<Message> messages, MessageCore messageCore, ExcelReader reader)
        {
            throw new NotImplementedException();
        }

        private static bool ScanBKRD(Message brkdMessage, ExcelReader reader)
        {
            bool result = false;

            for (int i = 0; i < 10000; i++)
            {
                string fuelType = reader.ReadCellAsText("traffic message on departure", string.Format("B{0}", i + 28));
                double? quantity = reader.ReadCellAsDecimal("traffic message on departure", string.Format("C{0}", i + 28));
                if (fuelType.IsNullOrEmpty()) break;

                if (!(brkdMessage.GetSublistElementWithIdentifier((i + 1).ToString()) is BRKD brkd))
                {
                    brkd = new BRKD();
                    brkd.MessageHeader = brkdMessage;
                    brkd.Identifier = (i + 1).ToString();
                    brkdMessage.Elements.Add(brkd);
                }
                brkd.BunkerFuelType = fuelType;
                brkd.BunkerFuelQuantity_TNE = quantity;

                result = true;
            }

            return result;
        }

        private static bool ScanBKRA(Message bkraMessage, ExcelReader reader)
        {
            bool result = false;

            for (int i = 0; i < 10000; i++)
            {
                string fuelType = reader.ReadCellAsText("traffic message on arrival", string.Format("B{0}", i + 28));
                double? quantity = reader.ReadCellAsDecimal("traffic message on arrival", string.Format("C{0}", i + 28));                
                if (fuelType.IsNullOrEmpty()) break;

                if (!(bkraMessage.GetSublistElementWithIdentifier((i + 1).ToString()) is BRKA brka))
                {
                    brka = new BRKA();
                    brka.MessageHeader = bkraMessage;
                    brka.Identifier = (i + 1).ToString();
                    bkraMessage.Elements.Add(brka);
                }
                brka.BunkerFuelType = fuelType;
                brka.BunkerFuelQuantity_TNE = quantity;
                
                result = true;
            }

            return result;
        }

        private static bool ScanATD(Message atdMessage, ExcelReader reader)
        {
            if (atdMessage.Elements.Count == 0)
            {
                ATD newATD = new ATD();
                newATD.MessageHeader = atdMessage;
                atdMessage.Elements.Add(newATD);
            }
            ATD atd = atdMessage.Elements[0] as ATD;
            atd.ATDPortOfCall = reader.ReadCellAsDateTime("traffic message on departure", "C20");
            return atd.ATDPortOfCall.HasValue;
        }

        private static bool ScanATA(Message ataMessage, ExcelReader reader)
        {
            if (ataMessage.Elements.Count == 0)
            {
                ATA newATA = new ATA();
                newATA.MessageHeader = ataMessage;
                ataMessage.Elements.Add(newATA);
            }
            ATA ata = ataMessage.Elements[0] as ATA;
            ata.ATAPortOfCall = reader.ReadCellAsDateTime("traffic message on arrival", "C20");
            return ata.ATAPortOfCall.HasValue;
        }

        #region AGNT

        private static bool ScanAGNT(Message agntMessage, ExcelReader reader)
        {
            if (agntMessage.Elements.Count == 0)
            {
                AGNT newAgnt = new AGNT();
                newAgnt.MessageHeader = agntMessage;
                agntMessage.Elements.Add(newAgnt);
            }

            AGNT agnt = agntMessage.Elements[0] as AGNT;
            agnt.AgentCompanyName = reader.ReadCellAsText("main", "C32");
            agnt.AgentCity = reader.ReadCellAsText("main", "C36");
            agnt.AgentCountry = reader.ReadCellAsText("main", "C37");
            agnt.AgentEMail = reader.ReadCellAsText("main", "C42");
            agnt.AgentFax = reader.ReadCellAsText("main", "C41");
            agnt.AgentFirstName = reader.ReadCellAsText("main", "C39");
            agnt.AgentLastName = reader.ReadCellAsText("main", "C38");
            agnt.AgentPhone = reader.ReadCellAsText("main", "C40");
            agnt.AgentPostalCode = reader.ReadCellAsText("main", "C35");
            string street = reader.ReadCellAsText("main", "C33") ?? "";
            string number = reader.ReadCellAsText("main", "C34") ?? "";
            agnt.AgentStreetAndNumber = string.Format("{0} {1}", street, number);

            if (agnt.AgentLastName.IsNullOrEmpty()) agnt.AgentLastName = "-";

            // wird nicht mehr entfernt, egal welche Felder gelesen werden
            return true;
        }

        #endregion

    }
}