//
//  Class:			WAS
//	Current CLR:	4.0.30319.34209
//	System:			Microsoft Visual Studio 10.0
//	Author:			dani
// 	Created:		4/2/2015 7:38:45 PM
//
//	Copyright (c) 2015 Informatikbüro Daniel Schick. All rights reserved.

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

namespace bsmd.database
{
    public class WAS : DatabaseEntity, ISublistContainer
    {

        private ObservableCollection<DatabaseEntity> wdsp = new ObservableCollection<DatabaseEntity>();

        private ObservableCollection<DatabaseEntity> waste = new ObservableCollection<DatabaseEntity>();

        private static readonly int[] dkWasteCodes = { 1100, 1200, 1300, 2100, 2200, 2300, 2311, 2308, 2600, 2300, 2309, 3000, 5100, 5200, 5300, 2300 };
        private static readonly int[] requiredCodes = { 1100, 1200, 1300, 2100, 2200, 2300, 2311, 2308, 2600, 2309, 3000, 5100, 5200, 5300 };
        private static readonly string[] dkWasteTypes = { "Waste oils - Sludge", "Waste oils - Bilge water", "Waste oils - Other", "Garbage - Food waste", "Garbage - Plastic", "Garbage - Other", "Garbage - Other - Cooking oil", "Garbage - Other - Incinerator ashes and clinkers", "Operational wastes", "Garbage - Other", "Garbage - Other - Animal carcasses", "Sewage", "Cargo residues - Marpol Annex I - Other", "Cargo residues - Marpol Annex II - Other", "Cargo residues - Marpol Annex V - Other", "Garbage - Other" };
        private static readonly string[] requiredTypes = { "Oily Residues (sludge)", "Oily Bilge Water", "Waste oil - others (specify)", "Food waste", "Plastics", "Domestic wastes", "Cooking oil", "Incinerator ashes", "Operational wastes", "Animal carcass(es)", "Sewage", "Cargo residues - Marpol Annex I", "Cargo residues - Marpol Annex II", "Cargo residues - Marpol Annex V"  };

        public WAS()
        {
            this.tablename = "[dbo].[WAS]";
            this.WasteDisposalValidExemption = false;
        }

        #region Properties

        public static int[] DKWasteCodes { get { return dkWasteCodes; } }

        public static string[] DKWasteTypes { get { return dkWasteTypes; } }

        public static int[] RequiredCodes { get { return requiredCodes; } }

        public static string[] RequiredTypes { get { return requiredTypes; } }

        [ShowReport]
        [ENI2Validation]
        public bool? WasteDisposalValidExemption { get; set; }

        [ShowReport]
        [Validation2(ValidationCode.LOCODE)]
        [LookupName("WAS.LastWasteDisposalPort")]
        [MaxLength(5)]
        [ENI2Validation]
        public string LastWasteDisposalPort { get; set; }

        [ShowReport]
        [Validation2(ValidationCode.NOT_NULL)]
        [LookupName("WAS.ConfirmationOfCorrectness")]
        [ENI2Validation]
        public bool? ConfirmationOfCorrectness { get; set; }

        [ShowReport]
        [Validation2(ValidationCode.NOT_NULL)]
        [LookupName("WAS.LastWasteDisposalDate")]
        [ENI2Validation]
        [DateOnly]
        public DateTime? LastWasteDisposalDate { get; set; }

        [ShowReport]
        [Validation2(ValidationCode.NOT_NULL)]
        [ENI2Validation]
        public byte? WasteDisposalDelivery { get; set; }

        [LookupName("WAS.ConfirmationOfSufficiency")]
        [ENI2Validation]
        public bool? ConfirmationOfSufficiency { get; set; }

        public ObservableCollection<DatabaseEntity> Waste { get { return this.waste; } }

        public ObservableCollection<DatabaseEntity> WasteDisposalServiceProvider { get { return this.wdsp; } }

        /// <summary>
        /// Hilfsproperty, um eine kommaseparierte Liste von WasteDisposalServiceProvider (analog ANSW) im ENI-2 anzuzeigen,
        /// bzw im Setter um eine kommaseparierte Liste mit den WasteDisposalServiceProvider Entitäten abzugleichen
        /// </summary>
        public string WasteDisposalServiceProviderText
        {
            get
            {
                StringBuilder sb = new StringBuilder();
                for(int i=0;i<this.WasteDisposalServiceProvider.Count;i++) 
                {
                    if (i > 0)
                        sb.Append(", ");
                    sb.Append(((WasteDisposalServiceProvider) this.WasteDisposalServiceProvider[i]).WasteDisposalServiceProviderName);                    
                }
                return sb.ToString();
            }
            set
            {
                if (value.IsNullOrEmpty())
                {
                    foreach (WasteDisposalServiceProvider wdsp in this.WasteDisposalServiceProvider)
                        DBManager.Instance.Delete(wdsp);
                    this.WasteDisposalServiceProvider.Clear();
                }
                else
                {
                    string[] serviceProviderNames = value.Split(',');
                    List<WasteDisposalServiceProvider> foundList = new List<database.WasteDisposalServiceProvider>();

                    for (int i=0;i<serviceProviderNames.Length;i++)
                    {                        
                        string serviceProviderName = serviceProviderNames[i].Trim();
                        if(serviceProviderName.Length > 0)
                        {
                            WasteDisposalServiceProvider matchingServiceProvider = null;
                            foreach(WasteDisposalServiceProvider wdsp in this.WasteDisposalServiceProvider)
                            {
                                if(wdsp.WasteDisposalServiceProviderName.Equals(serviceProviderName, StringComparison.OrdinalIgnoreCase))
                                {
                                    matchingServiceProvider = wdsp;
                                    break;
                                }
                            }
                            if(matchingServiceProvider != null)
                            {
                                foundList.Add(matchingServiceProvider);
                                this.WasteDisposalServiceProvider.Remove(matchingServiceProvider);
                            }
                            else
                            {
                                WasteDisposalServiceProvider newWDSP = new WasteDisposalServiceProvider();
                                newWDSP.WAS = this;
                                newWDSP.WasteDisposalServiceProviderName = serviceProviderName;
                                foundList.Add(newWDSP);
                            }
                        }
                    }

                    // remove remaining service provider (no longer valid)
                    foreach (WasteDisposalServiceProvider remainingProvider in this.WasteDisposalServiceProvider)
                        DBManager.Instance.Delete(remainingProvider);
                    this.WasteDisposalServiceProvider.Clear();
                    // add existing and new providers
                    foreach(WasteDisposalServiceProvider wdsp in foundList)
                        this.WasteDisposalServiceProvider.Add(wdsp);
                    DatabaseEntity.ResetIdentifiers(this.WasteDisposalServiceProvider);
                }
            }
        }

        #endregion

        #region DatabaseEntity implementation

        public override void PrepareSave(System.Data.IDbCommand cmd)
        {

            SqlCommand scmd = cmd as SqlCommand;

            scmd.Parameters.AddWithValue("@P1", this.MessageHeader.Id);
            scmd.Parameters.AddWithNullableValue("@P2", this.WasteDisposalValidExemption);
            scmd.Parameters.AddWithNullableValue("@P3", this.LastWasteDisposalPort);
            scmd.Parameters.AddWithNullableValue("@P4", this.ConfirmationOfCorrectness);
            scmd.Parameters.AddWithNullableValue("@P5", this.LastWasteDisposalDate);
            scmd.Parameters.AddWithNullableValue("@P6", this.WasteDisposalDelivery);
            scmd.Parameters.AddWithNullableValue("@P7", this.ConfirmationOfSufficiency);

            if (this.IsNew)
            {
                this.CreateId();
                scmd.Parameters.AddWithValue("@ID", this.Id);
                scmd.CommandText = string.Format("INSERT INTO {0} (Id, MessageHeaderId, WasteDisposalValidExemption, " +
                    "LastWasteDisposalPort, ConfirmationOfCorrectness, LastWasteDisposalDate, WasteDisposalDelivery, " +
                    "ConfirmationOfSufficiency) 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 WasteDisposalValidExemption = @P2, LastWasteDisposalPort = @P3, " +
                    "ConfirmationOfCorrectness = @P4, LastWasteDisposalDate = @P5, WasteDisposalDelivery = @P6, ConfirmationOfSufficiency = @P7 " +
                    "WHERE Id = @ID", this.Tablename);
            }
        }

        public override void PrepareLoadCommand(System.Data.IDbCommand cmd, Message.LoadFilter filter, params object[] criteria)
        {
            string query = string.Format("SELECT Id, WasteDisposalValidExemption, LastWasteDisposalPort, ConfirmationOfCorrectness, " +
                "LastWasteDisposalDate, WasteDisposalDelivery, ConfirmationOfSufficiency " +
                "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(System.Data.IDataReader reader)
        {
            List<DatabaseEntity> result = new List<DatabaseEntity>();

            while (reader.Read())
            {
                WAS was = new WAS();

                was.id = reader.GetGuid(0);
                if (!reader.IsDBNull(1)) was.WasteDisposalValidExemption = reader.GetBoolean(1);
                if (!reader.IsDBNull(2)) was.LastWasteDisposalPort = reader.GetString(2);
                if (!reader.IsDBNull(3)) was.ConfirmationOfCorrectness = reader.GetBoolean(3);
                if (!reader.IsDBNull(4)) was.LastWasteDisposalDate = reader.GetDateTime(4);
                if (!reader.IsDBNull(5)) was.WasteDisposalDelivery = reader.GetByte(5);
                if (!reader.IsDBNull(6)) was.ConfirmationOfSufficiency = reader.GetBoolean(6);
                result.Add(was);
            }
            reader.Close();
            return result;
        }

        #endregion

        #region ISublistContainer implementation

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

        public int NumberOfExcelRows
        {
            get { return 15; }
        }

        public void SaveElements()
        {
            foreach(Waste waste in this.Waste)
            {
                DBManager.Instance.Save(waste);
            }            

            foreach(WasteDisposalServiceProvider wdsp in this.WasteDisposalServiceProvider)
            {
                DBManager.Instance.Save(wdsp);
            }            
        }

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

            foreach (WasteDisposalServiceProvider wdsp in this.WasteDisposalServiceProvider)
            {
                DBManager.Instance.Delete(wdsp);
            }
            this.WasteDisposalServiceProvider.Clear();
        }

        #endregion

        #region IMessageParagraph implementation

        public override string Subtitle
        {
            get
            {
                return "Waste/cargo residue";
            }
        }

        public override List<IMessageParagraph> ChildParagraphs
        {
            get
            {
                List<IMessageParagraph> result = new List<IMessageParagraph>();
                foreach (IMessageParagraph imp in this.Waste)
                    result.Add(imp);
                return result;
            }
        }

        #endregion

        #region Validation

        public override DatabaseEntity.ValidationBlock GetValidationBlock()
        {
            return (this.WasteDisposalValidExemption ?? false) ? ValidationBlock.BLOCK1 : ValidationBlock.BLOCK2;
        }

        public override void Validate(List<MessageError> errors, List<MessageViolation> violations)
        {
            
            if(this.GetValidationBlock() == ValidationBlock.BLOCK2)
            {                
                foreach (Waste waste in this.Waste)
                {
                    RuleEngine.ValidateProperties(waste, errors, violations);
                    waste.Validate(errors, violations);
                }

                foreach(WasteDisposalServiceProvider wdsp in this.WasteDisposalServiceProvider)
                {
                    RuleEngine.ValidateProperties(wdsp, errors, violations);
                    wdsp.Validate(errors, violations);
                }

                bool entryMissing = false;
                int missingType = 0;

                foreach(int wasteCode in requiredCodes)
                {
                    bool codeFound = false;
                    foreach(Waste w in this.Waste)
                    {
                        if((w.WasteType ?? 0) == wasteCode)
                        {
                            codeFound = true; break;
                        }
                    }
                    if(!codeFound)
                    {
                        missingType = wasteCode;
                        entryMissing = true;
                        break;
                    }                    
                }

                if(entryMissing)
                {
                    errors.Add(RuleEngine.CreateError(ValidationCode.POSITION_COUNT, string.Format("Waste {0}", missingType), null, this.Title, null, this.Tablename));
                }

                if(!(this.ConfirmationOfCorrectness ?? false))
                {
                    errors.Add(RuleEngine.CreateError(ValidationCode.IMPLAUSIBLE, "Confirmation of correctness not set!", null, this.Title, null, this.Tablename));
                }

            }
        }

        #endregion

        #region public convenience method

        public List<Waste> AddRemainingWasteTypes()
        {
            List<Waste> result = new List<Waste>();

            for (byte wType = 1; wType <= 9; wType++ )
            {
                bool wasteTypeFound = false;
                foreach (Waste w in this.Waste)
                {
                    if ((w.WasteType ?? 0) == wType)
                        wasteTypeFound = true;
                }
                if (!wasteTypeFound)
                {
                    Waste newWaste = new Waste();
                    newWaste.WasteType = wType;
                    newWaste.WasteAmountGeneratedTillNextPort_MTQ = 0;
                    newWaste.WasteAmountRetained_MTQ = 0;
                    newWaste.WasteCapacity_MTQ = 0;
                    newWaste.WasteDisposalAmount_MTQ = 0;
                    newWaste.Identifier = "";
                    newWaste.WasteDisposalPort = "ZZUKN";
                    newWaste.WasteDescription = "-";
                    newWaste.WAS = this;
                    this.Waste.Add(newWaste);
                    result.Add(newWaste);
                }
            }
            return result;
        }

        /// <summary>
        /// Convenience Methode, die fehlende Waste Einträge ergänzt. Verbesserte Version, aus ENI-2 herüberkopiert, damit es auch im
        /// Excel_Reader nutzbar wird
        /// </summary>        
        public void AddMissingWaste()
        {
            
            foreach (int wasteCode in WAS.requiredCodes)
            {
                Waste foundWaste = null;
                foreach (Waste waste in this.Waste)
                {
                    if (waste.WasteType.HasValue && waste.WasteType.Value == wasteCode)
                    {
                        foundWaste = waste;
                        break;
                    }
                }
                if (foundWaste == null)
                {
                    Waste newWaste = new Waste();
                    newWaste.Identifier = DatabaseEntity.GetNewIdentifier(this.Waste);
                    newWaste.WAS = this;
                    newWaste.WasteAmountGeneratedTillNextPort_MTQ = 0;
                    newWaste.WasteAmountRetained_MTQ = 0;
                    newWaste.WasteCapacity_MTQ = 0;
                    newWaste.WasteDescription = (wasteCode == 1300) ? "-" : "";
                    newWaste.WasteDisposalAmount_MTQ = 0;
                    newWaste.WasteDisposalPort = "ZZUKN";
                    newWaste.WasteDisposedAtLastPort_MTQ = 0;
                    newWaste.WasteType = wasteCode;
                    this.Waste.Add(newWaste);
                }
                else
                {
                    if (!foundWaste.WasteAmountGeneratedTillNextPort_MTQ.HasValue) foundWaste.WasteAmountGeneratedTillNextPort_MTQ = 0;
                    if (!foundWaste.WasteAmountRetained_MTQ.HasValue) foundWaste.WasteAmountRetained_MTQ = 0;
                    if (!foundWaste.WasteCapacity_MTQ.HasValue) foundWaste.WasteCapacity_MTQ = 0;
                    if ((wasteCode == 1300) && foundWaste.WasteDescription.IsNullOrEmpty()) foundWaste.WasteDescription = "-";
                    if (!foundWaste.WasteDisposalAmount_MTQ.HasValue) foundWaste.WasteDisposalAmount_MTQ = 0;
                    if (foundWaste.WasteDisposalPort.IsNullOrEmpty()) foundWaste.WasteDisposalPort = "ZZUKN";
                    if (!foundWaste.WasteDisposedAtLastPort_MTQ.HasValue) foundWaste.WasteDisposedAtLastPort_MTQ = 0;
                }
            }
        }

        #endregion

        #region ICloneable implementation

        public override object Clone()
        {
            WAS was = this.MemberwiseClone() as WAS;
            was.id = null;
            was.waste = new ObservableCollection<DatabaseEntity>();
            was.wdsp = new ObservableCollection<DatabaseEntity>();

            foreach (Waste waste in this.Waste)
            {
                Waste clonedWaste = waste.Clone() as Waste;
                clonedWaste.WAS = was;
                was.Waste.Add(clonedWaste);
            }

            foreach (WasteDisposalServiceProvider wdsp in this.WasteDisposalServiceProvider)
            {
                WasteDisposalServiceProvider clonedWDSP = wdsp.Clone() as WasteDisposalServiceProvider;
                clonedWDSP.WAS = was;
                was.WasteDisposalServiceProvider.Add(clonedWDSP);
            }

            return was;

        }

        #endregion

    }
}