using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows;
using DTS.Common.Base;
using DTS.Common.Storage;
using DTS.Common.Enums;
using DTS.Common.DataModel;
using DTS.Common.SharedResource.Strings;

namespace DataPROWin7.DataModel
{
    public class TestEngineerDetails : BasePropertyChanged
    {

        private bool _blank = true;
        public bool IsBlank() { return _blank; }

        private DTS.Common.ISO.TestEngineerDetails _testEngineerDetails;
        public enum Fields
        {
            Name,
            TestEngineerName,
            TestEngineerPhone,
            TestEngineerFax,
            TestEngineerEmail
        }

        public string Name
        {
            get => _testEngineerDetails.Name;
            set
            {
                _testEngineerDetails.Name = value;
                _blank = false;
                OnPropertyChanged(Fields.Name.ToString());
            }
        }

        public string TestEngineerName
        {
            get => _testEngineerDetails.TestEngineerName;
            set
            {
                _testEngineerDetails.TestEngineerName = value;
                _blank = false;
                OnPropertyChanged(Fields.TestEngineerName.ToString());
            }
        }

        public string TestEngineerPhone
        {
            get => _testEngineerDetails.TestEngineerPhone;
            set
            {
                _testEngineerDetails.TestEngineerPhone = value;
                _blank = false;
                OnPropertyChanged(Fields.TestEngineerPhone.ToString());
            }
        }

        public string TestEngineerFax
        {
            get => _testEngineerDetails.TestEngineerFax;
            set
            {
                _testEngineerDetails.TestEngineerFax = value;
                _blank = false;
                OnPropertyChanged(Fields.TestEngineerFax.ToString());
            }
        }

        public string TestEngineerEmail
        {
            get => _testEngineerDetails.TestEngineerEmail;
            set
            {
                _testEngineerDetails.TestEngineerEmail = value;
                _blank = false;
                OnPropertyChanged(Fields.TestEngineerEmail.ToString());
            }
        }

        public bool LocalOnly => _testEngineerDetails.LocalOnly;

        public DateTime LastModified => _testEngineerDetails.LastModified;

        public string LastModifiedBy => _testEngineerDetails.LastModifiedBy;

        public int Version => _testEngineerDetails.Version;

        public TestEngineerDetails()
        {
            _testEngineerDetails = new DTS.Common.ISO.TestEngineerDetails();
            _testEngineerDetails.Name = StringResources.TestTemplate_EmptyListName;
        }

        public bool HasBlankName()
        {
            return _testEngineerDetails.Name == StringResources.TestTemplate_EmptyListName;
        }
        public TestEngineerDetails(DTS.Common.ISO.TestEngineerDetails testEngineerDetails)
        {
            _blank = false;
            _testEngineerDetails = new DTS.Common.ISO.TestEngineerDetails(testEngineerDetails);
        }
        public DTS.Common.ISO.TestEngineerDetails GetISOTestEngineer()
        {
            return _testEngineerDetails;
        }
        public override string ToString()
        {
            return Name;
        }
    }
    public class TestEngineerDetailsList : BasePropertyChanged
    {
        public enum Tags
        {
            TestEngineers

        }
        protected TestEngineerDetailsList()
        {
        }

        private static TestEngineerDetailsList _testEngineerList = new TestEngineerDetailsList();
        public static TestEngineerDetailsList TestEngineerList => _testEngineerList;
        public void Delete(TestEngineerDetails testEngineer)
        {
            testEngineer.GetISOTestEngineer().Delete(ApplicationProperties.CurrentUser.UserName);
            lock (_testEngineerLock)
            {
                _testEngineers.Remove(testEngineer.Name);
            }
            OnPropertyChanged(Tags.TestEngineers.ToString());
        }
        public void Delete(TestEngineerDetails[] testEngineers)
        {
            foreach (var testEngineer in testEngineers)
            {
                Delete(testEngineer);
            }
        }
        private static readonly object _testEngineerLock = new object();
        private Dictionary<string, TestEngineerDetails> _testEngineers = null;
        public TestEngineerDetails[] TestEngineers
        {
            get
            {
                lock (_testEngineerLock)
                {
                    if (null == _testEngineers || _testEngineers.Count == 0)
                    {
                        PopulateEngineers();
                    }
                }
                List<TestEngineerDetails> testEngineers = new List<TestEngineerDetails>(_testEngineers.Values);
                testEngineers.Sort(new Comparison<TestEngineerDetails>(CompareTestEngineers));
                return testEngineers.ToArray();
            }
        }
        private void PopulateEngineers()
        {
            _testEngineers = new Dictionary<string, TestEngineerDetails>();
            foreach (var t in GetAllTestEngineers())
            {
                if (!_testEngineers.ContainsKey(t.Name)) { _testEngineers.Add(t.Name, t); }
            }
        }
        public void ReloadAll()
        {
            lock (_testEngineerLock)
            {
                PopulateEngineers();
            }
        }
        public void DeleteAll()
        {
            _testEngineers = null;
            DTS.Common.ISO.TestEngineerDetails.DeleteAllTestEngineerDetails();
        }
        private int CompareTestEngineers(TestEngineerDetails a, TestEngineerDetails b)
        {
            if (a == b) { return 0; }
            if (null == a) { return -1; }
            if (null == b) { return 1; }
            return a.Name.CompareTo(b.Name);
        }

        public static TestEngineerDetails[] GetAllTestEngineers()
        {
            var list = new List<TestEngineerDetails>();
            if (RunTestVariables.InRunTest &&
                TestTemplateList.TestTemplatesList.CachedTestEngineerDetails != null &&
                TestTemplateList.TestTemplatesList.CachedTestEngineerDetails.Count > 0)
            {
                DbOperations.LogDBCaching("****** Using cached Laboratory Details in GetAllTestEngineers");
                var isoTestEngineersList = new List<DTS.Common.ISO.TestEngineerDetails>();
                foreach (var te in TestTemplateList.TestTemplatesList.CachedTestEngineerDetails)
                {
                    var isoTestEngineerDetails = new DTS.Common.ISO.TestEngineerDetails()
                    {
                        Name = te.Value.Name,
                        TestEngineerName = te.Value.TestEngineerName,
                        TestEngineerPhone = te.Value.TestEngineerPhone,
                        TestEngineerEmail = te.Value.TestEngineerEmail,
                        TestEngineerFax = te.Value.TestEngineerFax
                    };

                    isoTestEngineersList.Add(isoTestEngineerDetails);
                }
                list = isoTestEngineersList.Select(isote => new TestEngineerDetails(isote)).ToList();
            }
            else
            {
                foreach (var ts in DTS.Common.ISO.TestEngineerDetails.GetAllTestEngineerDetails())
                {
                    list.Add(new TestEngineerDetails(ts));
                }
            }
            return list.ToArray();
        }

        public TestEngineerDetails GetTestEngineerDetail(string name)
        {
            var testEngineers = from t in TestEngineers.AsParallel() where t.Name == name select t;
            if (null != testEngineers && testEngineers.Any()) { return testEngineers.First(); }
            else { return null; }
        }

        public void AddTestEngineer(TestEngineerDetails testEngineer)
        {
            testEngineer.GetISOTestEngineer().Commit(ApplicationProperties.CurrentUser.UserName);
            lock (_testEngineerLock)
            {
                //force _testEngineers to not be null...
                var length = TestEngineers.Length;
                if (!_testEngineers.ContainsKey(testEngineer.Name)) { _testEngineers.Add(testEngineer.Name, testEngineer); }
                else { _testEngineers[testEngineer.Name] = testEngineer; }
            }
            OnPropertyChanged(Tags.TestEngineers.ToString());
        }
    }
}