using Caspian.WorkflowFramework.Models;
using Caspian.WorkflowFramework.Contracts;
using Newtonsoft.Json;
using Elsa.Workflows.Runtime;
using Microsoft.Extensions.DependencyInjection;
using Elsa.Workflows.Management;
using Elsa.Workflows.Management.Filters;
using Elsa.Workflows.Runtime.Messages;
using Elsa.Workflows.Models;
using Elsa.Common.Models;
using Caspian.WorkflowFramework.Utility;
using MongoLogger;
using System.Diagnostics;

namespace Caspian.WorkflowFramework.Services
{
    public class WorkflowService : IWorkflowService, ILoggable
    {
        #region Fields
        private readonly IServiceProvider _serviceProvider;
        private readonly IWorkflowRuntime _workflowRuntime;
        private readonly IWorkflowDefinitionService _workflowDefinitionService;
        private readonly IWorkflowInstanceVariableManager _workflowInstanceVariableManager;
        private readonly IWorkflowInstanceManager _workflowInstanceManager;
        private readonly IEventPublisher _eventPublisher;
        private readonly IMdbLogger<WorkflowService> _logger;
        #endregion

        #region Ctor
        public WorkflowService(IServiceProvider serviceProvider,
            IMdbLogger<WorkflowService> logger)
        {
            _serviceProvider = serviceProvider;
            _workflowRuntime = _serviceProvider.GetRequiredService<IWorkflowRuntime>();
            _workflowDefinitionService = _serviceProvider.GetRequiredService<IWorkflowDefinitionService>();
            _workflowInstanceVariableManager = _serviceProvider.GetRequiredService<IWorkflowInstanceVariableManager>();
            _workflowInstanceManager = _serviceProvider.GetRequiredService<IWorkflowInstanceManager>();
            _eventPublisher = _serviceProvider.GetRequiredService<IEventPublisher>();
            _logger = logger;
        }
        #endregion

        #region CreateAndExecuteAsync
        /// <inheritdoc />
        public async Task<WorkflowResponse<WorkflowModel>> CreateAndExecuteAsync(CreateAndExecuteWorkflowModel input)
        {
            try
            {
                _logger.Log("Start of CreateAndExecuteAsync", JsonConvert.SerializeObject(input));

                WorkflowResponse<WorkflowModel> response;

                var workflowClient = await _workflowRuntime.CreateClientAsync();

                var definition = await _workflowDefinitionService
                    .FindWorkflowDefinitionAsync(new WorkflowDefinitionFilter()
                    {
                        Name = input.Name
                    });

                if (definition == null)
                {
                    var msg = $"Workflow '{input.Name}' defintion not found";
                    response = new WorkflowResponse<WorkflowModel>()
                    {
                        Status = 1,
                        Message = msg,
                        Data = null
                    };

                    _logger.Log("End of CreateAndExecuteAsync", WFInstanceId: response.Data?.InstanceId, JsonConvert.SerializeObject(response));

                    return response;
                }

                var instanceInput = new Dictionary<string, object> { ["UserId"] = input.UserId };
                input.Version = VersionOptions.Published;
                var newInstance = await workflowClient.CreateInstanceAsync(new CreateWorkflowInstanceRequest
                {
                    WorkflowDefinitionHandle = WorkflowDefinitionHandle.ByDefinitionId(definition.DefinitionId, input.Version),
                    Input = instanceInput,
                    ExternalUserId = input.UserId
                });

                var result = await workflowClient.RunInstanceAsync(RunWorkflowInstanceRequest.Empty);

                var variables = await _workflowInstanceVariableManager.GetVariablesAsync(result.WorkflowInstanceId);

                // تبدیل به دیکشنری
                var dictionary = variables.ToDictionary(a => a.Variable.Name, a => a.Value);

                var workflowModel = dictionary.ConvertToWorkflowModel();
                workflowModel.InstanceId = workflowClient.WorkflowInstanceId;
                workflowModel.UserId = input.UserId;

                response = new WorkflowResponse<WorkflowModel>()
                {
                    Status = 0,
                    Message = "Success",
                    Data = workflowModel
                };

                _logger.Log("End of CreateAndExecuteAsync", WFInstanceId: response.Data?.InstanceId, JsonConvert.SerializeObject(response));

                return response;
            }
            catch (Exception ex)
            {
                var response = new WorkflowResponse<WorkflowModel>()
                {
                    Status = 100,
                    Message = ex.Message,
                    Data = null
                };

                _logger.Log("Exception occurs in CreateAndExecuteAsync", WFInstanceId: response.Data?.InstanceId, JsonConvert.SerializeObject(response), ex);

                return response;
            }
        }
        #endregion

        #region PublishEventAsync
        /// <inheritdoc />
        public async Task<WorkflowResponse<WorkflowModel>> PublishEventAsync(PublishEventModel input)
        {
            try
            {
                _logger.Log("Start of PublishEventAsync", WFInstanceId: input.WorkflowInstanceId, JsonConvert.SerializeObject(input));

                WorkflowResponse<WorkflowModel> response;

                var instance = await _workflowInstanceManager.FindByIdAsync(input.WorkflowInstanceId);

                if (instance == null)
                {
                    var msg = $"Workflow instance with id '{input.WorkflowInstanceId}' not found";
                    response = new WorkflowResponse<WorkflowModel>()
                    {
                        Status = 1,
                        Message = msg,
                        Data = null
                    };

                    _logger.Log("End of PublishEventAsync", WFInstanceId: input.WorkflowInstanceId, JsonConvert.SerializeObject(response));

                    return response;
                }

                await _eventPublisher.PublishAsync(input.EventName, null, input.WorkflowInstanceId, null, input.EventData);

                var variables = await _workflowInstanceVariableManager.GetVariablesAsync(input.WorkflowInstanceId);

                // تبدیل به دیکشنری
                var dictionary = variables.ToDictionary(a => a.Variable.Name, a => a.Value);

                var workflowModel = dictionary.ConvertToWorkflowModel();
                workflowModel.InstanceId = instance.Id;
                workflowModel.UserId = instance.ExternalUserId;

                response = new WorkflowResponse<WorkflowModel>()
                {
                    Status = 0,
                    Message = "Success",
                    Data = workflowModel
                };

                _logger.Log("End of PublishEventAsync", WFInstanceId: input.WorkflowInstanceId, JsonConvert.SerializeObject(response));

                return response;
            }
            catch (Exception ex)
            {
                var response = new WorkflowResponse<WorkflowModel>()
                {
                    Status = 100,
                    Message = ex.Message,
                    Data = null
                };

                _logger.Log("Exception occurs in PublishEventAsync", WFInstanceId: input.WorkflowInstanceId, JsonConvert.SerializeObject(response), ex);

                return response;
            }
        }
        #endregion

        #region InquiryStateAsync
        /// <inheritdoc />
        public async Task<WorkflowResponse<WorkflowModel>> InquiryStateAsync(InquiryStateModel input)
        {
            try
            {
                _logger.Log("Start of InquiryStateAsync", WFInstanceId: input.WorkflowInstanceId, JsonConvert.SerializeObject(input));

                WorkflowResponse<WorkflowModel> response;

                var instance = await _workflowInstanceManager.FindByIdAsync(input.WorkflowInstanceId);

                if (instance == null)
                {
                    var msg = $"Workflow instance with id '{input.WorkflowInstanceId}' not found";
                    response = new WorkflowResponse<WorkflowModel>()
                    {
                        Status = 1,
                        Message = msg,
                        Data = null
                    };

                    _logger.Log("End of InquiryStateAsync", WFInstanceId: input.WorkflowInstanceId, JsonConvert.SerializeObject(response));

                    return response;
                }

                var variables = await _workflowInstanceVariableManager.GetVariablesAsync(input.WorkflowInstanceId);

                // تبدیل به دیکشنری
                var dictionary = variables.ToDictionary(a => a.Variable.Name, a => a.Value);

                var workflowModel = dictionary.ConvertToWorkflowModel();
                workflowModel.InstanceId = instance.Id;
                workflowModel.UserId = instance.ExternalUserId;

                response = new WorkflowResponse<WorkflowModel>()
                {
                    Status = 0,
                    Message = "Success",
                    Data = workflowModel
                };

                _logger.Log("End of InquiryStateAsync", WFInstanceId: input.WorkflowInstanceId, JsonConvert.SerializeObject(response));

                return response;
            }
            catch (Exception ex)
            {
                var response = new WorkflowResponse<WorkflowModel>()
                {
                    Status = 100,
                    Message = ex.Message,
                    Data = null
                };

                _logger.Log("Exception occurs in InquiryStateAsync", WFInstanceId: input.WorkflowInstanceId, JsonConvert.SerializeObject(response), ex);

                return response;
            }
        }
        #endregion
    }
}