// Copyright (c) 2015-2017 schick Informatik
// Description: Kopfdaten eines Excel-Einlesevorgangs

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;

namespace bsmd.database
{
    public class ImportHeader : DatabaseEntity
    {

        public ImportHeader()
        {
            this.tablename = "[dbo].[ImportHeader]";
        }

        #region Properties

        public Guid? ReportingPartyId { get; set; }

        public string SenderEmail { get; set; }

        public DateTime ImportDate { get; set; }

        public string Filename { get; set; }

        public Guid MessageCoreId { get; set; }

        #endregion

        #region DatabaseEntity implementation

        public override List<DatabaseEntity> LoadList(IDataReader reader)
        {
            List<DatabaseEntity> result = new List<DatabaseEntity>();
            while (reader.Read())
            {
                ImportHeader ih = new ImportHeader();

                ih.id = reader.GetGuid(0);
                if (!reader.IsDBNull(1)) ih.ReportingPartyId = reader.GetGuid(1);
                if (!reader.IsDBNull(2)) ih.SenderEmail = reader.GetString(2);
                if (!reader.IsDBNull(3)) ih.ImportDate = reader.GetDateTime(3);
                if (!reader.IsDBNull(4)) ih.Filename = reader.GetString(4);
                if (!reader.IsDBNull(5)) ih.MessageCoreId = reader.GetGuid(5);                

                result.Add(ih);
            }
            reader.Close();
            return result;
        }

        public override void PrepareLoadCommand(IDbCommand cmd, Message.LoadFilter filter, params object[] criteria)
        {
            string query = string.Format("SELECT Id, ReportingPartyId, SenderEMail, ImportDate, Filename, MessageCoreId FROM {0} ", this.Tablename);

            switch (filter)
            {
                case Message.LoadFilter.BY_CORE:
                    query += " WHERE MessageCoreId = @MCID";
                    ((SqlCommand)cmd).Parameters.AddWithValue("@MCID", criteria[0]);
                    break;
                default:
                    break;
            }

            query += " ORDER BY ImportDate DESC";

            cmd.CommandText = query;
        }

        public override void PrepareSave(IDbCommand cmd)
        {
            SqlCommand scmd = cmd as SqlCommand;

            scmd.Parameters.AddWithNullableValue("@RPID", this.ReportingPartyId);
            scmd.Parameters.AddWithNullableValue("@SENDER", this.SenderEmail);
            scmd.Parameters.AddWithNullableValue("@IMPORTDATE", this.ImportDate);
            scmd.Parameters.AddWithNullableValue("@FILENAME", this.Filename);
            scmd.Parameters.AddWithNullableValue("@MESSAGECOREID", this.MessageCoreId);            

            if (this.IsNew)
            {
                this.CreateId();
                scmd.Parameters.AddWithValue("@ID", this.Id);
                scmd.CommandText = string.Format("INSERT INTO {0} (Id, ReportingPartyId, SenderEMail, ImportDate, Filename, MessageCoreId) " +
                    "VALUES (@ID, @RPID, @SENDER, @IMPORTDATE, @FILENAME, @MESSAGECOREID)", this.Tablename);                
            }
            else
            {
                scmd.Parameters.AddWithValue("@ID", this.Id);
                scmd.CommandText = string.Format("UPDATE {0} SET ReportingPartyId = @RPID, SenderEMail = @SENDER, ImportDate = @IMPORTDATE, " +
                    "Filename = @FILENAME, MessageCoreId = @MESSAGECOREID WHERE Id = @ID", this.Tablename);
            }
        }

        #endregion

        #region public methods

        /// <summary>
        /// Diese Methode erzeugt ImportValue Entitäten  aus den eingelesenen Excel-Werten. Dabei werden nur
        /// Deltas gespeichert, d.h. alle Änderungen bezogen
        /// </summary>
        /// <param name="importValues"></param>
        /// <returns></returns>
        public List<ImportValue> CreateUpdateList(Dictionary<string, string> importValues)
        {
            List<ImportHeader> existingListHeaders = DBManager.Instance.GetImportHeader(this.MessageCoreId);
            List<ImportValue> result = new List<ImportValue>();

            // in diesem Dict wird der "neueste" eingelesene Stand aufbereitet, der dann direkt mit den neu
            // eingelesenen Werten verglichen werden kann. Dazu müssen alle Values der Anmeldung gelesen werden und 
            // von hinten nach vorne überschrieben werden.
            Dictionary<string, string> comparisonDict = new Dictionary<string, string>();

            // existingListHeaders sind von neu..alt sortiert, man muss also von hinten lesen
            for(int i = (existingListHeaders.Count - 1); i >= 0; i--)
            {
                List<ImportValue> values = DBManager.Instance.GetValuesForImportHeader(existingListHeaders[i]);
                foreach(ImportValue anImportValue in values)
                {
                    comparisonDict[anImportValue.Name] = anImportValue.Value;
                }
            }

            // jetzt alle Einträge suchen, die es noch nicht gibt oder geändert sind und dafür ImportValue Entitäten anlegen
            
            foreach(string key in importValues.Keys)
            {
                if(comparisonDict.ContainsKey(key))
                {
                    if (comparisonDict[key].Equals(importValues[key])) continue;
                }

                // Wert ist anders oder nicht vorhanden
                ImportValue iv = new ImportValue();
                iv.Value = importValues[key];

                iv.Name = key;
                string[] elems = key.Split('.');
                Message.NotificationClass aNotificationClass = Message.NotificationClass.VISIT;
                if (Enum.TryParse<Message.NotificationClass>(elems[0], out aNotificationClass))
                    iv.NotificationClass = aNotificationClass;
                iv.ImportHeaderId = this.Id.Value;

                result.Add(iv);
            }

            return result;
        }

        #endregion

    }
}