using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using LCU.Library.Internal.DispatcherModels.Models;
using LCU.Library.Internal.DispatcherModels.Entities;
using LCU.Api.Internal.DispatcherLib.Persistence;
using LCU.Api.Internal.DispatcherLib.Extensions.Queryables;
using LCU.Api.Internal.DispatcherLib.Extensions.Enumerables;
using LCU.Library.Internal.DispatcherModels.Models.Results;
using LCU.Library.Internal.DispatcherModels.Enums;
namespace LCU.Api.Internal.DispatcherLib.Repositories;

public class JobRepository : BaseRepository, IJobRepository
{
    public JobRepository(AppDbContext context) : base(context) { }

    public async Task<PagedResult<Job>> FilteredListAsync(Filter filter,
                                                          int numberOfWorkItemExecutions,
                                                          int numberOfExecutionMessages)
    {
        var results = new PagedResult<Job>();
        var skip = (filter.Page - 1) * filter.Limit;

        results.Total = await _context.Jobs.Where(job => job.SoftDeleteDate == null)
                                      .IncludeAll(numberOfWorkItemExecutions, numberOfExecutionMessages)
                                      .FilterJobName(filter)
                                      .FilterJobDescription(filter)
                                      .FilterNextRunTimeGreaterThanDate(filter)
                                      .FilterOnTagId(filter)
                                      .FilterByStatusType(filter)
                                      .AsNoTracking()
                                      .CountAsync();

        //Queryable
        var jobs = await _context.Jobs.Where(job => job.SoftDeleteDate == null)
                                      .IncludeAll(numberOfWorkItemExecutions, numberOfExecutionMessages)
                                      .FilterJobName(filter)
                                      .FilterJobDescription(filter)
                                      .FilterNextRunTimeGreaterThanDate(filter)
                                      .FilterOnTagId(filter)
                                      .FilterByStatusType(filter)
                                      .OrderBySortableFields(filter)
                                      .AsNoTracking()
                                      .ToListAsync();

        results.Items = jobs.Skip(skip).Take(filter.Limit);

        return results;
    }

    public async Task<IEnumerable<Job>> ListAsync(int numberOfWorkItemExecutions, int numberOfExecutionMessages)
    {
        return await _context.Jobs.IncludeAll(numberOfWorkItemExecutions, numberOfExecutionMessages)
                                    .AsNoTracking()
                                    .ToListAsync();
    }

    public async Task<IEnumerable<Job>> ListInactiveAsync(int numberOfWorkItemExecutions, int numberOfExecutionMessages)
    {
        return await _context.Jobs.Where(job => string.IsNullOrWhiteSpace(job.CronSchedule) && job.NextRunTime == null)
                                    .IncludeAll(numberOfWorkItemExecutions, numberOfExecutionMessages)
                                    .AsNoTracking()
                                    .ToListAsync();
    }

    public async Task<IEnumerable<Job>> ListInactiveExcludeSoftDeletedTrackedAsync(int numberOfWorkItemExecutions, int numberOfExecutionMessages)
    {
        return await _context.Jobs.Where(job => string.IsNullOrWhiteSpace(job.CronSchedule) && job.NextRunTime == null && job.SoftDeleteDate == null)
                                    .IncludeAll(numberOfWorkItemExecutions, numberOfExecutionMessages)
                                    .ToListAsync();
    }

    public async Task<IEnumerable<Job>> ListSoftDeletedTrackedAsync(int numberOfWorkItemExecutions, int numberOfExecutionMessages, DateTime cutOffDate)
    {
        return await _context.Jobs.Where(job => job.SoftDeleteDate != null && cutOffDate > job.SoftDeleteDate)
                                    .IncludeAll(numberOfWorkItemExecutions, numberOfExecutionMessages)
                                    .ToListAsync();
    }

    public async Task<Job> FindByIdAsync(int id, int numberOfWorkItemExecutions, int numberOfExecutionMessages)
    {
        return await _context.Jobs.Where(job => job.JobId == id)
                                  .IncludeAll(numberOfWorkItemExecutions, numberOfExecutionMessages)
                                  .AsNoTracking()
                                  .FirstOrDefaultAsync();
    }

    public async Task<Job> FindByIdExcludingWorkItemsAsync(int id)
    {
        return await _context.Jobs.Where(job => job.JobId == id)
                                  .AsNoTracking()
                                  .FirstOrDefaultAsync();
    }

    public async Task<Job> FindByWorkItemIdAsync(int workItemId, int numberOfWorkItemExecutions, int numberOfExecutionMessages)
    {
        return await _context.Jobs.Where(job => job.WorkItems.Any(workItem => workItem.WorkItemId == workItemId))
                                  .IncludeAll(numberOfWorkItemExecutions, numberOfExecutionMessages)
                                  .AsNoTracking()
                                  .FirstOrDefaultAsync();
    }

    public async Task<Job> FindByWorkItemIdExcludingWorkItemsAsync(int workItemId)
	{
		return await _context.Jobs.Where(job => job.WorkItems.Any(workItem => workItem.WorkItemId == workItemId))
                                    .AsNoTracking()
                                    .FirstOrDefaultAsync();
	}

    public async Task<Job> FindByWorkItemIdExcludingWorkItemsIncludeErrorRecipientsAsync(int workItemId)
    {
        return await _context.Jobs.Where(job => job.WorkItems.Any(workItem => workItem.WorkItemId == workItemId))
                                    .IncludeErrorRecipients()
                                    .AsNoTracking()
                                    .FirstOrDefaultAsync();
    }

    public async Task<IEnumerable<Job>> FindJobsPastDateByStatuses(DateTime date,
                                                         int numberOfWorkItemExecutions,
                                                         int numberOfExecutionMessages,
                                                         List<JobStatus> jobStatuses)
    {
        return await _context.Jobs.Where(job => date > job.NextRunTime && (jobStatuses.Contains(job.JobStatus) || job.JobStatus == JobStatus.Failed))
                                  .IncludeAll(numberOfWorkItemExecutions, numberOfExecutionMessages)
                                  .AsNoTracking()
                                  .ToListAsync();
    }

    public async Task<IEnumerable<Job>> FindJobsReadyToBeScheduled(DateTime date)
    {
        var jobs = await _context.Jobs.Where(job => (job.JobStatus == JobStatus.ReadyToSchedule && job.NextRunTime < date))
                                        .AsNoTracking()
                                        .ToListAsync();
        return jobs;
    }

    public async Task<Job> AddAsync(Job job)
    {
        var result = await _context.Jobs.AddAsync(job);
        return result.Entity;
    }

    public async Task<Job> Update(Job job)
    {
        var trackedJob = await _context.Jobs
        .IncludeErrorRecipients()
        .FirstAsync(j => j.JobId == job.JobId);

        _context.Entry(trackedJob).CurrentValues.SetValues(job);

        return trackedJob;
    }

    public void Remove(Job job)
    {
        _context.Jobs.Remove(job);
    }
}