using FrameworkDAL.CustomCode.ActionPanel;
using FrameworkDAL.DTO.ActionPanel;
using GB5Shared.DTO.Framework.AutoNumber;
using GB5Shared.DTO.Framework.Criteria;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.EventLogPublish;
using GB5Shared.GenerateAutoNumber;
using GB5Shared.Resource.Response;
using GB5Shared.Telemetry;
using GB5Shared.Validation;
using static GB5Shared.GB5Constant.Constant;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using System;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace FrameworkBLL.ActionPanel
{
    public class ActionPanelBLL : IActionPanelBLL
    {
        private readonly IActionPanelDAL _actionPanelDAL;
        private readonly AutoNumber _autoNumber;
        private readonly IValidation _validation;
        private readonly EventLogPublish _eventLog;
        private readonly ILogger<ActionPanelBLL> _logger;

        public ActionPanelBLL(
            IActionPanelDAL actionPanelDAL,
            AutoNumber autoNumber,
            IValidation validation,
            EventLogPublish eventLog,
            ILogger<ActionPanelBLL> logger)
        {
            _actionPanelDAL = actionPanelDAL;
            _autoNumber = autoNumber;
            _validation = validation;
            _eventLog = eventLog;
            _logger = logger;
        }

        public async Task<string> GetActionPanel(int actionPanelId, LoginDTO loginDTO, CancellationToken ct)
        {
            try
            {
                var dto = await _actionPanelDAL.GetActionPanel(actionPanelId, loginDTO, ct).ConfigureAwait(false);
                return JsonConvert.SerializeObject(dto);
            }
            catch (Exception ex)
            {
                GB5Trace.MarkFailed("get-actionpanel-failed", ex);
                _logger.LogError(ex, "GetActionPanel failed for ActionPanelId {ActionPanelId}", actionPanelId);
                throw;
            }
        }

        public async Task<string> SaveActionPanel(ActionPanelDTO actionPanelDTO, LoginDTO loginDTO, CancellationToken ct)
        {
            if (actionPanelDTO == null)
                throw new ArgumentNullException(nameof(actionPanelDTO));

            AutoNumberDTO autoNumberDTO = null;

            try
            {
                GB5Trace.Step("validate-actionpanel", new { actionPanelDTO.ActionPanelId });
                await _validation.NotEmpty(actionPanelDTO.Label, nameof(actionPanelDTO.Label));

                actionPanelDTO.TenantId = loginDTO.ClientId;
                actionPanelDTO.ModifiedById = loginDTO.UserId;
                actionPanelDTO.ModifiedOn = DateTime.UtcNow;

                bool isNew = actionPanelDTO.ActionPanelId == 0;

                GB5Trace.Step("save-actionpanel", new { actionPanelDTO.ActionPanelId, isNew });

                if (isNew)
                {
                    autoNumberDTO = await _autoNumber.GetAutoNumber(1, "ActionPanel", loginDTO).ConfigureAwait(false);
                    actionPanelDTO.ActionPanelId = autoNumberDTO.StartNumber;
                    actionPanelDTO.CreatedById = loginDTO.UserId;
                    actionPanelDTO.CreatedOn = DateTime.UtcNow;

                    await _actionPanelDAL.SaveActionPanel(actionPanelDTO, loginDTO, ct).ConfigureAwait(false);
                }
                else
                {
                    await _actionPanelDAL.UpdateActionPanel(actionPanelDTO, loginDTO, ct).ConfigureAwait(false);
                }

                int eventTypeId = WebServiceConstant.FRAMEWORKACTIONPANELSAVE;
                GB5Trace.Step("event-publish", new { EventTypeId = eventTypeId });
                try
                {
                    await _eventLog.PublishEventLogAsync(
                        isNew ? "ActionPanel Created" : "ActionPanel Updated",
                        actionPanelDTO,
                        eventTypeId,
                        actionPanelDTO.ActionPanelId,
                        loginDTO,
                        ct: ct).ConfigureAwait(false);
                }
                catch (Exception ex)
                {
                    _logger.LogWarning(ex, "Event publish failed for ActionPanelId {ActionPanelId}", actionPanelDTO.ActionPanelId);
                }

                return isNew
                    ? $"{SuccessResponse.SaveSuccessMessage} {actionPanelDTO.ActionPanelId}"
                    : $"{SuccessResponse.UpdateSuccessMessage} {actionPanelDTO.ActionPanelId}";
            }
            catch (ValidationException vex)
            {
                GB5Trace.MarkFailed("save-actionpanel-validation-failed", vex);
                throw new Exception(vex.Message);
            }
            catch (Exception ex)
            {
                GB5Trace.MarkFailed("save-actionpanel-failed", ex);
                _logger.LogError(ex, "SaveActionPanel failed for ActionPanelId {ActionPanelId}", actionPanelDTO.ActionPanelId);

                if (autoNumberDTO != null && actionPanelDTO.ActionPanelId > 0)
                {
                    await _autoNumber.RollbackAutoNumber("ActionPanel", actionPanelDTO.ActionPanelId, loginDTO).ConfigureAwait(false);
                }

                throw;
            }
        }

        public async Task<string> GetSelectListActionPanel(int firstNumber, int maxResult, CriteriaDTO criteriaDTO, LoginDTO loginDTO, CancellationToken ct)
        {
            try
            {
                return await _actionPanelDAL.GetSelectListActionPanel(firstNumber, maxResult, criteriaDTO, loginDTO, isCount: false, ct).ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                GB5Trace.MarkFailed("get-selectlist-actionpanel-failed", ex);
                _logger.LogError(ex, "GetSelectListActionPanel failed");
                throw;
            }
        }

        public async Task<int> DeleteActionPanel(int actionPanelId, LoginDTO loginDTO, CancellationToken ct)
        {
            try
            {
                GB5Trace.Step("delete-actionpanel", new { actionPanelId });
                int rows = await _actionPanelDAL.DeleteActionPanel(actionPanelId, loginDTO, ct).ConfigureAwait(false);

                int eventTypeId = WebServiceConstant.FRAMEWORKACTIONPANELDELETE;
                GB5Trace.Step("event-publish", new { EventTypeId = eventTypeId });
                try
                {
                    await _eventLog.PublishEventLogAsync(
                        "ActionPanel Deleted", new { ActionPanelId = actionPanelId },
                        eventTypeId, actionPanelId, loginDTO, ct: ct).ConfigureAwait(false);
                }
                catch (Exception ex)
                {
                    _logger.LogWarning(ex, "Event publish failed for deleted ActionPanelId {ActionPanelId}", actionPanelId);
                }

                return rows;
            }
            catch (Exception ex)
            {
                GB5Trace.MarkFailed("delete-actionpanel-failed", ex);
                _logger.LogError(ex, "DeleteActionPanel failed for ActionPanelId {ActionPanelId}", actionPanelId);
                throw;
            }
        }

        public async Task<string> GetActionsForScreen(int menuId, string channel, LoginDTO loginDTO, CancellationToken ct)
        {
            try
            {
                GB5Trace.Step("get-actions-for-screen", new { menuId, channel });

                var actionsTask = _actionPanelDAL.GetActionsForScreen(menuId, channel, loginDTO, ct);
                var quickActionsTask = _actionPanelDAL.GetQuickActionsForScreen(menuId, loginDTO, ct);
                await Task.WhenAll(actionsTask, quickActionsTask).ConfigureAwait(false);

                var result = new
                {
                    Actions = actionsTask.Result.ToList(),
                    QuickActions = quickActionsTask.Result.Select(qa => new
                    {
                        qa.ActionCode,
                        qa.Label,
                        Fields = JsonConvert.DeserializeObject(qa.FieldsJson ?? "[]"),
                        qa.Api,
                        qa.VisibleWhen
                    }).ToList()
                };

                return JsonConvert.SerializeObject(result);
            }
            catch (Exception ex)
            {
                GB5Trace.MarkFailed("get-actions-for-screen-failed", ex);
                _logger.LogError(ex, "GetActionsForScreen failed for MenuId {MenuId}", menuId);
                throw;
            }
        }

        public async Task<string> GetAllActionPanel(LoginDTO loginDTO, CancellationToken ct)
        {
            try
            {
                return await _actionPanelDAL.GetAllActionPanel(loginDTO, ct).ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                GB5Trace.MarkFailed("get-all-actionpanel-failed", ex);
                _logger.LogError(ex, "GetAllActionPanel failed");
                throw;
            }
        }

        public async Task<string> GetQuickAction(int quickActionId, LoginDTO loginDTO, CancellationToken ct)
        {
            try
            {
                var dto = await _actionPanelDAL.GetQuickAction(quickActionId, loginDTO, ct).ConfigureAwait(false);
                return JsonConvert.SerializeObject(dto);
            }
            catch (Exception ex)
            {
                GB5Trace.MarkFailed("get-quickaction-failed", ex);
                _logger.LogError(ex, "GetQuickAction failed for QuickActionId {QuickActionId}", quickActionId);
                throw;
            }
        }

        public async Task<string> SaveQuickAction(QuickActionDTO quickActionDTO, LoginDTO loginDTO, CancellationToken ct)
        {
            if (quickActionDTO == null)
                throw new ArgumentNullException(nameof(quickActionDTO));

            AutoNumberDTO autoNumberDTO = null;

            try
            {
                GB5Trace.Step("validate-quickaction", new { quickActionDTO.QuickActionId });
                await _validation.NotEmpty(quickActionDTO.Label, nameof(quickActionDTO.Label));
                await _validation.NotEmpty(quickActionDTO.ActionCode, nameof(quickActionDTO.ActionCode));
                await _validation.NotEmpty(quickActionDTO.Api, nameof(quickActionDTO.Api));

                quickActionDTO.TenantId = loginDTO.ClientId;
                quickActionDTO.ModifiedById = loginDTO.UserId;
                quickActionDTO.ModifiedOn = DateTime.UtcNow;

                bool isNew = quickActionDTO.QuickActionId == 0;

                GB5Trace.Step("save-quickaction", new { quickActionDTO.QuickActionId, isNew });

                if (isNew)
                {
                    autoNumberDTO = await _autoNumber.GetAutoNumber(1, "QuickAction", loginDTO).ConfigureAwait(false);
                    quickActionDTO.QuickActionId = autoNumberDTO.StartNumber;
                    quickActionDTO.CreatedById = loginDTO.UserId;
                    quickActionDTO.CreatedOn = DateTime.UtcNow;

                    await _actionPanelDAL.SaveQuickAction(quickActionDTO, loginDTO, ct).ConfigureAwait(false);
                }
                else
                {
                    await _actionPanelDAL.UpdateQuickAction(quickActionDTO, loginDTO, ct).ConfigureAwait(false);
                }

                int eventTypeId = WebServiceConstant.FRAMEWORKQUICKACTIONSAVE;
                GB5Trace.Step("event-publish", new { EventTypeId = eventTypeId });
                try
                {
                    await _eventLog.PublishEventLogAsync(
                        isNew ? "QuickAction Created" : "QuickAction Updated",
                        quickActionDTO,
                        eventTypeId,
                        quickActionDTO.QuickActionId,
                        loginDTO,
                        ct: ct).ConfigureAwait(false);
                }
                catch (Exception ex)
                {
                    _logger.LogWarning(ex, "Event publish failed for QuickActionId {QuickActionId}", quickActionDTO.QuickActionId);
                }

                return isNew
                    ? $"{SuccessResponse.SaveSuccessMessage} {quickActionDTO.QuickActionId}"
                    : $"{SuccessResponse.UpdateSuccessMessage} {quickActionDTO.QuickActionId}";
            }
            catch (ValidationException vex)
            {
                GB5Trace.MarkFailed("save-quickaction-validation-failed", vex);
                throw new Exception(vex.Message);
            }
            catch (Exception ex)
            {
                GB5Trace.MarkFailed("save-quickaction-failed", ex);
                _logger.LogError(ex, "SaveQuickAction failed for QuickActionId {QuickActionId}", quickActionDTO.QuickActionId);

                if (autoNumberDTO != null && quickActionDTO.QuickActionId > 0)
                {
                    await _autoNumber.RollbackAutoNumber("QuickAction", quickActionDTO.QuickActionId, loginDTO).ConfigureAwait(false);
                }

                throw;
            }
        }

        public async Task<int> DeleteQuickAction(int quickActionId, LoginDTO loginDTO, CancellationToken ct)
        {
            try
            {
                GB5Trace.Step("delete-quickaction", new { quickActionId });
                int rows = await _actionPanelDAL.DeleteQuickAction(quickActionId, loginDTO, ct).ConfigureAwait(false);

                int eventTypeId = WebServiceConstant.FRAMEWORKQUICKACTIONDELETE;
                GB5Trace.Step("event-publish", new { EventTypeId = eventTypeId });
                try
                {
                    await _eventLog.PublishEventLogAsync(
                        "QuickAction Deleted", new { QuickActionId = quickActionId },
                        eventTypeId, quickActionId, loginDTO, ct: ct).ConfigureAwait(false);
                }
                catch (Exception ex)
                {
                    _logger.LogWarning(ex, "Event publish failed for deleted QuickActionId {QuickActionId}", quickActionId);
                }

                return rows;
            }
            catch (Exception ex)
            {
                GB5Trace.MarkFailed("delete-quickaction-failed", ex);
                _logger.LogError(ex, "DeleteQuickAction failed for QuickActionId {QuickActionId}", quickActionId);
                throw;
            }
        }

        public async Task<string> GetAllQuickAction(LoginDTO loginDTO, CancellationToken ct)
        {
            try
            {
                return await _actionPanelDAL.GetAllQuickAction(loginDTO, ct).ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                GB5Trace.MarkFailed("get-all-quickaction-failed", ex);
                _logger.LogError(ex, "GetAllQuickAction failed");
                throw;
            }
        }
    }
}