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;

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.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);

        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);
            }
        }
        return audit;
    }

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

        DynamicParameters parameters = new();
        parameters.Add("@AuditNo", value: auditNo);
        parameters.Add("@UserID", userID);

        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("AuditDate", audit.AuditDate);
                parameters.Add("AuditStatus", audit.AuditStatus);
                parameters.Add("AuditScore", audit.AuditScore);
                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);
            }
        }
    }

    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";
        }

        // 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) {
            result.IsAdmin = false;
        } else {
            result.IsAdmin = true;
        }
        if ((audit.RecordLockIndicator && audit.RecordLockedBy != userId)
            || audit.AuditStatus != 0) // open
        {
            result.RedirectToAction = true;
        }
        if (!result.IsAdmin && !result.IsSubmitter) {
            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 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 string NotifyActionItemOwner(int issueID, DateTime? dueDate, int? responsibleOwnerID, string emailTemplatesPath) {
        string emailSentList = "";

        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;
    }

}