using System;
using System.Collections.Generic;
using System.Linq;
using System.Data;
using System.Data.SqlClient;
using DTS.Common.Storage;
using DTS.Common.Utilities.Logging;
using ISO.Strings;
using DTS.Common.Classes.CustomerDetails;
using DTS.Common.Interface.TestMetaData;

namespace DTS.Common.ISO
{
    [Serializable]
    public class CustomerDetails : CustomerDetailsDbRecord //: ISerializableFile
    {
        #region properties
        public new string ProjectRefNumber
        {
            get => base.ProjectRefNumber;
            set
            {
                if (value != string.Empty)
                {
                    base.ProjectRefNumber = value;
                }
            }
        }

        public new string CustomerOrderNumber
        {
            get => base.CustomerOrderNumber;
            set
            {
                if (value != string.Empty)
                {
                    base.CustomerOrderNumber = value;
                }
            }
        }

        public new string CustomerCostUnit
        {
            get => base.CustomerCostUnit;
            set
            {
                if (value != string.Empty)
                {
                    base.CustomerCostUnit = value;
                }
            }
        }

        #endregion properties
        #region constructor
        public CustomerDetails()
        {
        }

        //public CustomerDetails(string name, bool localOnly) { Name = name; LocalOnly = localOnly; }

        public CustomerDetails(ICustomerDetailsDbRecord customerDetailsDbRecord)
            : base(customerDetailsDbRecord)
        {
        }
        #endregion constructor
        private enum Fields
        {
            Name,
            CustomerName,
            CustomerTestRefNumber,
            ProjectRefNumber,
            CustomerOrderNumber,
            CustomerCostUnit,
            LocalOnly,
            LastModified,
            LastModifiedBy,
            Version
        }
        public static CustomerDetails ReadXML(System.Xml.XmlElement root)
        {
            var c = new CustomerDetails();

            foreach (var node in root.ChildNodes)
            {
                if (node is System.Xml.XmlElement)
                {
                    ProcessXMLElement(node as System.Xml.XmlElement, ref c);
                }
            }
            return c;
        }
        private static void ProcessXMLElement(System.Xml.XmlElement node, ref CustomerDetails c)
        {
            if (!Enum.TryParse(node.Name, out Fields field)) return;
            switch (field)
            {
                case Fields.CustomerCostUnit: c.CustomerCostUnit = node.InnerText; break;
                case Fields.CustomerName: c.CustomerName = node.InnerText; break;
                case Fields.CustomerOrderNumber: c.CustomerOrderNumber = node.InnerText; break;
                case Fields.CustomerTestRefNumber: c.CustomerTestRefNumber = node.InnerText; break;
                case Fields.LastModified: c.LastModified = DateTime.Parse(node.InnerText, System.Globalization.CultureInfo.InvariantCulture); break;
                case Fields.LastModifiedBy: c.LastModifiedBy = node.InnerText; break;
                case Fields.LocalOnly: c.LocalOnly = bool.Parse(node.InnerText); break;
                case Fields.Name: c.Name = node.InnerText; break;
                case Fields.ProjectRefNumber: c.ProjectRefNumber = node.InnerText; break;
                case Fields.Version: c.Version = int.Parse(node.InnerText, System.Globalization.CultureInfo.InvariantCulture); break;
                default: throw new NotSupportedException("ISODll.CustomerDetails::ProcessXMLElement unsupported field: " + field.ToString());
            }
        }
        public void WriteXML(ref System.Xml.XmlWriter writer)
        {
            writer.WriteStartElement("CustomerDetail");

            var fields = Enum.GetValues(typeof(Fields)).Cast<Fields>().ToArray();

            foreach (var field in fields)
            {
                writer.WriteStartElement(field.ToString());

                switch (field)
                {
                    case Fields.CustomerCostUnit: writer.WriteString(CustomerCostUnit); break;
                    case Fields.CustomerName: writer.WriteString(CustomerName); break;
                    case Fields.CustomerOrderNumber: writer.WriteString(CustomerOrderNumber); break;
                    case Fields.CustomerTestRefNumber: writer.WriteString(CustomerTestRefNumber); break;
                    case Fields.LastModified: writer.WriteString(LastModified.ToString(System.Globalization.CultureInfo.InvariantCulture)); break;
                    case Fields.LastModifiedBy: writer.WriteString(LastModifiedBy); break;
                    case Fields.LocalOnly: writer.WriteString(LocalOnly.ToString()); break;
                    case Fields.Name: writer.WriteString(Name); break;
                    case Fields.ProjectRefNumber: writer.WriteString(ProjectRefNumber); break;
                    case Fields.Version: writer.WriteString(Version.ToString(System.Globalization.CultureInfo.InvariantCulture)); break;
                    default: throw new NotSupportedException("CustomerDetails::WriteXML unsupported field " + field.ToString());
                }

                writer.WriteEndElement();
            }

            writer.WriteEndElement();
        }

        public static CustomerDetails GetCustomerDetails(string name)
        {
            try
            {
                var errorNumber = DbOperations.CustomerDetailsGet(name, out ICustomerDetailsDbRecord[] customerDetailsDbRecords);

                if (errorNumber == 0 && null != customerDetailsDbRecords && customerDetailsDbRecords.Any())
                {
                    return new CustomerDetails(customerDetailsDbRecords[0]);
                }
            }
            catch (Exception ex)
            {
                APILogger.Log("failed to get customer details", name, ex);
            }
            return null;
        }
        public static void DeleteCustomerDetails(string name = null)
        {
            try
            {
                var errorNumber = DbOperations.CustomerDetailsDelete(name, out string errorMessage);

                if (errorNumber != 0)
                {
                    APILogger.Log("Failed to delete customer details", errorMessage);
                }
            }
            catch (Exception ex)
            {
                APILogger.Log("Failed to delete customer details", ex);
            }
        }
        public static CustomerDetails[] GetAllCustomerDetails()
        {
            var list = new List<CustomerDetails>();
            try
            {
                var errorNumber = DbOperations.CustomerDetailsGet(null, out ICustomerDetailsDbRecord[] customerDetailsDbRecords);

                if (errorNumber == 0)
                {
                    foreach (var customerDetailDbRecord in customerDetailsDbRecords)
                    {
                        try
                        {
                            var cd = new CustomerDetails(customerDetailDbRecord);
                            if (!cd.IsInvalidBlank())
                            {
                                list.Add(cd);
                            }
                        }
                        catch (Exception ex)
                        {
                            APILogger.Log("failed to get customer details", ex);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                APILogger.Log("Failed to retrieve customer details", ex);
            }
            return list.ToArray();
        }
        private void Insert(string user)
        {
            try
            {
                var customerDetailsDbRecord = new CustomerDetailsDbRecord(this);
                customerDetailsDbRecord.LastModified = DateTime.Now;
                customerDetailsDbRecord.LastModifiedBy = user;
                customerDetailsDbRecord.Version = Version;
                var errorNumber = DbOperations.CustomerDetailsInsert(customerDetailsDbRecord, out int newId, out string errorMessage);
                if (errorNumber != 0)
                {
                    throw new Exception(errorMessage);
                }
                if (newId != -1)
                {
                    customerDetailsDbRecord.CustomerId = newId;
                }
            }
            catch (Exception ex)
            {
                APILogger.Log("Failed to insert new customer details", Name, ex);
                throw;
            }
        }
        private void UpdateAll(string user)
        {
            try
            {
                var customerDetailsDbRecord = new CustomerDetailsDbRecord(this);
                customerDetailsDbRecord.LastModified = DateTime.Now;
                customerDetailsDbRecord.LastModifiedBy = user;
                var errorNumber = DbOperations.CustomerDetailsUpdate(customerDetailsDbRecord, out string errorMessage);
                if (errorNumber != 0)
                {
                    throw new Exception(errorMessage);
                }
            }
            catch (Exception ex)
            {
                APILogger.Log("Failed to update customer details", Name, ex);
                throw;
            }
        }
        public void Commit(string user)
        {
            try
            {
                if (IsInvalidBlank())
                {
                    throw new NullReferenceException(StringResources.CustomerDetails_NullReferenceName);
                }

                if (null == GetCustomerDetails(Name))
                {
                    Insert(user);
                }
                else
                {
                    UpdateAll(user);
                }
            }
            catch (Exception ex)
            {
                APILogger.Log(StringResources.CustomerDetails_FailedToCommit, Name, ex);
                throw ex;
            }
        }
        public void Delete(string user)
        {
            try
            {
                var errorNumber = DbOperations.CustomerDetailsDelete(Name, out string errorMessage);

                if (errorNumber != 0)
                {
                    APILogger.Log("Failed to delete customer details", errorMessage);
                }
            }
            catch (Exception ex)
            {
                APILogger.Log("Failed to update customer details", Name, ex);
                throw;
            }
        }
    }
}