using System;
using System.Threading.Tasks;
using F4SD.ActionConnector.Enumerations;
using F4SD.ActionConnector.Models;
using static C4IT.Logging.cLogManager;

namespace F4SD.ActionConnector.Execution
{
    /// <summary>
    /// Routes a single action definition to the correct executor based on its <see cref="ActionType"/>.
    /// </summary>
    internal sealed class ActionDispatcher
    {
        private readonly Func<QuickActionRequest, Task<ActionResult>> _quickActionExecutor;

        internal ActionDispatcher(Func<QuickActionRequest, Task<ActionResult>> quickActionExecutor)
        {
            _quickActionExecutor = quickActionExecutor;
        }

        internal async Task<ActionResult> DispatchAsync(ActionDefinitionBase action, ActionContext context)
        {
            if (!action.IsEnabled)
                return ActionResult.Skip(action.Id);

            switch (action.Type)
            {
                case ActionType.QuickAction:
                    return await ExecuteQuickActionAsync((QuickActionDefinition)action, context);

                case ActionType.HttpCall:
                case ActionType.Webhook:
                    throw new NotImplementedException(
                        $"ActionType '{action.Type}' is not yet implemented.");

                default:
                    LogEntry($"ActionDispatcher: unknown ActionType '{action.Type}' for action '{action.Id}'.",
                        C4IT.Logging.LogLevels.Warning);
                    return ActionResult.Skip(action.Id);
            }
        }

        private async Task<ActionResult> ExecuteQuickActionAsync(QuickActionDefinition definition, ActionContext context)
        {
            if (_quickActionExecutor == null)
                throw new InvalidOperationException(
                    $"A QuickAction ('{definition.Id}') was triggered but no {nameof(Bus.ActionBusOptions.QuickActionExecutor)} was registered.");

            var resolvedParameters = PayloadVariableResolver.Resolve(definition.Parameters, context.Payload);

            var request = new QuickActionRequest
            {
                ActionId = definition.Id,
                QuickActionRef = definition.QuickActionRef,
                Parameters = resolvedParameters,
                Context = context,
            };

            return await _quickActionExecutor(request);
        }
    }
}