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

namespace DTS.Common.ISO
{
    [Serializable()]
    public class TestEngineerDetails : TestEngineerDetailsDbRecord //: ISerializableFile
    {
        private enum Fields
        {
            Name,
            TestEngineerName,
            TestEngineerPhone,
            TestEngineerFax,
            TestEngineerEmail,
            LocalOnly,
            LastModified,
            LastModifiedBy,
            Version
        }
        public static TestEngineerDetails ReadXML(System.Xml.XmlElement root)
        {
            var t = new TestEngineerDetails();

            foreach (var node in root.ChildNodes)
            {
                if (node is System.Xml.XmlElement)
                {
                    ProcessXMLElement(node as System.Xml.XmlElement, ref t);
                }
            }
            return t;
        }
        private static void ProcessXMLElement(System.Xml.XmlElement node, ref TestEngineerDetails t)
        {
            if (!Enum.TryParse(node.Name, out Fields field)) return;
            switch (field)
            {
                case Fields.TestEngineerEmail: t.TestEngineerEmail = node.InnerText; break;
                case Fields.TestEngineerFax: t.TestEngineerFax = node.InnerText; break;
                case Fields.TestEngineerName: t.TestEngineerName = node.InnerText; break;
                case Fields.TestEngineerPhone: t.TestEngineerPhone = node.InnerText; break;
                case Fields.LastModified: t.LastModified = DateTime.Parse(node.InnerText, System.Globalization.CultureInfo.InvariantCulture); break;
                case Fields.LastModifiedBy: t.LastModifiedBy = node.InnerText; break;
                case Fields.LocalOnly: t.LocalOnly = bool.Parse(node.InnerText); break;
                case Fields.Name: t.Name = node.InnerText; break;
                case Fields.Version: t.Version = int.Parse(node.InnerText, System.Globalization.CultureInfo.InvariantCulture); break;
                default: throw new NotSupportedException("ISODll.TestEngineerDetails::ProcessXMLElement unsupported field: " + field);
            }
        }
        public void WriteXML(ref System.Xml.XmlWriter writer)
        {
            writer.WriteStartElement("TestEngineerDetail");

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

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

                switch (field)
                {

                    case Fields.TestEngineerEmail: writer.WriteString(TestEngineerEmail); break;
                    case Fields.TestEngineerFax: writer.WriteString(TestEngineerFax); break;
                    case Fields.TestEngineerName: writer.WriteString(TestEngineerName); break;
                    case Fields.TestEngineerPhone: writer.WriteString(TestEngineerPhone); 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.Version: writer.WriteString(Version.ToString(System.Globalization.CultureInfo.InvariantCulture)); break;
                    default: throw new NotSupportedException("TestEngineerDetails::WriteXML unsupported field " + field);
                }

                writer.WriteEndElement();
            }

            writer.WriteEndElement();
        }

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

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

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

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

        public TestEngineerDetails()
        {
        }

        public TestEngineerDetails(TestEngineerDetails copy)
        {
            Name = copy.Name;
            TestEngineerName = copy.TestEngineerName;
            TestEngineerPhone = copy.TestEngineerPhone;
            TestEngineerFax = copy.TestEngineerFax;
            TestEngineerEmail = copy.TestEngineerEmail;
            LocalOnly = copy.LocalOnly;
            LastModified = copy.LastModified;
            LastModifiedBy = copy.LastModifiedBy;
            Version = copy.Version;
        }
        public TestEngineerDetails(ITestEngineerDetailsDbRecord testEngineerDetailsDbRecord)
            : base(testEngineerDetailsDbRecord)
        {
        }
        public static TestEngineerDetails GetTestEngineerDetails(string name)
        {
            try
            {
                var errorNumber = DbOperations.TestEngineerDetailsGet(name, out ITestEngineerDetailsDbRecord[] testEngineerDetailsDbRecords);

                if (errorNumber == 0)
                {
                    return new TestEngineerDetails(testEngineerDetailsDbRecords[0]);
                }
            }
            catch (Exception ex) { APILogger.Log("failed to get test engineer details", name, ex); }
            return null;
        }
        public static void DeleteAllTestEngineerDetails()
        {
            try
            {
                var errorNumber = DbOperations.TestEngineerDetailsDelete(null, out string errorMessage);

                if (errorNumber != 0)
                {
                    APILogger.Log("Failed to delete test engineer details", errorMessage);
                }
            }
            catch (Exception ex) { APILogger.Log("Failed to delete test engineer details", ex); }
        }
        public static TestEngineerDetails[] GetAllTestEngineerDetails()
        {
            var list = new List<TestEngineerDetails>();
            try
            {
                var errorNumber = DbOperations.TestEngineerDetailsGet(null, out ITestEngineerDetailsDbRecord[] testEngineerDetailsDbRecords);

                if (errorNumber == 0)
                {
                    foreach (var testEngineerDetailsDbRecord in testEngineerDetailsDbRecords)
                    {
                        try
                        {
                            var ted = new TestEngineerDetails(testEngineerDetailsDbRecord);
                            if (!ted.IsInvalidBlank())
                            {
                                list.Add(ted);
                            }
                        }
                        catch (Exception ex)
                        {
                            APILogger.Log("failed to get test engineer details", ex);
                        }
                    }
                }
            }
            catch (Exception ex) { APILogger.Log("Failed to retrieve test engineer details", ex); }
            return list.ToArray();
        }

        private void Update(string user)
        {
            try
            {
                var testEngineerDetailsDbRecord = new TestEngineerDetailsDbRecord(this);
                testEngineerDetailsDbRecord.LastModified = DateTime.Now;
                testEngineerDetailsDbRecord.LastModifiedBy = user;
                var errorNumber = DbOperations.TestEngineerDetailsUpdateInsert(testEngineerDetailsDbRecord, out string errorMessage);
                if (errorNumber != 0)
                {
                    APILogger.Log("Failed to update test engineer details", TestEngineerName, errorMessage);
                }
            }
            catch (Exception ex)
            {
                APILogger.Log("Failed to update test engineer details", TestEngineerName, ex);
                throw; //TODO: handle exception properly
            }
        }
        public void Commit(string user)
        {
            try
            {
                if (IsInvalidBlank())
                {
                    throw new NullReferenceException(StringResources.TestEngineerDetails_NullReferenceName);
                }
                Update(user);
            }
            catch (Exception ex)
            {
                APILogger.Log(StringResources.TestEngineerDetails_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 test engineer details", errorMessage);
                }
            }
            catch (Exception ex) { APILogger.Log("Failed to update test engineer details", Name, ex); throw; }
        }
    }
}