using System;
using System.Linq;
using System.Collections.Generic;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Routing;
using Microsoft.Extensions.Logging;
using Microsoft.AspNetCore.Authorization;
using AyaNova.Models;
using AyaNova.Api.ControllerHelpers;
using AyaNova.Biz;
using AyaNova.Util;
using System.Threading.Tasks;


namespace AyaNova.Api.Controllers
{

    /// <summary>
    /// Enum list controller
    /// </summary>
    [ApiController]
    [ApiVersion("8.0")]
    [Route("api/v{version:apiVersion}/enum-list")]
    [Produces("application/json")]
    [Authorize]
    public class EnumListController : ControllerBase
    {
        private readonly AyContext ct;
        private readonly ILogger<EnumListController> log;
        private readonly ApiServerState serverState;


        /// <summary>
        /// ctor
        /// </summary>
        /// <param name="dbcontext"></param>
        /// <param name="logger"></param>
        /// <param name="apiServerState"></param>
        public EnumListController(AyContext dbcontext, ILogger<EnumListController> logger, ApiServerState apiServerState)
        {
            ct = dbcontext;
            log = logger;
            serverState = apiServerState;
        }


        /// <summary>
        /// Get name value Translated display value list of AyaNova enumerated types for list specified
        /// </summary>
        /// <param name="enumkey">The key name of the enumerated type</param>
        /// <returns>List</returns>
        [HttpGet("list/{enumkey}")]
        public async Task<IActionResult> GetList([FromRoute] string enumkey)
        {
            if (serverState.IsClosed && UserIdFromContext.Id(HttpContext.Items) != 1)//bypass for superuser to fix fundamental problems
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            var ret = await GetEnumList(enumkey, UserTranslationIdFromContext.Id(HttpContext.Items), UserRolesFromContext.Roles(HttpContext.Items));
            return Ok(ApiOkResponse.Response(ret));
        }




        /// <summary>
        /// Get all possible enumerated values list key names
        /// </summary>     
        /// <returns>List of AyaNova enumerated type list key names that can be fetched from the GetList Route</returns>
        [HttpGet("listkeys")]
        public ActionResult GetTypesList()
        {
            if (!serverState.IsOpen)
                return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
            List<KeyValuePair<string, string>> ret = new List<KeyValuePair<string, string>>();
            ret.Add(new KeyValuePair<string, string>(StringUtil.TrimTypeName(typeof(UserType).ToString()), "AyaNova user account types"));
            ret.Add(new KeyValuePair<string, string>("insideusertype", "AyaNova user account types for staff / contractors"));
            ret.Add(new KeyValuePair<string, string>("outsideusertype", "AyaNova user account types for customer / headoffice users"));
            ret.Add(new KeyValuePair<string, string>(StringUtil.TrimTypeName(typeof(AuthorizationRoles).ToString()), "AyaNova user account role types"));
            ret.Add(new KeyValuePair<string, string>(StringUtil.TrimTypeName(typeof(AyaType).ToString()), "All AyaNova object types untranslated"));
            ret.Add(new KeyValuePair<string, string>("alltranslated", "All AyaNova object types translated"));
            ret.Add(new KeyValuePair<string, string>("coreall", "All Core AyaNova business object types"));
            ret.Add(new KeyValuePair<string, string>("coreview", "All Core AyaNova business object types current user is allowed to view"));
            ret.Add(new KeyValuePair<string, string>("coreedit", "All Core AyaNova business object types current user is allowed to edit"));
            ret.Add(new KeyValuePair<string, string>("reportable", "All AyaNova business object types that are reportable"));
            ret.Add(new KeyValuePair<string, string>("importable", "All AyaNova business object types that are importable"));
            ret.Add(new KeyValuePair<string, string>(StringUtil.TrimTypeName(typeof(UiFieldDataType).ToString()), "Types of data used in AyaNova for display and formatting UI purposes"));
            ret.Add(new KeyValuePair<string, string>(StringUtil.TrimTypeName(typeof(NotifyEventType).ToString()), "Notification event types"));
            ret.Add(new KeyValuePair<string, string>(StringUtil.TrimTypeName(typeof(NotifyDeliveryMethod).ToString()), "Notification delivery methods"));
            ret.Add(new KeyValuePair<string, string>(StringUtil.TrimTypeName(typeof(NotifyMailSecurity).ToString()), "Notification SMTP mail server security method"));
            ret.Add(new KeyValuePair<string, string>(StringUtil.TrimTypeName(typeof(AyaEvent).ToString()), "Event log object change types"));
            ret.Add(new KeyValuePair<string, string>(StringUtil.TrimTypeName(typeof(LoanUnitRateUnit).ToString()), "Loan unit rate unit types"));
            ret.Add(new KeyValuePair<string, string>(StringUtil.TrimTypeName(typeof(CustomerServiceRequestPriority).ToString()), "csr priorities"));
            ret.Add(new KeyValuePair<string, string>(StringUtil.TrimTypeName(typeof(CustomerServiceRequestStatus).ToString()), "csr status"));
            ret.Add(new KeyValuePair<string, string>(StringUtil.TrimTypeName(typeof(PurchaseOrderStatus).ToString()), "PO Status"));
            ret.Add(new KeyValuePair<string, string>(StringUtil.TrimTypeName(typeof(ContractOverrideType).ToString()), "Contract price adjustment type"));
            ret.Add(new KeyValuePair<string, string>(StringUtil.TrimTypeName(typeof(WorkOrderItemTaskCompletionType).ToString()), "Work order item task completion type"));
            ret.Add(new KeyValuePair<string, string>(StringUtil.TrimTypeName(typeof(PMTimeUnit).ToString()), "PM time units"));
            ret.Add(new KeyValuePair<string, string>(StringUtil.TrimTypeName(typeof(AyaDaysOfWeek).ToString()), "Days of the week"));
            return Ok(ApiOkResponse.Response(ret));
        }



        public static async Task<List<NameIdItem>> GetEnumList(string enumKey, long translationId, AuthorizationRoles userRoles)
        {

            List<string> TranslationKeysToFetch = new List<string>();

            List<NameIdItem> ReturnList = new List<NameIdItem>();

            var keyNameInLowerCase = enumKey.ToLowerInvariant();


            if (keyNameInLowerCase == StringUtil.TrimTypeName(typeof(UiFieldDataType).ToString()).ToLowerInvariant())
            {
                //Iterate the enum and get the values
                Type t = typeof(UiFieldDataType);
                Enum.GetName(t, UiFieldDataType.NoType);
                foreach (var dt in Enum.GetValues(t))
                {
                    ReturnList.Add(new NameIdItem() { Name = Enum.GetName(t, dt), Id = (int)dt });
                }

            }
            else if (keyNameInLowerCase == "coreall")
            {
                //core biz objects for UI facing purposes such as search form limit to object type etc
                var values = Enum.GetValues(typeof(AyaType));
                foreach (AyaType t in values)
                {
                    if (t.HasAttribute(typeof(CoreBizObjectAttribute)))
                    {
                        TranslationKeysToFetch.Add(t.ToString());
                    }
                }
                var LT = await TranslationBiz.GetSubsetStaticAsync(TranslationKeysToFetch, translationId);

                foreach (AyaType t in values)
                {
                    if (t.HasAttribute(typeof(CoreBizObjectAttribute)))
                    {
                        var tName = t.ToString();
                        string name = string.Empty;
                        if (LT.ContainsKey(tName))
                        {
                            name = LT[tName];
                        }
                        else
                        {
                            name = tName;
                        }
                        ReturnList.Add(new NameIdItem() { Name = name, Id = (long)t });
                    }
                }
            }
            else if (keyNameInLowerCase == "reportable")
            {
                //reportable biz objects for report designer selection 
                var values = Enum.GetValues(typeof(AyaType));
                foreach (AyaType t in values)
                {
                    if (t.HasAttribute(typeof(ReportableBizObjectAttribute)))
                    {
                        TranslationKeysToFetch.Add(t.ToString());
                    }
                }
                var LT = await TranslationBiz.GetSubsetStaticAsync(TranslationKeysToFetch, translationId);

                foreach (AyaType t in values)
                {
                    if (t.HasAttribute(typeof(ReportableBizObjectAttribute)))
                    {
                        var tName = t.ToString();
                        string name = string.Empty;
                        if (LT.ContainsKey(tName))
                        {
                            name = LT[tName];
                        }
                        else
                        {
                            name = tName;
                        }
                        ReturnList.Add(new NameIdItem() { Name = name, Id = (long)t });
                    }
                }
            }
            else if (keyNameInLowerCase == "importable")
            {
                //importable biz objects for administration -> import selection
                var values = Enum.GetValues(typeof(AyaType));
                foreach (AyaType t in values)
                {
                    if (t.HasAttribute(typeof(ImportableBizObjectAttribute)))
                    {

                        var nameToFetch = t.ToString();
                        if (t == AyaType.PartInventory)
                            nameToFetch = "PartInventoryTransaction";
                        TranslationKeysToFetch.Add(nameToFetch);
                    }
                }
                var LT = await TranslationBiz.GetSubsetStaticAsync(TranslationKeysToFetch, translationId);

                foreach (AyaType t in values)
                {
                    if (t.HasAttribute(typeof(ImportableBizObjectAttribute)))
                    {
                        var tName = t.ToString();
                        if (t == AyaType.PartInventory)
                            tName = "PartInventoryTransaction";
                        string name = string.Empty;
                        if (LT.ContainsKey(tName))
                        {
                            name = LT[tName];
                        }
                        else
                        {
                            name = tName;
                        }
                        ReturnList.Add(new NameIdItem() { Name = name, Id = (long)t });
                    }
                }
            }
            else if (keyNameInLowerCase == "coreview")//all core objects user can read
            {

                //core biz objects for UI facing purposes
                var rawvalues = Enum.GetValues(typeof(AyaType));

                List<AyaType> allowedValues = new List<AyaType>();
                foreach (AyaType t in rawvalues)
                {
                    if (Authorized.HasReadFullRole(userRoles, t))
                        allowedValues.Add(t);
                }

                foreach (AyaType t in allowedValues)
                {
                    if (t.HasAttribute(typeof(CoreBizObjectAttribute)))
                    {
                        TranslationKeysToFetch.Add(t.ToString());
                    }
                }
                var LT = await TranslationBiz.GetSubsetStaticAsync(TranslationKeysToFetch, translationId);

                foreach (AyaType t in allowedValues)
                {
                    if (t.HasAttribute(typeof(CoreBizObjectAttribute)))
                    {
                        var tName = t.ToString();
                        string name = string.Empty;
                        if (LT.ContainsKey(tName))
                        {
                            name = LT[tName];
                        }
                        else
                        {
                            name = tName;
                        }
                        ReturnList.Add(new NameIdItem() { Name = name, Id = (long)t });
                    }
                }
            }
            else if (keyNameInLowerCase == "coreedit")//all core objects current user can edit
            {
                //core biz objects for UI facing purposes
                var rawvalues = Enum.GetValues(typeof(AyaType));

                List<AyaType> allowedValues = new List<AyaType>();
                foreach (AyaType t in rawvalues)
                {
                    if (Authorized.HasModifyRole(userRoles, t))
                        allowedValues.Add(t);
                }

                foreach (AyaType t in allowedValues)
                {
                    if (t.HasAttribute(typeof(CoreBizObjectAttribute)))
                    {
                        TranslationKeysToFetch.Add(t.ToString());
                    }
                }
                var LT = await TranslationBiz.GetSubsetStaticAsync(TranslationKeysToFetch, translationId);

                foreach (AyaType t in allowedValues)
                {
                    if (t.HasAttribute(typeof(CoreBizObjectAttribute)))
                    {
                        var tName = t.ToString();
                        string name = string.Empty;
                        if (LT.ContainsKey(tName))
                        {
                            name = LT[tName];
                        }
                        else
                        {
                            name = tName;
                        }
                        ReturnList.Add(new NameIdItem() { Name = name, Id = (long)t });
                    }
                }
            }
            else if (keyNameInLowerCase == "alltranslated")//all ayatype objects with translations
            {
                //all types for search results and history UI
                var rawvalues = Enum.GetValues(typeof(AyaType));
                foreach (AyaType t in rawvalues)
                {
                    TranslationKeysToFetch.Add(t.ToString());
                }
                var LT = await TranslationBiz.GetSubsetStaticAsync(TranslationKeysToFetch, translationId);

                foreach (AyaType t in rawvalues)
                {
                    var tName = t.ToString();
                    string name = string.Empty;
                    if (LT.ContainsKey(tName))
                    {
                        name = LT[tName];
                    }
                    else
                    {
                        name = tName;
                    }
                    ReturnList.Add(new NameIdItem() { Name = name, Id = (long)t });

                }
            }
            else if (keyNameInLowerCase == StringUtil.TrimTypeName(typeof(AyaType).ToString()).ToLowerInvariant())
            {
                //All types, used by search form and possibly others

                var values = Enum.GetValues(typeof(AyaType));

                foreach (AyaType t in values)
                    TranslationKeysToFetch.Add(t.ToString());
                var LT = await TranslationBiz.GetSubsetStaticAsync(TranslationKeysToFetch, translationId);

                foreach (AyaType t in values)
                {
                    string tName = t.ToString();
                    string name = string.Empty;
                    if (LT.ContainsKey(tName))
                    {
                        name = LT[tName];
                    }
                    else
                    {
                        name = tName;
                    }
                    ReturnList.Add(new NameIdItem() { Name = name, Id = (long)t });
                }
            }
            else if (keyNameInLowerCase == StringUtil.TrimTypeName(typeof(UserType).ToString()).ToLowerInvariant())
            {

                TranslationKeysToFetch.Add("UserTypeService");
                TranslationKeysToFetch.Add("UserTypeNotService");
                TranslationKeysToFetch.Add("UserTypeCustomer");
                TranslationKeysToFetch.Add("UserTypeHeadOffice");
                TranslationKeysToFetch.Add("UserTypeServiceContractor");
                var LT = await TranslationBiz.GetSubsetStaticAsync(TranslationKeysToFetch, translationId);

                ReturnList.Add(new NameIdItem() { Name = LT["UserTypeService"], Id = (long)UserType.Service });
                ReturnList.Add(new NameIdItem() { Name = LT["UserTypeNotService"], Id = (long)UserType.NotService });
                ReturnList.Add(new NameIdItem() { Name = LT["UserTypeCustomer"], Id = (long)UserType.Customer });
                ReturnList.Add(new NameIdItem() { Name = LT["UserTypeHeadOffice"], Id = (long)UserType.HeadOffice });
                ReturnList.Add(new NameIdItem() { Name = LT["UserTypeServiceContractor"], Id = (long)UserType.ServiceContractor });
            }
            else if (keyNameInLowerCase == "insideusertype")
            {

                TranslationKeysToFetch.Add("UserTypeService");
                TranslationKeysToFetch.Add("UserTypeNotService");
                TranslationKeysToFetch.Add("UserTypeServiceContractor");
                var LT = await TranslationBiz.GetSubsetStaticAsync(TranslationKeysToFetch, translationId);

                ReturnList.Add(new NameIdItem() { Name = LT["UserTypeService"], Id = (long)UserType.Service });
                ReturnList.Add(new NameIdItem() { Name = LT["UserTypeNotService"], Id = (long)UserType.NotService });
                ReturnList.Add(new NameIdItem() { Name = LT["UserTypeServiceContractor"], Id = (long)UserType.ServiceContractor });
            }
            else if (keyNameInLowerCase == "outsideusertype")
            {


                TranslationKeysToFetch.Add("UserTypeCustomer");
                TranslationKeysToFetch.Add("UserTypeHeadOffice");
                var LT = await TranslationBiz.GetSubsetStaticAsync(TranslationKeysToFetch, translationId);

                ReturnList.Add(new NameIdItem() { Name = LT["UserTypeCustomer"], Id = (long)UserType.Customer });
                ReturnList.Add(new NameIdItem() { Name = LT["UserTypeHeadOffice"], Id = (long)UserType.HeadOffice });
            }
            else if (keyNameInLowerCase == StringUtil.TrimTypeName(typeof(AyaEvent).ToString()).ToLowerInvariant())
            {
                TranslationKeysToFetch.Add("EventDeleted");
                TranslationKeysToFetch.Add("EventCreated");
                TranslationKeysToFetch.Add("EventRetrieved");
                TranslationKeysToFetch.Add("EventModified");
                TranslationKeysToFetch.Add("EventAttachmentCreate");
                TranslationKeysToFetch.Add("EventAttachmentDelete");
                TranslationKeysToFetch.Add("EventAttachmentDownload");
                TranslationKeysToFetch.Add("EventLicenseFetch");
                TranslationKeysToFetch.Add("EventLicenseTrialRequest");
                TranslationKeysToFetch.Add("EventServerStateChange");
                TranslationKeysToFetch.Add("EventSeedDatabase");
                TranslationKeysToFetch.Add("EventAttachmentModified");
                TranslationKeysToFetch.Add("AdminEraseDatabase");
                TranslationKeysToFetch.Add("EventResetSerial");
                TranslationKeysToFetch.Add("EventUtilityFileDownload");
                TranslationKeysToFetch.Add("NotifyEventDirectSMTPMessage");
                var LT = await TranslationBiz.GetSubsetStaticAsync(TranslationKeysToFetch, translationId);

                ReturnList.Add(new NameIdItem() { Name = LT["EventDeleted"], Id = (long)AyaEvent.Deleted });
                ReturnList.Add(new NameIdItem() { Name = LT["EventCreated"], Id = (long)AyaEvent.Created });
                ReturnList.Add(new NameIdItem() { Name = LT["EventRetrieved"], Id = (long)AyaEvent.Retrieved });
                ReturnList.Add(new NameIdItem() { Name = LT["EventModified"], Id = (long)AyaEvent.Modified });
                ReturnList.Add(new NameIdItem() { Name = LT["EventAttachmentCreate"], Id = (long)AyaEvent.AttachmentCreate });
                ReturnList.Add(new NameIdItem() { Name = LT["EventAttachmentDelete"], Id = (long)AyaEvent.AttachmentDelete });
                ReturnList.Add(new NameIdItem() { Name = LT["EventAttachmentDownload"], Id = (long)AyaEvent.AttachmentDownload });
                ReturnList.Add(new NameIdItem() { Name = LT["EventLicenseFetch"], Id = (long)AyaEvent.LicenseFetch });
                ReturnList.Add(new NameIdItem() { Name = LT["EventLicenseTrialRequest"], Id = (long)AyaEvent.LicenseTrialRequest });
                ReturnList.Add(new NameIdItem() { Name = LT["EventServerStateChange"], Id = (long)AyaEvent.ServerStateChange });
                ReturnList.Add(new NameIdItem() { Name = LT["EventSeedDatabase"], Id = (long)AyaEvent.SeedDatabase });
                ReturnList.Add(new NameIdItem() { Name = LT["EventAttachmentModified"], Id = (long)AyaEvent.AttachmentModified });
                ReturnList.Add(new NameIdItem() { Name = LT["AdminEraseDatabase"], Id = (long)AyaEvent.EraseAllData });
                ReturnList.Add(new NameIdItem() { Name = LT["EventResetSerial"], Id = (long)AyaEvent.ResetSerial });
                ReturnList.Add(new NameIdItem() { Name = LT["EventUtilityFileDownload"], Id = (long)AyaEvent.UtilityFileDownload });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyEventDirectSMTPMessage"], Id = (long)AyaEvent.DirectSMTP });
            }
            else if (keyNameInLowerCase == StringUtil.TrimTypeName(typeof(AuthorizationRoles).ToString()).ToLowerInvariant())
            {

                // TranslationKeysToFetch.Add("AuthorizationRoleNoRole");
                TranslationKeysToFetch.Add("AuthorizationRoleBizAdminRestricted");
                TranslationKeysToFetch.Add("AuthorizationRoleBizAdmin");
                TranslationKeysToFetch.Add("AuthorizationRoleServiceRestricted");
                TranslationKeysToFetch.Add("AuthorizationRoleService");
                TranslationKeysToFetch.Add("AuthorizationRoleInventoryRestricted");
                TranslationKeysToFetch.Add("AuthorizationRoleInventory");
                TranslationKeysToFetch.Add("AuthorizationRoleAccounting");
                TranslationKeysToFetch.Add("AuthorizationRoleTechRestricted");
                TranslationKeysToFetch.Add("AuthorizationRoleTech");
                TranslationKeysToFetch.Add("AuthorizationRoleSubContractorRestricted");
                TranslationKeysToFetch.Add("AuthorizationRoleSubContractor");
                TranslationKeysToFetch.Add("AuthorizationRoleCustomerRestricted");
                TranslationKeysToFetch.Add("AuthorizationRoleCustomer");
                TranslationKeysToFetch.Add("AuthorizationRoleOpsAdminRestricted");
                TranslationKeysToFetch.Add("AuthorizationRoleOpsAdmin");
                TranslationKeysToFetch.Add("AuthorizationRoleSalesRestricted");
                TranslationKeysToFetch.Add("AuthorizationRoleSales");
                //  TranslationKeysToFetch.Add("AuthorizationRoleAll");
                var LT = await TranslationBiz.GetSubsetStaticAsync(TranslationKeysToFetch, translationId);

                //   ReturnList.Add(new NameIdItem() { Name = LT["AuthorizationRoleNoRole"], Id = (long)AuthorizationRoles.NoRole });
                ReturnList.Add(new NameIdItem() { Name = LT["AuthorizationRoleBizAdminRestricted"], Id = (long)AuthorizationRoles.BizAdminRestricted });
                ReturnList.Add(new NameIdItem() { Name = LT["AuthorizationRoleBizAdmin"], Id = (long)AuthorizationRoles.BizAdmin });
                ReturnList.Add(new NameIdItem() { Name = LT["AuthorizationRoleServiceRestricted"], Id = (long)AuthorizationRoles.ServiceRestricted });
                ReturnList.Add(new NameIdItem() { Name = LT["AuthorizationRoleService"], Id = (long)AuthorizationRoles.Service });
                ReturnList.Add(new NameIdItem() { Name = LT["AuthorizationRoleInventoryRestricted"], Id = (long)AuthorizationRoles.InventoryRestricted });
                ReturnList.Add(new NameIdItem() { Name = LT["AuthorizationRoleInventory"], Id = (long)AuthorizationRoles.Inventory });
                ReturnList.Add(new NameIdItem() { Name = LT["AuthorizationRoleAccounting"], Id = (long)AuthorizationRoles.Accounting });
                ReturnList.Add(new NameIdItem() { Name = LT["AuthorizationRoleTechRestricted"], Id = (long)AuthorizationRoles.TechRestricted });
                ReturnList.Add(new NameIdItem() { Name = LT["AuthorizationRoleTech"], Id = (long)AuthorizationRoles.Tech });
                ReturnList.Add(new NameIdItem() { Name = LT["AuthorizationRoleSubContractorRestricted"], Id = (long)AuthorizationRoles.SubContractorRestricted });
                ReturnList.Add(new NameIdItem() { Name = LT["AuthorizationRoleSubContractor"], Id = (long)AuthorizationRoles.SubContractor });
                ReturnList.Add(new NameIdItem() { Name = LT["AuthorizationRoleCustomerRestricted"], Id = (long)AuthorizationRoles.CustomerRestricted });
                ReturnList.Add(new NameIdItem() { Name = LT["AuthorizationRoleCustomer"], Id = (long)AuthorizationRoles.Customer });
                ReturnList.Add(new NameIdItem() { Name = LT["AuthorizationRoleOpsAdminRestricted"], Id = (long)AuthorizationRoles.OpsAdminRestricted });
                ReturnList.Add(new NameIdItem() { Name = LT["AuthorizationRoleOpsAdmin"], Id = (long)AuthorizationRoles.OpsAdmin });
                ReturnList.Add(new NameIdItem() { Name = LT["AuthorizationRoleSalesRestricted"], Id = (long)AuthorizationRoles.SalesRestricted });
                ReturnList.Add(new NameIdItem() { Name = LT["AuthorizationRoleSales"], Id = (long)AuthorizationRoles.Sales });
                // ReturnList.Add(new NameIdItem() { Name = LT["AuthorizationRoleAll"], Id = (long)AuthorizationRoles.All });

            }
            else if (keyNameInLowerCase == StringUtil.TrimTypeName(typeof(NotifyEventType).ToString()).ToLowerInvariant())
            {
                TranslationKeysToFetch.Add("NotifyEventObjectDeleted");
                TranslationKeysToFetch.Add("NotifyEventObjectCreated");
                TranslationKeysToFetch.Add("NotifyEventObjectModified");
                TranslationKeysToFetch.Add("NotifyEventWorkorderStatusChange");
                TranslationKeysToFetch.Add("NotifyEventContractExpiring");
                TranslationKeysToFetch.Add("NotifyEventCSRAccepted");
                TranslationKeysToFetch.Add("NotifyEventCSRRejected");
                TranslationKeysToFetch.Add("NotifyEventWorkorderCompleted");
                TranslationKeysToFetch.Add("NotifyEventQuoteStatusChange");
                TranslationKeysToFetch.Add("NotifyEventQuoteStatusAge");
                TranslationKeysToFetch.Add("NotifyEventObjectAge");
                TranslationKeysToFetch.Add("NotifyEventServiceBankDepleted");
                TranslationKeysToFetch.Add("NotifyEventReminderImminent");
                TranslationKeysToFetch.Add("NotifyEventScheduledOnWorkorder");
                TranslationKeysToFetch.Add("NotifyEventScheduledOnWorkorderImminent");
                TranslationKeysToFetch.Add("NotifyEventWorkorderCompletedStatusOverdue");
                TranslationKeysToFetch.Add("NotifyEventOutsideServiceOverdue");
                TranslationKeysToFetch.Add("NotifyEventOutsideServiceReceived");
                TranslationKeysToFetch.Add("NotifyEventPartRequestReceived");
                TranslationKeysToFetch.Add("NotifyEventNotifyHealthCheck");
                TranslationKeysToFetch.Add("NotifyEventBackupStatus");
                TranslationKeysToFetch.Add("NotifyEventCustomerServiceImminent");
                TranslationKeysToFetch.Add("NotifyEventPMStopGeneratingDateReached");
                TranslationKeysToFetch.Add("NotifyEventWorkorderTotalExceedsThreshold");
                TranslationKeysToFetch.Add("NotifyEventWorkorderStatusAge");
                TranslationKeysToFetch.Add("NotifyEventUnitWarrantyExpiry");
                TranslationKeysToFetch.Add("NotifyEventUnitMeterReadingMultipleExceeded");
                TranslationKeysToFetch.Add("NotifyEventServerOperationsProblem");
                TranslationKeysToFetch.Add("NotifyEventGeneralNotification");
                //TranslationKeysToFetch.Add("NotifyEventCopyOfCustomerNotification");
                TranslationKeysToFetch.Add("NotifyEventWorkorderCreatedForCustomer");
                TranslationKeysToFetch.Add("NotifyEventPMGenerationFailed");
                TranslationKeysToFetch.Add("NotifyEventPMInsufficientInventory");
                TranslationKeysToFetch.Add("NotifyEventReviewImminent");
                 TranslationKeysToFetch.Add("NotifyEventDirectSMTPMessage");

                var LT = await TranslationBiz.GetSubsetStaticAsync(TranslationKeysToFetch, translationId);

                ReturnList.Add(new NameIdItem() { Name = LT["NotifyEventObjectDeleted"], Id = (long)NotifyEventType.ObjectDeleted });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyEventObjectCreated"], Id = (long)NotifyEventType.ObjectCreated });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyEventObjectModified"], Id = (long)NotifyEventType.ObjectModified });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyEventWorkorderStatusChange"], Id = (long)NotifyEventType.WorkorderStatusChange });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyEventContractExpiring"], Id = (long)NotifyEventType.ContractExpiring });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyEventCSRAccepted"], Id = (long)NotifyEventType.CSRAccepted });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyEventCSRRejected"], Id = (long)NotifyEventType.CSRRejected });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyEventWorkorderCompleted"], Id = (long)NotifyEventType.WorkorderCompleted });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyEventQuoteStatusChange"], Id = (long)NotifyEventType.QuoteStatusChange });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyEventQuoteStatusAge"], Id = (long)NotifyEventType.QuoteStatusAge });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyEventObjectAge"], Id = (long)NotifyEventType.ObjectAge });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyEventPMInsufficientInventory"], Id = (long)NotifyEventType.PMInsufficientInventory });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyEventReminderImminent"], Id = (long)NotifyEventType.ReminderImminent });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyEventReviewImminent"], Id = (long)NotifyEventType.ReviewImminent });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyEventScheduledOnWorkorder"], Id = (long)NotifyEventType.ScheduledOnWorkorder });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyEventScheduledOnWorkorderImminent"], Id = (long)NotifyEventType.ScheduledOnWorkorderImminent });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyEventWorkorderCompletedStatusOverdue"], Id = (long)NotifyEventType.WorkorderCompletedStatusOverdue });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyEventOutsideServiceOverdue"], Id = (long)NotifyEventType.OutsideServiceOverdue });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyEventOutsideServiceReceived"], Id = (long)NotifyEventType.OutsideServiceReceived });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyEventPartRequestReceived"], Id = (long)NotifyEventType.PartRequestReceived });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyEventNotifyHealthCheck"], Id = (long)NotifyEventType.NotifyHealthCheck });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyEventBackupStatus"], Id = (long)NotifyEventType.BackupStatus });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyEventCustomerServiceImminent"], Id = (long)NotifyEventType.CustomerServiceImminent });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyEventPMStopGeneratingDateReached"], Id = (long)NotifyEventType.PMStopGeneratingDateReached });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyEventWorkorderTotalExceedsThreshold"], Id = (long)NotifyEventType.WorkorderTotalExceedsThreshold });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyEventWorkorderStatusAge"], Id = (long)NotifyEventType.WorkorderStatusAge });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyEventUnitWarrantyExpiry"], Id = (long)NotifyEventType.UnitWarrantyExpiry });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyEventUnitMeterReadingMultipleExceeded"], Id = (long)NotifyEventType.UnitMeterReadingMultipleExceeded });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyEventServerOperationsProblem"], Id = (long)NotifyEventType.ServerOperationsProblem });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyEventGeneralNotification"], Id = (long)NotifyEventType.GeneralNotification });

                // ReturnList.Add(new NameIdItem() { Name = LT["NotifyEventCopyOfCustomerNotification"], Id = (long)NotifyEventType.CopyOfCustomerNotification });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyEventWorkorderCreatedForCustomer"], Id = (long)NotifyEventType.WorkorderCreatedForCustomer });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyEventPMGenerationFailed"], Id = (long)NotifyEventType.PMGenerationFailed });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyEventDirectSMTPMessage"], Id = (long)NotifyEventType.DirectSMTPMessage });

            }
            else if (keyNameInLowerCase == StringUtil.TrimTypeName(typeof(NotifyDeliveryMethod).ToString()).ToLowerInvariant())
            {
                TranslationKeysToFetch.Add("NotifyDeliveryMethodApp");
                TranslationKeysToFetch.Add("NotifyDeliveryMethodSMTP");

                var LT = await TranslationBiz.GetSubsetStaticAsync(TranslationKeysToFetch, translationId);

                ReturnList.Add(new NameIdItem() { Name = LT["NotifyDeliveryMethodApp"], Id = (long)NotifyDeliveryMethod.App });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyDeliveryMethodSMTP"], Id = (long)NotifyDeliveryMethod.SMTP });
            }
            else if (keyNameInLowerCase == StringUtil.TrimTypeName(typeof(NotifyMailSecurity).ToString()).ToLowerInvariant())
            {
                TranslationKeysToFetch.Add("NotifyMailSecurityNone");
                TranslationKeysToFetch.Add("NotifyMailSecuritySSLTLS");
                TranslationKeysToFetch.Add("NotifyMailSecurityStartTls");

                var LT = await TranslationBiz.GetSubsetStaticAsync(TranslationKeysToFetch, translationId);

                ReturnList.Add(new NameIdItem() { Name = LT["NotifyMailSecurityNone"], Id = (long)NotifyMailSecurity.None });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyMailSecuritySSLTLS"], Id = (long)NotifyMailSecurity.SSLTLS });
                ReturnList.Add(new NameIdItem() { Name = LT["NotifyMailSecurityStartTls"], Id = (long)NotifyMailSecurity.StartTls });
            }
            else if (keyNameInLowerCase == StringUtil.TrimTypeName(typeof(LoanUnitRateUnit).ToString()).ToLowerInvariant())
            {

                TranslationKeysToFetch.Add("LoanUnitRateDay");
                TranslationKeysToFetch.Add("LoanUnitRateHalfDay");
                TranslationKeysToFetch.Add("LoanUnitRateHour");
                TranslationKeysToFetch.Add("LoanUnitRateMonth");
                TranslationKeysToFetch.Add("LoanUnitRateNone");
                TranslationKeysToFetch.Add("LoanUnitRateWeek");
                TranslationKeysToFetch.Add("LoanUnitRateYear");

                var LT = await TranslationBiz.GetSubsetStaticAsync(TranslationKeysToFetch, translationId);

                ReturnList.Add(new NameIdItem() { Name = LT["LoanUnitRateNone"], Id = (long)LoanUnitRateUnit.None });
                ReturnList.Add(new NameIdItem() { Name = LT["LoanUnitRateHour"], Id = (long)LoanUnitRateUnit.Hours });
                ReturnList.Add(new NameIdItem() { Name = LT["LoanUnitRateHalfDay"], Id = (long)LoanUnitRateUnit.HalfDays });
                ReturnList.Add(new NameIdItem() { Name = LT["LoanUnitRateDay"], Id = (long)LoanUnitRateUnit.Days });
                ReturnList.Add(new NameIdItem() { Name = LT["LoanUnitRateWeek"], Id = (long)LoanUnitRateUnit.Weeks });
                ReturnList.Add(new NameIdItem() { Name = LT["LoanUnitRateMonth"], Id = (long)LoanUnitRateUnit.Months });
                ReturnList.Add(new NameIdItem() { Name = LT["LoanUnitRateYear"], Id = (long)LoanUnitRateUnit.Years });

            }
            else if (keyNameInLowerCase == StringUtil.TrimTypeName(typeof(CustomerServiceRequestPriority).ToString()).ToLowerInvariant())
            {
                TranslationKeysToFetch.Add("CustomerServiceRequestPriorityASAP");
                TranslationKeysToFetch.Add("CustomerServiceRequestPriorityNotUrgent");
                TranslationKeysToFetch.Add("CustomerServiceRequestPriorityEmergency");

                var LT = await TranslationBiz.GetSubsetStaticAsync(TranslationKeysToFetch, translationId);

                ReturnList.Add(new NameIdItem() { Name = LT["CustomerServiceRequestPriorityNotUrgent"], Id = (long)CustomerServiceRequestPriority.NotUrgent });
                ReturnList.Add(new NameIdItem() { Name = LT["CustomerServiceRequestPriorityASAP"], Id = (long)CustomerServiceRequestPriority.ASAP });
                ReturnList.Add(new NameIdItem() { Name = LT["CustomerServiceRequestPriorityEmergency"], Id = (long)CustomerServiceRequestPriority.Emergency });
            }
            else if (keyNameInLowerCase == StringUtil.TrimTypeName(typeof(CustomerServiceRequestStatus).ToString()).ToLowerInvariant())
            {
                TranslationKeysToFetch.Add("CustomerServiceRequestStatusOpen");
                TranslationKeysToFetch.Add("CustomerServiceRequestStatusAccepted");
                TranslationKeysToFetch.Add("CustomerServiceRequestStatusDeclined");

                var LT = await TranslationBiz.GetSubsetStaticAsync(TranslationKeysToFetch, translationId);

                ReturnList.Add(new NameIdItem() { Name = LT["CustomerServiceRequestStatusOpen"], Id = (long)CustomerServiceRequestStatus.Open });
                ReturnList.Add(new NameIdItem() { Name = LT["CustomerServiceRequestStatusAccepted"], Id = (long)CustomerServiceRequestStatus.Accepted });
                ReturnList.Add(new NameIdItem() { Name = LT["CustomerServiceRequestStatusDeclined"], Id = (long)CustomerServiceRequestStatus.Declined });
            }
            else if (keyNameInLowerCase == StringUtil.TrimTypeName(typeof(PurchaseOrderStatus).ToString()).ToLowerInvariant())
            {
                TranslationKeysToFetch.Add("PurchaseOrderStatusOpenNotYetOrdered");
                TranslationKeysToFetch.Add("PurchaseOrderStatusOpenOrdered");
                TranslationKeysToFetch.Add("PurchaseOrderStatusOpenPartialReceived");
                TranslationKeysToFetch.Add("PurchaseOrderStatusClosedFullReceived");
                TranslationKeysToFetch.Add("PurchaseOrderStatusClosedNoneReceived");
                TranslationKeysToFetch.Add("PurchaseOrderStatusClosedPartialReceived");

                var LT = await TranslationBiz.GetSubsetStaticAsync(TranslationKeysToFetch, translationId);

                ReturnList.Add(new NameIdItem() { Name = LT["PurchaseOrderStatusOpenNotYetOrdered"], Id = (long)PurchaseOrderStatus.OpenNotYetOrdered });
                ReturnList.Add(new NameIdItem() { Name = LT["PurchaseOrderStatusOpenOrdered"], Id = (long)PurchaseOrderStatus.OpenOrdered });
                ReturnList.Add(new NameIdItem() { Name = LT["PurchaseOrderStatusOpenPartialReceived"], Id = (long)PurchaseOrderStatus.OpenPartialReceived });
                ReturnList.Add(new NameIdItem() { Name = LT["PurchaseOrderStatusClosedFullReceived"], Id = (long)PurchaseOrderStatus.ClosedFullReceived });
                ReturnList.Add(new NameIdItem() { Name = LT["PurchaseOrderStatusClosedNoneReceived"], Id = (long)PurchaseOrderStatus.ClosedNoneReceived });
                ReturnList.Add(new NameIdItem() { Name = LT["PurchaseOrderStatusClosedPartialReceived"], Id = (long)PurchaseOrderStatus.ClosedPartialReceived });
            }
            else if (keyNameInLowerCase == StringUtil.TrimTypeName(typeof(ContractOverrideType).ToString()).ToLowerInvariant())
            {
                TranslationKeysToFetch.Add("ContractOverrideTypePriceDiscount");
                TranslationKeysToFetch.Add("ContractOverrideTypeMarkup");

                var LT = await TranslationBiz.GetSubsetStaticAsync(TranslationKeysToFetch, translationId);

                ReturnList.Add(new NameIdItem() { Name = LT["ContractOverrideTypePriceDiscount"], Id = (long)ContractOverrideType.PriceDiscount });
                ReturnList.Add(new NameIdItem() { Name = LT["ContractOverrideTypeMarkup"], Id = (long)ContractOverrideType.CostMarkup });
                //this is not a valid setting, not sure why it's there
                // ReturnList.Add(new NameIdItem() { Name = "-", Id = (long)ContractOverrideType.NotSet });

            }
            else if (keyNameInLowerCase == StringUtil.TrimTypeName(typeof(WorkOrderItemTaskCompletionType).ToString()).ToLowerInvariant())
            {
                TranslationKeysToFetch.Add("WorkOrderItemTaskCompletionTypeComplete");
                TranslationKeysToFetch.Add("WorkOrderItemTaskCompletionTypeIncomplete");
                TranslationKeysToFetch.Add("WorkOrderItemTaskCompletionTypeNotApplicable");
                TranslationKeysToFetch.Add("WorkOrderItemTaskCompletionTypeFailed");

                var LT = await TranslationBiz.GetSubsetStaticAsync(TranslationKeysToFetch, translationId);

                ReturnList.Add(new NameIdItem() { Name = LT["WorkOrderItemTaskCompletionTypeComplete"], Id = (long)WorkOrderItemTaskCompletionType.Complete });
                ReturnList.Add(new NameIdItem() { Name = LT["WorkOrderItemTaskCompletionTypeIncomplete"], Id = (long)WorkOrderItemTaskCompletionType.Incomplete });
                ReturnList.Add(new NameIdItem() { Name = LT["WorkOrderItemTaskCompletionTypeNotApplicable"], Id = (long)WorkOrderItemTaskCompletionType.NotApplicable });
                ReturnList.Add(new NameIdItem() { Name = LT["WorkOrderItemTaskCompletionTypeFailed"], Id = (long)WorkOrderItemTaskCompletionType.Failed });
            }
            else if (keyNameInLowerCase == StringUtil.TrimTypeName(typeof(PMTimeUnit).ToString()).ToLowerInvariant())
            {

                TranslationKeysToFetch.Add("TimeSpanYears");
                TranslationKeysToFetch.Add("TimeSpanMonths");
                TranslationKeysToFetch.Add("TimeSpanDays");
                TranslationKeysToFetch.Add("TimeSpanHours");
                TranslationKeysToFetch.Add("TimeSpanMinutes");

                var LT = await TranslationBiz.GetSubsetStaticAsync(TranslationKeysToFetch, translationId);

                ReturnList.Add(new NameIdItem() { Name = LT["TimeSpanYears"], Id = (long)PMTimeUnit.Years });
                ReturnList.Add(new NameIdItem() { Name = LT["TimeSpanMonths"], Id = (long)PMTimeUnit.Months });
                ReturnList.Add(new NameIdItem() { Name = LT["TimeSpanDays"], Id = (long)PMTimeUnit.Days });
                ReturnList.Add(new NameIdItem() { Name = LT["TimeSpanHours"], Id = (long)PMTimeUnit.Hours });
                ReturnList.Add(new NameIdItem() { Name = LT["TimeSpanMinutes"], Id = (long)PMTimeUnit.Minutes });

            }
            else if (keyNameInLowerCase == StringUtil.TrimTypeName(typeof(AyaDaysOfWeek).ToString()).ToLowerInvariant())
            {

                TranslationKeysToFetch.Add("DayMonday");
                TranslationKeysToFetch.Add("DayTuesday");
                TranslationKeysToFetch.Add("DayWednesday");
                TranslationKeysToFetch.Add("DayThursday");
                TranslationKeysToFetch.Add("DayFriday");
                TranslationKeysToFetch.Add("DaySaturday");
                TranslationKeysToFetch.Add("DaySunday");


                var LT = await TranslationBiz.GetSubsetStaticAsync(TranslationKeysToFetch, translationId);

                ReturnList.Add(new NameIdItem() { Name = LT["DayMonday"], Id = (long)AyaDaysOfWeek.Monday });
                ReturnList.Add(new NameIdItem() { Name = LT["DayTuesday"], Id = (long)AyaDaysOfWeek.Tuesday });
                ReturnList.Add(new NameIdItem() { Name = LT["DayWednesday"], Id = (long)AyaDaysOfWeek.Wednesday });
                ReturnList.Add(new NameIdItem() { Name = LT["DayThursday"], Id = (long)AyaDaysOfWeek.Thursday });
                ReturnList.Add(new NameIdItem() { Name = LT["DayFriday"], Id = (long)AyaDaysOfWeek.Friday });
                ReturnList.Add(new NameIdItem() { Name = LT["DaySaturday"], Id = (long)AyaDaysOfWeek.Saturday });
                ReturnList.Add(new NameIdItem() { Name = LT["DaySunday"], Id = (long)AyaDaysOfWeek.Sunday });

            }
            //#################################################################################################################
            //################### NEW HERE DO NOT FORGET TO ADD TO LISTS AVAILABLE ABOVE AS WELL ##############################
            //#################################################################################################################
            else
            {
                ReturnList.Add(new NameIdItem() { Name = $"Unknown enum type list key value {enumKey}", Id = 0 });
            }

            return ReturnList;

        }


    }//eoc
}//ens