using e_suite.API.Common;
using e_suite.API.Common.repository;
using e_suite.Database.Audit;
using e_suite.Database.Core.Extensions;
using e_suite.Database.Core.Tables.Activity;
using e_suite.Messaging.Common;
using e_suite.Utilities.Pagination;
using eSuite.Core.Miscellaneous;
using Microsoft.EntityFrameworkCore;
using System.Linq.Expressions;
using System.Runtime.CompilerServices;
using eSuite.Core.Enums;

namespace e_suite.Modules.RunningActivityManager;

public class ActivityManager : IActivityManager
{
    private readonly IActivityMessageSender _activityMessageSender;
    private readonly IActivityRepository _activityRepository;
    private readonly IWorkflowTemplateRepository _workflowTemplateRepository;

    public ActivityManager(IActivityMessageSender activityMessageSender, IActivityRepository activityRepository, IWorkflowTemplateRepository workflowTemplateRepository)
    {
        _activityMessageSender = activityMessageSender;
        _activityRepository = activityRepository;
        _workflowTemplateRepository = workflowTemplateRepository;
    }

    public async Task CreateActivity(
        AuditUserDetails auditUserDetails,
        CreateActivity template,
        CancellationToken cancellationToken
    )
    {
        GeneralIdRef? progressActivityRef = null;
        await _activityRepository.TransactionAsync(async () =>
        {
            var workflowTemplate = _workflowTemplateRepository.GetWorkflows().Include( x => x.Versions).FindByGeneralIdRef(template.WorkflowTemplateId);
            var workflowTemplateVersion = workflowTemplate!.Versions.OrderByDescending(x => x.Version).First();

            Activity activity = new Activity
            {
                Guid = Guid.NewGuid(),
                Name = template.ActivityName,
                WorkflowVersion = workflowTemplateVersion,
            };

            await _activityRepository.CreateActivityInstanceAsync(auditUserDetails, activity, cancellationToken);

            progressActivityRef = activity.ToGeneralIdRef();
        });

        if (progressActivityRef != null)
            _activityMessageSender.ProgressActivity(progressActivityRef);
    }

    public async Task<PaginatedData<GetMyAssignments>> GetMyActiveAssignmentsAsync(AuditUserDetails auditUserDetails, Paging paging, CancellationToken cancellationToken)
    {
        var myAssignments = _activityRepository.GetAssignments()
            .Where(x => 
                x.Deleted == false && 
                x.ActivityState == ActivityState.Active && 
                (x.UserId == auditUserDetails.UserId
                || x.Role.UserRoles.Any(u => u.UserId == auditUserDetails.UserId)));

        var paginatedData = await PaginatedData.Paginate<ActivityAssignment, GetMyAssignments>(myAssignments, paging,
            MyActiveAssignmentsKeySelector, cancellationToken);

        return paginatedData;
    }

    private Expression<Func<ActivityAssignment, object>> MyActiveAssignmentsKeySelector(string sortKey)
    {
        return sortKey?.ToLowerInvariant() switch
        {
            "id" => x => x.Id,
            "guid" => x => x.Guid,
            "taskname" => x => x.Task.TaskName,
            "startdatetime" => x => x.StartDateTime,
            _ => x => x.Id
        };
    }
}