// Copyright (c) 2020-present schick Informatik
// Description: New class for NSW 7.0 Waste "Empfangsbestätigung"

using System;
using System.Text;
using System.Data.SqlClient;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using Newtonsoft.Json;
using System.Data;

namespace bsmd.database
{

    [TypeConverter(typeof(MessageClassConverter<WAS_RCPT>))]
    [JsonConverter(typeof(NoTypeConverterJsonConverter<WAS_RCPT>))]
    public class WAS_RCPT : DatabaseEntity, ISublistContainer, ISublistElement
    {
        public WAS_RCPT()
        {
            this.tablename = "[dbo].[WAS_RCPT]";
        }

        #region Properties

        [MaxLength(20)]
        public string IdentificationNumber { get; set; }

        [MaxLength(70)]
        public string PortReceptionFacilityName { get; set; }

        [MaxLength(70)]
        public string PortReceptionFacilityProviderName { get; set; }

        public ObservableCollection<WasteReceived> WasteReceived { get; private set; } = new ObservableCollection<WasteReceived>();

        [Validation(ValidationCode.NOT_NULL)]
        public DateTime? WasteDeliveryDateFrom { get; set; }

        [Validation(ValidationCode.NOT_NULL)]
        public DateTime? WasteDeliveryDateTo { get; set; }

        [Browsable(false)]
        public ObservableCollection<TreatmentFacilityProvider> TreatmentFacilityProvider { get; private set; } = new ObservableCollection<TreatmentFacilityProvider>();

        [ENI2Validation]
        public string TreatmentFacilityProviderText
        {
            get
            {
                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < this.TreatmentFacilityProvider.Count; i++)
                {
                    if (i > 0)
                        sb.Append(", ");
                    sb.Append(((TreatmentFacilityProvider)this.TreatmentFacilityProvider[i]).TreatmentFacilityProviderName);
                }
                return sb.ToString();
            }
            set
            {
                if (value.IsNullOrEmpty())
                {
                    foreach (TreatmentFacilityProvider wdsp in this.TreatmentFacilityProvider)
                        DBManager.Instance.Delete(wdsp);
                    this.TreatmentFacilityProvider.Clear();
                }
                else
                {
                    string[] tProviders = value.Split(',');
                    List<TreatmentFacilityProvider> foundList = new List<TreatmentFacilityProvider>();

                    for (int i = 0; i < tProviders.Length; i++)
                    {
                        string tProvider = tProviders[i].Trim();
                        if (tProvider.Length > 0)
                        {
                            TreatmentFacilityProvider matchingProvider = null;
                            foreach (TreatmentFacilityProvider wdsp in this.TreatmentFacilityProvider)
                            {
                                if (wdsp.TreatmentFacilityProviderName.Equals(tProvider, StringComparison.OrdinalIgnoreCase))
                                {
                                    matchingProvider = wdsp;
                                    break;
                                }
                            }
                            if (matchingProvider != null)
                            {
                                foundList.Add(matchingProvider);
                                this.TreatmentFacilityProvider.Remove(matchingProvider);
                            }
                            else
                            {
                                TreatmentFacilityProvider newProvider = new TreatmentFacilityProvider();
                                newProvider.WAS_RCPT = this;
                                newProvider.TreatmentFacilityProviderName = tProvider;
                                foundList.Add(newProvider);
                            }
                        }
                    }

                    // remove remaining provider (no longer valid)
                    foreach (TreatmentFacilityProvider remainingProvider in this.TreatmentFacilityProvider)
                        DBManager.Instance.Delete(remainingProvider);
                    this.TreatmentFacilityProvider.Clear();
                    // add existing and new provider
                    foreach (TreatmentFacilityProvider sjl in foundList)
                        this.TreatmentFacilityProvider.Add(sjl);
                }
            }
        }

        #endregion

        #region public methods

        public void AddMissingWasteReceived()
        {
            foreach (string wasteCode in WAS.WasteCodes)
            {
                WasteReceived foundWasteReceived = null;

                foreach (WasteReceived wasteReceived in this.WasteReceived)
                {
                    if (!wasteReceived.WasteCode.IsNullOrEmpty() && wasteReceived.WasteCode.Equals(wasteCode))
                    {
                        foundWasteReceived = wasteReceived;
                        break;
                    }
                }

                if (foundWasteReceived == null)
                {
                    foundWasteReceived = new WasteReceived
                    {
                        Identifier = DatabaseEntity.GetNewIdentifier(this.WasteReceived),
                        WAS_RCPT = this,
                        AmountWasteReceived_MTQ = 0,
                        WasteCode = wasteCode
                    };
                    this.WasteReceived.Add(foundWasteReceived);
                }

                if (foundWasteReceived.WasteDescription.IsNullOrEmpty())
                {
                    switch (wasteCode)
                    {
                        case "999":
                        case "201":
                        case "202":
                        case "203":
                        case "204":
                        case "510":
                        case "511":
                            foundWasteReceived.WasteDescription = "-";
                            break;
                        default:
                            foundWasteReceived.WasteDescription = "";
                            break;
                    }
                }                  
            }
        }

        #endregion

        #region ISublistContainer implementation

        public ISublistElement GetSublistElementWithIdentifier(string identifier)
        {
            foreach (WasteReceived wasteReceived in this.WasteReceived)
            {
                if (wasteReceived.Identifier.Equals(identifier))
                    return wasteReceived;
            }
            return null;
        }

        [Browsable(false)]
        [JsonIgnore]
        public int NumberOfExcelRows
        {
            get { return 25; }
        }

        public void SaveElements()
        {
            foreach (WasteReceived wasteReceived in this.WasteReceived)
            {
                DBManager.Instance.Save(wasteReceived);
            }

            foreach(TreatmentFacilityProvider tfp in this.TreatmentFacilityProvider)
            {
                DBManager.Instance.Save(tfp);
            }
        }

        public void DeleteElements()
        {
            foreach (WasteReceived wasteReceived in this.WasteReceived)
            {
                DBManager.Instance.Delete(wasteReceived);
            }
            this.WasteReceived.Clear();

            foreach(TreatmentFacilityProvider tfp in this.TreatmentFacilityProvider)
            {
                DBManager.Instance.Delete(tfp);
            }
            this.TreatmentFacilityProvider.Clear();
        }

        #endregion

        #region ISublistElement implementation

        public string Identifier { get; set; }

        public string SublistCollectionKey { get { return "was_rcpt"; } }

        #endregion

        #region DatabaseEntity implementation

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

            scmd.Parameters.AddWithValue("@P1", this.MessageHeader.Id);
            scmd.Parameters.AddWithNullableValue("@P2", this.IdentificationNumber);
            scmd.Parameters.AddWithNullableValue("@P3", this.PortReceptionFacilityName);
            scmd.Parameters.AddWithNullableValue("@P4", this.PortReceptionFacilityProviderName);
            scmd.Parameters.AddWithNullableValue("@P5", this.WasteDeliveryDateFrom);
            scmd.Parameters.AddWithNullableValue("@P6", this.WasteDeliveryDateTo);
            scmd.Parameters.AddWithNullableValue("@P7", this.Identifier);

            if (this.IsNew)
            {
                this.CreateId();
                scmd.Parameters.AddWithValue("@ID", this.Id);
                scmd.CommandText = string.Format("INSERT INTO {0} (Id, MessageHeaderId, IdentificationNumber, " +
                    "PortReceptionFacilityName, PortReceptionFacilityProviderName, WasteDeliveryDateFrom, WasteDeliveryDateTo, Identifier) " +
                    "VALUES ( @ID, @P1, @P2, @P3, @P4, @P5, @P6, @P7 )", this.Tablename);
            }
            else
            {
                scmd.Parameters.AddWithValue("ID", this.Id);
                scmd.CommandText = string.Format("UPDATE {0} SET IdentificationNumber = @P2, PortReceptionFacilityName = @P3, " +
                    "PortReceptionFacilityProviderName = @P4, WasteDeliveryDateFrom = @P5, WasteDeliveryDateTo = @P6, Identifier = @P7 " +
                    "WHERE Id = @ID", this.Tablename);
            }
        }

        public override void PrepareLoadCommand(IDbCommand cmd, Message.LoadFilter filter, params object[] criteria)
        {
            string query = string.Format("SELECT Id, IdentificationNumber, PortReceptionFacilityName, PortReceptionFacilityProviderName, " +
                "WasteDeliveryDateFrom, WasteDeliveryDateTo, Identifier " +
                "FROM {0} ", this.Tablename);

            switch (filter)
            {
                case Message.LoadFilter.MESSAGEHEADER:
                    query += " WHERE MessageHeaderId = @MHID";
                    ((SqlCommand)cmd).Parameters.AddWithValue("@MHID", criteria[0]);
                    break;
                case Message.LoadFilter.ALL:
                default:

                    break;
            }

            cmd.CommandText = query;
        }

        public override List<DatabaseEntity> LoadList(IDataReader reader)
        {
            List<DatabaseEntity> result = new List<DatabaseEntity>();

            while (reader.Read())
            {
                WAS_RCPT was_rcpt = new WAS_RCPT
                {
                    id = reader.GetGuid(0)
                };

                if (!reader.IsDBNull(1)) was_rcpt.IdentificationNumber = reader.GetString(1);
                if (!reader.IsDBNull(2)) was_rcpt.PortReceptionFacilityName = reader.GetString(2);
                if (!reader.IsDBNull(3)) was_rcpt.PortReceptionFacilityProviderName = reader.GetString(3);
                if (!reader.IsDBNull(4)) was_rcpt.WasteDeliveryDateFrom = reader.GetDateTime(4);
                if (!reader.IsDBNull(5)) was_rcpt.WasteDeliveryDateTo = reader.GetDateTime(5);
                if (!reader.IsDBNull(6)) was_rcpt.Identifier = reader.GetString(6);

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

        #endregion

        #region IMessageParagraph implementation

        [Browsable(false)]
        [JsonIgnore]
        public override string Subtitle
        {
            get
            {
                return "Waste receipt";
            }
        }

        [Browsable(false)]
        [JsonIgnore]
        public override List<IMessageParagraph> ChildParagraphs
        {
            get
            {
                List<IMessageParagraph> result = new List<IMessageParagraph>();
                foreach (IMessageParagraph imp in this.WasteReceived)
                    result.Add(imp);
                return result;
            }
        }

        #endregion

        #region Validation

        public override void Validate(List<MessageError> errors, List<MessageViolation> violations)
        {
            foreach (WasteReceived wasteReceived in this.WasteReceived)
            {
                RuleEngine.ValidateProperties(wasteReceived, errors, violations);
                wasteReceived.Validate(errors, violations);
            }
        }

        #endregion

        #region ICloneable implementation

        public override object Clone()
        {
            WAS_RCPT wasRcpt = this.MemberwiseClone() as WAS_RCPT;
            wasRcpt.id = null;
            wasRcpt.WasteReceived = new ObservableCollection<WasteReceived>();
            
            foreach (WasteReceived wasteReceived in this.WasteReceived)
            {
                WasteReceived clonedWasteReceived = wasteReceived.Clone() as WasteReceived;
                clonedWasteReceived.WAS_RCPT = wasRcpt;
                wasRcpt.WasteReceived.Add(clonedWasteReceived);
            }

            foreach(TreatmentFacilityProvider tfp in this.TreatmentFacilityProvider)
            {
                TreatmentFacilityProvider clonedTfp = tfp.Clone() as TreatmentFacilityProvider;
                clonedTfp.WAS_RCPT = wasRcpt;
                wasRcpt.TreatmentFacilityProvider.Add(clonedTfp);
            }            

            return wasRcpt;

        }

        #endregion

    }
}