using Dapper;

using Fab2ApprovalSystem.Models;

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;

#if !NET8
using System.Data.Linq;
#endif

using System.Linq;
using System.Transactions;

using Fab2ApprovalSystem.Misc;
using Fab2ApprovalSystem.Utilities;

using System.IO;

namespace Fab2ApprovalSystem.DMO;

public class AuditDMO {

    private readonly AppSettings _AppSettings;
    private readonly IDbConnection db = new SqlConnection(GlobalVars.DB_CONNECTION_STRING);

    public AuditDMO(AppSettings appSettings) =>
        _AppSettings = appSettings;

    public Audit InsertAudit(Audit audit) {
        DynamicParameters parameters = new();

        parameters = new DynamicParameters();
        parameters.Add("@AuditNo", value: audit.AuditNo, dbType: DbType.Int32, direction: ParameterDirection.InputOutput);
        parameters.Add("@OriginatorID", audit.OriginatorID);

        db.Execute("_8DInsertAuditItem", parameters, commandType: CommandType.StoredProcedure);
        audit.AuditNo = parameters.Get<int>("@AuditNo");

        return audit;
    }

    public Audit GetAuditItem(int auditNo, int userID) {
        Audit audit = new();

        //isITAR = 2;

        DynamicParameters parameters = new();
        parameters.Add("@AuditNo", value: auditNo);
        parameters.Add("@UserID", userID);
        //parameters.Add("@IsITAR", value: isITAR, dbType: DbType.Int32, direction: ParameterDirection.InputOutput);

        //audit = this.db.Query<Audit>("_8DGetAuditItem", parameters, commandType: CommandType.StoredProcedure).Single();

        using (var multipleResultItems = db.QueryMultiple("_8DGetAuditItem", parameters, commandType: CommandType.StoredProcedure)) {
            audit = multipleResultItems.Read<Audit>().SingleOrDefault();

            List<int> auditors = multipleResultItems.Read<int>().ToList();

            if (audit != null && auditors != null) {
                if (auditors.Count > 0)
                    audit.AuditorIDs.AddRange(auditors);
            }

            List<int> auditorTypes = multipleResultItems.Read<int>().ToList();
            if (audit != null && auditorTypes != null) {
                if (auditorTypes.Count > 0)
                    audit.AuditTypeIDs.AddRange(auditorTypes);
            }

            List<int> auditorAreas = multipleResultItems.Read<int>().ToList();
            if (audit != null && auditorAreas != null) {
                if (auditorAreas.Count > 0)
                    audit.AuditedAreaIDs.AddRange(auditorAreas);
            }
        }
        //FabApprovalSystemEntitiesAll auditDb = new FabApprovalSystemEntitiesAll();

        //var auditedStandardIDs = (from a in auditDb.C_8DAuditedStandardByAudit where a.AuditNo == audit.AuditNo select a.AuditedStandardID).ToList();

        //foreach (var id in auditedStandardIDs)
        //{
        //    audit.AuditedStandardIDs.Add(id);
        //}

        return audit;
    }

    public Audit GetAuditItemReadOnly(int auditNo, int userID) {
        Audit audit = new();

        //isITAR = 2;

        DynamicParameters parameters = new();
        parameters.Add("@AuditNo", value: auditNo);
        parameters.Add("@UserID", userID);
        //parameters.Add("@IsITAR", value: isITAR, dbType: DbType.Int32, direction: ParameterDirection.InputOutput);

        //audit = this.db.Query<Audit>("_8DGetAuditItem", parameters, commandType: CommandType.StoredProcedure).Single();

        using (var multipleResultItems = db.QueryMultiple("_8DGetAuditItemReadOnly", parameters, commandType: CommandType.StoredProcedure)) {
            audit = multipleResultItems.Read<Audit>().SingleOrDefault();

            List<int> auditors = multipleResultItems.Read<int>().ToList();

            if (audit != null && auditors != null) {
                if (auditors.Count > 0)
                    audit.AuditorIDs.AddRange(auditors);
            }

            List<int> auditorTypes = multipleResultItems.Read<int>().ToList();
            if (audit != null && auditorTypes != null) {
                if (auditorTypes.Count > 0)
                    audit.AuditTypeIDs.AddRange(auditorTypes);
            }

            List<int> auditorAreas = multipleResultItems.Read<int>().ToList();
            if (audit != null && auditorAreas != null) {
                if (auditorAreas.Count > 0)
                    audit.AuditedAreaIDs.AddRange(auditorAreas);
            }
        }

        return audit;
    }

    public IEnumerable<AuditType> GetAuditTypeList() {
        DynamicParameters parameters = new();

        List<AuditType> auditTypeList = db.Query<AuditType>("_8DGetAuditTypeList", parameters, commandType: CommandType.StoredProcedure).ToList();
        return auditTypeList;
    }

#if !NET8
    public IEnumerable<C_8DAuditedStandard> GetAuditStandardList() {
        FabApprovalSystemEntitiesAll db = new FabApprovalSystemEntitiesAll();

        var auditStandardList = from a in db.C_8DAuditedStandard select a;

        return auditStandardList;
    }
#endif
    public IEnumerable<Auditor> GetAuditorList() {
        DynamicParameters parameters = new();

        List<Auditor> auditorList = db.Query<Auditor>("_8DGetAuditorList", parameters, commandType: CommandType.StoredProcedure).ToList();
        return auditorList;
    }

    public IEnumerable<AuditedArea> GetAuditAreaList() {
        DynamicParameters parameters = new();

        List<AuditedArea> auditAreaList = db.Query<AuditedArea>("_8DGetAuditAreaList", parameters, commandType: CommandType.StoredProcedure).ToList();
        return auditAreaList;
    }

    public void UpdateAudit(Audit audit, int userID) {
        int result = 0;
        DynamicParameters parameters = new();

        using (TransactionScope transaction = new()) {
            try {
                parameters.Add("AuditNo", audit.AuditNo);
                parameters.Add("Title", audit.AuditTitle);
                //parameters.Add("AuditTypeID", audit.AuditTypeID);
                parameters.Add("AuditDate", audit.AuditDate);
                parameters.Add("AuditStatus", audit.AuditStatus);
                parameters.Add("AuditScore", audit.AuditScore);
                //parameters.Add("AuditedAreaID", audit.AuditedAreaID);
                parameters.Add("Auditees", audit.Auditees);
                db.Execute("_8DUpdateAudit", param: parameters, commandType: CommandType.StoredProcedure);

                parameters = new DynamicParameters();
                parameters.Add("@AuditNo", audit.AuditNo);
                db.Execute("_8DDeleteAuditors", parameters, commandType: CommandType.StoredProcedure);
                List<int> auditors = audit.AuditorIDs;
                if (auditors != null) {
                    foreach (int auditorID in auditors) {
                        parameters = new DynamicParameters();
                        parameters.Add("@AuditNo", audit.AuditNo);
                        parameters.Add("@AuditorID", auditorID);
                        db.Execute("_8DInsertAuditor", parameters, commandType: CommandType.StoredProcedure);
                    }
                }

                parameters = new DynamicParameters();
                parameters.Add("@AuditNo", audit.AuditNo);
                db.Execute("_8DDeleteAuditTypes", parameters, commandType: CommandType.StoredProcedure);
                List<int> auditTypes = audit.AuditTypeIDs;
                if (auditTypes != null) {
                    foreach (int auditTypeID in auditTypes) {
                        parameters = new DynamicParameters();
                        parameters.Add("@AuditNo", audit.AuditNo);
                        parameters.Add("@AuditTypeID", auditTypeID);
                        db.Execute("_8DInsertAuditType", parameters, commandType: CommandType.StoredProcedure);
                    }
                }

                parameters = new DynamicParameters();
                parameters.Add("@AuditNo", audit.AuditNo);
                db.Execute("_8DDeleteAuditedAreas", parameters, commandType: CommandType.StoredProcedure);
                List<int> auditedAreas = audit.AuditedAreaIDs;
                if (auditedAreas != null) {
                    foreach (int auditedAreaID in auditedAreas) {
                        parameters = new DynamicParameters();
                        parameters.Add("@AuditNo", audit.AuditNo);
                        parameters.Add("@AuditedAreaID", auditedAreaID);
                        db.Execute("_8DInsertAuditedArea", parameters, commandType: CommandType.StoredProcedure);
                    }
                }

                transaction.Complete();

            } catch (Exception ex) {
                transaction.Dispose();
                throw new Exception(ex.Message + " " + ex.InnerException);
            }
        }
        //FabApprovalSystemEntitiesAll auditDb = new FabApprovalSystemEntitiesAll();

        //List<int> auditedStandards = audit.AuditedStandardIDs;
        //if (auditedStandards != null)
        //{
        //    foreach (int auditedStandard in auditedStandards)
        //    {
        //        var auditStandardExists = (from a in auditDb.C_8DAuditedStandardByAudit where a.AuditNo == audit.AuditNo && a.AuditedStandardID == auditedStandard select a).ToList();
        //        if (auditStandardExists.Count() <= 0)
        //        {
        //            C_8DAuditedStandardByAudit standard = new C_8DAuditedStandardByAudit
        //            {
        //                AuditNo = audit.AuditNo,
        //                AuditedStandardID = auditedStandard
        //            };
        //            auditDb.C_8DAuditedStandardByAudit.Add(standard);
        //            auditDb.SaveChanges();
        //        }

        //    }
        //}

        //parameters = new DynamicParameters();
        //parameters.Add("AuditNo", audit.AuditNo);
        //this.db.Execute("_8DUpdateAuditScore", parameters, commandType: CommandType.StoredProcedure);
    }

    public IEnumerable<AuditReportAttachment> GetAuditReportAttachments(int auditNo) {
        DynamicParameters parameters = new();
        parameters.Add("@AuditNo", auditNo);
        List<AuditReportAttachment> data = db.Query<AuditReportAttachment>("_8DGetAuditReportAttachments", parameters, commandType: CommandType.StoredProcedure).ToList();
        return data;
    }

    public IEnumerable<AuditReportAttachment> GetCAFindingsItemAttachments(int caFindingsID) {
        DynamicParameters parameters = new();
        parameters.Add("@CAFindingsID", caFindingsID);
        List<AuditReportAttachment> data = db.Query<AuditReportAttachment>("_8DGetCAFindingsItemAttachments", parameters, commandType: CommandType.StoredProcedure).ToList();
        return data;
    }

    public IEnumerable<CAUserList> GetUserList() {
        DynamicParameters parameters = new();
        List<CAUserList> userList = db.Query<CAUserList>("_8DGetUserList", parameters, commandType: CommandType.StoredProcedure).ToList();
        return userList;
    }

    public AuditFindings GetAuditFindingsByID(int auditFindingsID) {
        DynamicParameters parameters = new();
        parameters.Add("@AuditFindingsID", auditFindingsID);
        var data = db.Query<AuditFindings>("SELECT * FROM _8DAuditFinding WHERE ID = @AuditFindingsID", parameters).SingleOrDefault();
        return data;
    }

    public IEnumerable<int> GetAuditFindingCategoryIdsByFindingId(int auditFindingsID) {
        DynamicParameters parameters = new();
        parameters.Add("@AuditFindingID", auditFindingsID);
        List<int> data = db.Query<int>("SELECT CategoryID FROM _8DAuditFindingCategoryByAuditFinding WHERE AuditFindingID = @AuditFindingID", parameters).ToList();
        return data;
    }

    public IEnumerable<AuditFindings> GetAuditFindingsList(int auditNo) {
        DynamicParameters parameters = new();
        parameters.Add("@AuditNo", auditNo);
        List<AuditFindings> data = db.Query<AuditFindings>("_8DGetAuditFindingsList", parameters, commandType: CommandType.StoredProcedure).ToList();
        return data;
    }

    public void DeleteAuditReportAttachment(int attachmentID) {
        DynamicParameters parameters = new();
        parameters.Add("@AttachmentID", attachmentID);
        db.Execute("_8DDeleteAuditReportAttachments", parameters, commandType: CommandType.StoredProcedure);
    }

    public void InsertAuditReportAttachment(AuditReportAttachment attach) {
        DynamicParameters parameters = new();
        parameters.Add("@AuditNo", attach.AuditNo);
        parameters.Add("@CAFindingsID", attach.CAFindingsID);
        parameters.Add("@UploadedByID", attach.UploadedByID);
        parameters.Add("@FileName", attach.FileName);
        parameters.Add("@FileGUID", attach.FileGUID);

        db.Execute("_8DInsertAuditReportAttachment", parameters, commandType: CommandType.StoredProcedure);
    }

    internal string GetAuditReportAttachmentFileName(string fileGUID) {
        DynamicParameters parameters = new();
        parameters.Add("@FileGUID", fileGUID);
        var fileName = db.Query<string>("_8DGetAuditReportAttachmentFileName", parameters, commandType: CommandType.StoredProcedure).Single();
        return fileName;
    }

    internal void InsertAuditFindingsItem(AuditFindings data) {
        DynamicParameters parameters = new();
        parameters.Add("@AuditNo", data.AuditNo);
        parameters.Add("@Findings", data.Findings);
        parameters.Add("@ViolatedClause", data.ViolatedClause);
        parameters.Add("@FindingType", data.FindingType);
        parameters.Add("@FindingCategories", data.FindingCategories);
        parameters.Add("@CANo", data.CANo);
        parameters.Add("@Title", data.Title);

        db.Execute("_8DInsertAuditFinding", parameters, commandType: CommandType.StoredProcedure);
    }

    internal void UpdateAuditFindingsItem(AuditFindings data) {
        DynamicParameters parameters = new();
        parameters.Add("@AuditFindingsID", data.ID);
        parameters.Add("@Findings", data.Findings);
        parameters.Add("@ViolatedClause", data.ViolatedClause);
        parameters.Add("@FindingType", data.FindingType);
        parameters.Add("@FindingCategories", data.FindingCategories);
        parameters.Add("@CANo", data.CANo);
        parameters.Add("@Title", data.Title);

        db.Execute("_8DUpdateAuditFinding", parameters, commandType: CommandType.StoredProcedure);
    }

    internal void DeleteAuditFindingsItem(int auditFindingsID) {
        DynamicParameters parameters = new();
        parameters.Add("@AuditFindingsID", auditFindingsID);

        db.Execute("_8DDeleteAuditFinding", parameters, commandType: CommandType.StoredProcedure);
    }

    internal List<AuditFindingCategory> GetAuditFindingCategories() {
        DynamicParameters parameters = new();
        return db.Query<AuditFindingCategory>("_8DGetAuditFindingCategories", commandType: CommandType.StoredProcedure).ToList();
    }

    public void ReleaseLockOnDocument(int userID, int issueID) {
        DynamicParameters parameters = new();
        parameters.Add("@AuditNo", issueID);
        parameters.Add("@UserID", userID);
        db.Execute("_8DReleaseLockOnAuditDocuments", parameters, commandType: CommandType.StoredProcedure);
    }

    public IEnumerable<CANoList> GetCorrectiveActionNoList() {
        DynamicParameters parameters = new();
        List<CANoList> dataList = db.Query<CANoList>("_8DGetCorrectiveActionNoList", parameters, commandType: CommandType.StoredProcedure).ToList();
        return dataList;
    }

    public List<int> Get8DQA() {
        List<int> users = new();
        DynamicParameters parameters = new();
        users = db.Query<int>("_8DGet8DQA", parameters, commandType: CommandType.StoredProcedure).ToList();
        return users;
    }

    public int GetOpenCACountByAuditNo(int auditNo) {
        int rowCount = 0;
        DynamicParameters parameters = new();
        parameters.Add("@AuditNo", auditNo);
        rowCount = db.Query<int>("_8DGetOpenCACountByAuditNo", parameters, commandType: CommandType.StoredProcedure).Single();
        return rowCount;
    }

    // CA Findings ====================================================================================================================================

    public void InsertCAFindings(CAFindings model) {
        DynamicParameters parameters = new();
        parameters.Add("@AuditNo", model.AuditNo);
        parameters.Add("@CAFinding", model.CAFinding);
        parameters.Add("@CorrectiveAction", model.CorrectiveAction);
        parameters.Add("@Result", model.Result);
        parameters.Add("@ResponsibilityOwnerID", model.ResponsibilityOwnerID);
        parameters.Add("@ECD", model.ECD);
        parameters.Add("@ImplementedDate", model.ImplementedDate);

        db.Execute("_8DInsertCAFindings", parameters, commandType: CommandType.StoredProcedure);
    }

    public void UpdateCAFindings(CAFindings model) {
        DynamicParameters parameters = new();
        parameters.Add("@CAFindingsID", model.ID);
        parameters.Add("@CAFinding", model.CAFinding);
        parameters.Add("@CorrectiveAction", model.CorrectiveAction);
        parameters.Add("@Result", model.Result);
        parameters.Add("@ResponsibilityOwnerID", model.ResponsibilityOwnerID);
        parameters.Add("@ECD", model.ECD);
        parameters.Add("@ImplementedDate", model.ImplementedDate);

        db.Execute("_8DUpdateCAFindings", parameters, commandType: CommandType.StoredProcedure);
    }

    public void DeleteCAFindingsItem(int caFindingsID) {
        DynamicParameters parameters = new();
        parameters.Add("@CAFindingsID", caFindingsID);

        db.Execute("_8DDeleteCAFindingsItem", parameters, commandType: CommandType.StoredProcedure);
    }

    public CAFindings GetCAFindingsItem(int caFindingsID) {
        CAFindings model = new();
        DynamicParameters parameters = new();
        parameters.Add("@CAFindingsID", caFindingsID);
        var data = db.Query<CAFindings>("_8DGetCAFindings", parameters, commandType: CommandType.StoredProcedure).Single();
        return data;
    }

    public IEnumerable<CAFindings> GetCAFindingsList(int auditNo) {
        DynamicParameters parameters = new();
        parameters.Add("@AuditNo", auditNo);
        List<CAFindings> dataList = db.Query<CAFindings>("_8DGetCAFindingsList", parameters, commandType: CommandType.StoredProcedure).ToList();
        return dataList;
    }

    public int IsCAAssignedToAudit(int CANo, int auditNo) {
        DynamicParameters parameters = new();
        int returnValue = 1;
        parameters.Add("@CANo", CANo);
        parameters.Add("@AuditNo", auditNo);
        parameters.Add("@IsCAAssignedToAudit", returnValue, direction: ParameterDirection.Output);

        db.Execute("_8DIsCAAssignedtoAudit", parameters, commandType: CommandType.StoredProcedure);

        returnValue = parameters.Get<int>("IsCAAssignedToAudit");
        return returnValue;
    }

    public AuditEdit GetAuditEdit(int issueID, Audit audit, bool isAdmin, int userId) {
        AuditEdit result = new();
        List<int> userList = Get8DQA();
        result.MesaUsers = UserUtilities.GetMesaUsers();
        int QAs = userList.Find(delegate (int al) { return al == userId; });
        result.Is8DQA = "false";
        if (QAs != 0) {
            result.Is8DQA = "true";
        }

        audit = GetAuditItem(issueID, userId);
        //transform audit users from string to list, delimited by a comma.
        if (audit.Auditees == null) {
            result.AuditeeNames = new List<string>();
        } else {
            string[] auditeeNames = audit.Auditees.Split(',');
            result.AuditeeNames = auditeeNames.ToList();
        }

        result.IsSubmitter = false;
        if (audit.OriginatorID == userId) {
            result.IsSubmitter = true;
        }
        if (isAdmin != true) {
            result.IsAdmin = false;
        } else {
            result.IsAdmin = true;
        }
        if ((audit.RecordLockIndicator && audit.RecordLockedBy != userId)
            || audit.AuditStatus != 0) //open
        {
            result.RedirectToAction = true;
        }
        if (result.IsAdmin == false && result.IsSubmitter == false) {
            result.RedirectToAction = true;
        } else {
            result.UserList = GetUserList();
            result.AuditTypeList = GetAuditTypeList();
            // result.AuditStandardList = GetAuditStandardList();
            result.AuditorList = GetAuditorList();
            result.AuditAreaList = GetAuditAreaList();
            result.AuditFindingCategoryList = GetAuditFindingCategories();
            result.CANoList = GetCorrectiveActionNoList();
        }
        return result;
    }

    public List<string> GetFileNameAndDocument(string fileGuid, int auditNo) {
        List<string> results = new();
        string fileName = GetAuditReportAttachmentFileName(fileGuid);
        string fileExtension = fileName.Substring(fileName.LastIndexOf("."), fileName.Length - fileName.LastIndexOf("."));

        string ecnFolderPath = _AppSettings.AttachmentFolder + "Audit\\" + auditNo.ToString();
        string sDocument = Path.Combine(ecnFolderPath, fileGuid + fileExtension);

        string FDir_AppData = _AppSettings.AttachmentFolder;
        if (!sDocument.StartsWith(FDir_AppData)) {
            sDocument = string.Empty;
        }
        results.Add(fileName);
        results.Add(sDocument);
        return results;
    }

    public Audit InsertAndGetAudit(CorrectiveActionDMO caDMO, AuditFindings data, int userID) {
        Audit audit = new();
        InsertAuditFindingsItem(data);
        audit = GetAuditItem(data.AuditNo, userID);

        //Transfer Finding Details to CA
        if (data.CANo != 0) {
            CorrectiveAction ca = caDMO.GetCAItem(data.CANo, userID);
            ca.CATitle = data.Title;
            ca.CASourceID = 1;//Audit
            caDMO.UpdateCorrectiveAction(ca);
        }

        return audit;
    }

    public Audit UpdateAndGetAudit(CorrectiveActionDMO caDMO, AuditFindings data, int userID) {
        Audit audit = new();
        UpdateAuditFindingsItem(data);
        audit = GetAuditItem(data.AuditNo, userID);

        //Transfer Finding Details to CA
        if (data.CANo != 0) {
            CorrectiveAction ca = caDMO.GetCAItem(data.CANo, userID);
            ca.CATitle = data.Title;
            ca.CASourceID = 1;//Audit
            caDMO.UpdateCorrectiveAction(ca);
        }

        return audit;
    }

    public Audit DeleteAndGetAudit(int auditFindingsID, int userID) {
        var af = GetAuditFindingsByID(auditFindingsID);
        DeleteAuditFindingsItem(auditFindingsID);
        var audit = GetAuditItem(af.AuditNo, userID);
        return audit;
    }

    public void AuditReportAttachSave(int auditNo, int userId, string fullFileName, Stream stream) {
        // Some browsers send file names with full path.
        // We are only interested in the file name.

        var fileName = Path.GetFileName(fullFileName);
        var fileExtension = Path.GetExtension(fullFileName);
        //var physicalPath = Path.Combine(Server.MapPath("~/UserUploads"), fileName);       
        DirectoryInfo di;
        var ccPhysicalPath = _AppSettings.AttachmentFolder + @"Audit\" + auditNo;
        di = new DirectoryInfo(ccPhysicalPath);
        if (!di.Exists)
            di.Create();

        var guid = Guid.NewGuid().ToString();
        var physicalPath = Path.Combine(_AppSettings.AttachmentFolder + @"Audit\" + auditNo + @"\", guid + fileExtension);

        using (FileStream fileStream = new(physicalPath, FileMode.Create, FileAccess.Write)) {
            stream.CopyTo(fileStream);
        }
        AuditReportAttachment attach = new() {
            AuditNo = auditNo,
            FileGUID = guid,
            FileName = fileName,
            UploadedByID = userId

        };

        //ccDMO.InsertCCAttachment(attach);
        InsertAuditReportAttachment(attach);
    }

    public void SaveAndInsert(int caFindingsID, int auditNo, int userId, string fullFileName, Stream stream) {
        // Some browsers send file names with full path.
        // We are only interested in the file name.

        var fileName = Path.GetFileName(fullFileName);
        var fileExtension = Path.GetExtension(fullFileName);
        //var physicalPath = Path.Combine(Server.MapPath("~/UserUploads"), fileName);       
        DirectoryInfo di;
        var ccPhysicalPath = _AppSettings.AttachmentFolder + @"Audit\" + auditNo;
        di = new DirectoryInfo(ccPhysicalPath);
        if (!di.Exists)
            di.Create();

        var guid = Guid.NewGuid().ToString();
        var physicalPath = Path.Combine(_AppSettings.AttachmentFolder + @"Audit\" + auditNo + @"\", guid + fileExtension);

        using (FileStream fileStream = new(physicalPath, FileMode.Create, FileAccess.Write)) {
            stream.CopyTo(fileStream);
        }
        AuditReportAttachment attach = new() {
            CAFindingsID = caFindingsID,
            AuditNo = auditNo,
            FileGUID = guid,
            FileName = fileName,
            UploadedByID = userId

        };

        InsertAuditReportAttachment(attach);
    }

    public string NotifyActionItemOwner(int issueID, DateTime? dueDate, int? responsibleOwnerID, string emailTemplatesPath) {
        string emailSentList = "";

        //List<string> emailIst = ldDMO.GetApproverEmailList(@issueID, currentStep).Distinct().ToList();
        string email = MiscDMO.GetEmail(responsibleOwnerID);

        string emailTemplate = "CorrectiveActionFindingAssigned.txt";
        string userEmail = string.Empty;
        string subject = "5s/CA Findings";
        string senderName = "CorrectiveAction";

        EmailNotification en = new(_AppSettings, subject, emailTemplatesPath);
        string[] emailparams = new string[5];
        emailparams[0] = Functions.ReturnAuditNoStringFormat(issueID);
        if (dueDate is null)
            emailparams[1] = string.Empty;
        else
            emailparams[1] = dueDate.Value.ToString();
        emailparams[2] = Functions.DocumentTypeMapper(GlobalVars.DocumentType.Audit);
        emailparams[3] = GlobalVars.hostURL;
        emailparams[4] = issueID.ToString();
        userEmail = email;

        en.SendNotificationEmail(emailTemplate, GlobalVars.SENDER_EMAIL, senderName, userEmail, null, subject, emailparams);
        emailSentList += email + ",";
        return email;
    }

}