///
/// Copyright (c) 2015-2023 Sensus Slovensko a.s.
///
using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using Common;

namespace SharedDatabase.Entities
{
    public class WaterMeterData
	{
        public virtual int                         Id                          { get; protected set; }
		public virtual string                      ProductName                 { get; set; }
		public virtual string                      Producer                    { get; set; }
        public virtual double                      DN                          { get; set; }	/// [mm]
        public virtual double                      L                           { get; set; }	/// [mm]
        public virtual Mounting                    Mounting                    { get; set; }	/// H / V / S / F
		public virtual sbyte                       Qnames                      { get; set; }	/// see Common.Enums.FlowNames
        public virtual double                      Q4_Qmax                     { get; set; }	/// [m3/h]
		public virtual double                      Q3_Qn                       { get; set; }	/// [m3/h]
		public virtual double                      Q2_Qt                       { get; set; }	/// [m3/h]
		public virtual double                      Q1_Qmin                     { get; set; }	/// [m3/h]
        public virtual double                      ErrLimHiQ                   { get; set; }	/// [%]
        public virtual double                      ErrLimLoQ                   { get; set; }	/// [%]
        
        public virtual string                      MetrologicalClass           { get; set; }
        public virtual TemperatureClass            TemperatureClass            { get; set; }
        public virtual PressureLossClass           PressureLossClass           { get; set; }
        public virtual MaxAdmissiblePressure       MaxAdmissiblePressure       { get; set; }
        public virtual FlowProfileSensitivityClass FlowProfileSensitivityClass { get; set; }
        public virtual string                      ApprovalInfo                { get; set; }
        public virtual string                      Certificate                 { get; set; }
        public virtual double                      PulsesPerLtr                { get; set; }
 
        ///  Concerns compound water meters
        public virtual string                      ProducerAux                 { get; set; }
        public virtual double                      Q3_Qn_Aux                   { get; set; }	/// [m3/h]
        public virtual string                      MetrologicalClassAux        { get; set; }
        public virtual string                      ApprovalInfoAux             { get; set; }

        public virtual Medium                      Medium                      { get; set; }
        public virtual string                      Text1                       { get; set; }
        public virtual string                      Text2                       { get; set; }
        public virtual string                      Text3                       { get; set; }
        public virtual string                      Text4                       { get; set; }
        public virtual string                      Text5                       { get; set; }
        public virtual bool                        Compound                    { get; set; }
        public virtual bool                        HeatMeter                   { get; set; }
		public virtual int                         WMTypeId                    { get; set; }    /// Mapped to DB only when ORACLE_DB is defined

        /// <summary>
        /// Default constructor, safe values
        /// </summary>
        public WaterMeterData()
		{
		}

        /// <summary>
        /// Copy constructor, copies all except of Id
        /// </summary>
        public WaterMeterData(WaterMeterData oriWMData)
        {
            ProductName                 = oriWMData.ProductName;
            Producer                    = oriWMData.Producer;
            DN                          = oriWMData.DN;
            L                           = oriWMData.L;
            Mounting                    = oriWMData.Mounting;
            Qnames                      = oriWMData.Qnames;
            Q4_Qmax                     = oriWMData.Q4_Qmax;
            Q3_Qn                       = oriWMData.Q3_Qn;
            Q2_Qt                       = oriWMData.Q2_Qt;
            Q1_Qmin                     = oriWMData.Q1_Qmin;
            ErrLimHiQ                   = oriWMData.ErrLimHiQ;
            ErrLimLoQ                   = oriWMData.ErrLimLoQ;
            MetrologicalClass           = oriWMData.MetrologicalClass;
            TemperatureClass            = oriWMData.TemperatureClass;
            PressureLossClass           = oriWMData.PressureLossClass;
            MaxAdmissiblePressure       = oriWMData.MaxAdmissiblePressure;
            FlowProfileSensitivityClass = oriWMData.FlowProfileSensitivityClass;
            ApprovalInfo                = oriWMData.ApprovalInfo;
            Certificate                 = oriWMData.Certificate;
            PulsesPerLtr                = oriWMData.PulsesPerLtr;
            ProducerAux                 = oriWMData.ProducerAux;
            Q3_Qn_Aux                   = oriWMData.Q3_Qn_Aux;
            MetrologicalClassAux        = oriWMData.MetrologicalClassAux;
            ApprovalInfoAux             = oriWMData.ApprovalInfoAux;
            Medium                      = oriWMData.Medium;
            Text1                       = oriWMData.Text1;
            Text2                       = oriWMData.Text2;
            Text3                       = oriWMData.Text3;
            Text4                       = oriWMData.Text4;
            Text5                       = oriWMData.Text5;
            Compound                    = oriWMData.Compound;
            HeatMeter                   = oriWMData.HeatMeter;
            WMTypeId                    = oriWMData.WMTypeId;
        }


		/// <summary>
		/// Method to compare the content of two entities
		/// </summary>
		/// <param name="wmd">Second entity to compare with</param>
		/// <returns>first = two entities are equal (except of Id)</returns>
		public virtual bool Equals(WaterMeterData wmd)
		{
			if (ProductName != wmd.ProductName) return false;
			if (Producer != wmd.Producer) return false;
            if (DN != wmd.DN) return false;
            if (L != wmd.L) return false;
            if (Mounting != wmd.Mounting) return false;
			if (Qnames != wmd.Qnames) return false;
            if (Q4_Qmax != wmd.Q4_Qmax) return false;
			if (Q3_Qn   != wmd.Q3_Qn) return false;
			if (Q2_Qt   != wmd.Q2_Qt) return false;
			if (Q1_Qmin != wmd.Q1_Qmin) return false;
            if (ErrLimHiQ != wmd.ErrLimHiQ) return false;
            if (ErrLimLoQ != wmd.ErrLimLoQ) return false;
            if (MetrologicalClass != wmd.MetrologicalClass) return false;
            if (TemperatureClass != wmd.TemperatureClass) return false;
            if (PressureLossClass != wmd.PressureLossClass) return false;
            if (MaxAdmissiblePressure != wmd.MaxAdmissiblePressure) return false;
            if (FlowProfileSensitivityClass != wmd.FlowProfileSensitivityClass) return false;
            if (ApprovalInfo != wmd.ApprovalInfo) return false;
            if (Certificate != wmd.Certificate) return false;
            if (PulsesPerLtr != wmd.PulsesPerLtr) return false;
            if (ProducerAux != wmd.ProducerAux) return false;
            if (Q3_Qn_Aux != wmd.Q3_Qn_Aux) return false;
            if (MetrologicalClassAux != wmd.MetrologicalClassAux) return false;
            if (ApprovalInfoAux != wmd.ApprovalInfoAux) return false;
            if (Medium != wmd.Medium) return false;
            if (Text1 != wmd.Text1) return false;
            if (Text2 != wmd.Text2) return false;
            if (Text3 != wmd.Text3) return false;
            if (Text4 != wmd.Text4) return false;
            if (Text5 != wmd.Text5) return false;
            if (Compound != wmd.Compound) return false;
			if (HeatMeter != wmd.HeatMeter) return false;
            if (WMTypeId != wmd.WMTypeId) return false;
            return true;
		}


		/// <summary>
		/// Adds an item to the list if it does not occur there
		/// </summary>
		/// <param name="list">List of items</param>
		/// <param name="item">Item to add to the list or find there</param>
		/// <returns>Item from the list (existing or added)</returns>
		public static WaterMeterData UpdateList(IList<WaterMeterData> list, WaterMeterData item)
		{
			if (item == null) return null;		/// Null item is not stored in the list

			WaterMeterData found = list.FirstOrDefault<WaterMeterData>(x => x.Equals(item));

			if (found != null) return found;	/// The same item found in the list, The found item returned

			list.Add(item);						/// Item not fund in the list, it is added to the list
			return item;
		}

        public virtual void WriteBinary(BinaryWriter writer)
        {
            writer.Write(Id);
            writer.Write((ProductName != null) ? ProductName : string.Empty);
            writer.Write((Producer != null) ? Producer : string.Empty);
            writer.Write(DN);
            writer.Write(L);
            writer.Write((int)Mounting);
            writer.Write((int)Qnames);
            writer.Write(Q4_Qmax);
            writer.Write(Q3_Qn);
            writer.Write(Q2_Qt);
            writer.Write(Q1_Qmin);
            writer.Write(ErrLimHiQ);
            writer.Write(ErrLimLoQ);
            writer.Write((MetrologicalClass != null) ? MetrologicalClass : string.Empty);
            writer.Write((int)TemperatureClass);
            writer.Write((int)PressureLossClass);
            writer.Write((int)MaxAdmissiblePressure);
            writer.Write((int)FlowProfileSensitivityClass);
            writer.Write((ApprovalInfo != null) ? ApprovalInfo : string.Empty);
            writer.Write((Certificate != null) ? Certificate : string.Empty);
            writer.Write(PulsesPerLtr);
            writer.Write((ProducerAux != null) ? ProducerAux : string.Empty);
            writer.Write(Q3_Qn_Aux);
            writer.Write((MetrologicalClassAux != null) ? MetrologicalClassAux : string.Empty);
            writer.Write((ApprovalInfoAux != null) ? ApprovalInfoAux : string.Empty);
            writer.Write((int)Medium);
            writer.Write((Text1 != null) ? Text1 : string.Empty);
            writer.Write((Text2 != null) ? Text2 : string.Empty);
            writer.Write((Text3 != null) ? Text3 : string.Empty);
            writer.Write((Text4 != null) ? Text4 : string.Empty);
            writer.Write((Text5 != null) ? Text5 : string.Empty);
            writer.Write(Compound);
            writer.Write(HeatMeter);
		    writer.Write(WMTypeId);
        }

        public virtual void ReadBinary(BinaryReader reader)
        {
            Id = reader.ReadInt32();
            ProductName = reader.ReadString();
            Producer = reader.ReadString();
            DN = reader.ReadDouble();
            L = reader.ReadDouble();
            Mounting = (Mounting)reader.ReadInt32();
            Qnames = (sbyte)reader.ReadInt32();
            Q4_Qmax = reader.ReadDouble();
            Q3_Qn = reader.ReadDouble();
            Q2_Qt = reader.ReadDouble();
            Q1_Qmin = reader.ReadDouble();
            ErrLimHiQ = reader.ReadDouble();
            ErrLimLoQ = reader.ReadDouble();
            MetrologicalClass = reader.ReadString();
            TemperatureClass = (TemperatureClass)reader.ReadInt32();
            PressureLossClass = (PressureLossClass)reader.ReadInt32();
            MaxAdmissiblePressure = (MaxAdmissiblePressure)reader.ReadInt32();
            FlowProfileSensitivityClass = (FlowProfileSensitivityClass)reader.ReadInt32();
            ApprovalInfo = reader.ReadString();
            Certificate = reader.ReadString();
            PulsesPerLtr = reader.ReadDouble();
            ProducerAux = reader.ReadString();
            Q3_Qn_Aux = reader.ReadDouble();
            MetrologicalClassAux = reader.ReadString();
            ApprovalInfoAux = reader.ReadString();
            Medium = (Medium)reader.ReadInt32();
            Text1 = reader.ReadString();
            Text2 = reader.ReadString();
            Text3 = reader.ReadString();
            Text4 = reader.ReadString();
            Text5 = reader.ReadString();
            Compound = reader.ReadBoolean();
            HeatMeter = reader.ReadBoolean();
            WMTypeId = reader.ReadInt32();
        }
    }
}