monorepo/LCU.API.Internal.ArchiverApi/LCU.Api.Internal.ArchiverApi/Services/ReportService.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Linq;
using LCU.Library.Internal.ArchiverApiModel.Models;
using LCU.Library.Internal.ArchiverApiModel.Entities;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.ApplicationHistories;

namespace LCU.Api.Internal.ArchiverApi.Services;

public class ReportService : IReportService
{
    private readonly ICoreApiWrapperService _coreApiWrapperService;
    private readonly IApplicationMappingService _applicationMappingService;
    private readonly IRegexMappingService _regexMappingService;

    public ReportService(ICoreApiWrapperService coreApiWrapperService,
                         IApplicationMappingService applicationMappingService,
                         IRegexMappingService regexMappingService)
    {
        _coreApiWrapperService = coreApiWrapperService;
        _applicationMappingService = applicationMappingService;
        _regexMappingService = regexMappingService;
    }

    public async Task<IEnumerable<Report>> GetReportsToArchiveAsync(ArchiveRequest archiveRequest)
    {
        try
        {
            var applicationHistories = await _coreApiWrapperService.GetApplicationHistories(archiveRequest);
            var reports = new List<Report>();
            foreach (var applicationHistory in applicationHistories)
            {
                var applicationMappings = await _applicationMappingService.GetByIdentifierAsync(applicationHistory.ApplicationNumber.ToString());
                var report = new Report()
                {
                    ReportName = applicationHistory.ApplicationName,
                    QueueNumber = applicationHistory.QueueNumber.ToString(),
                    StopDateTime = applicationHistory.StopDateTime,
                    ApplicationMapping = DeteriminApplicationMapping(applicationMappings.ToList(), applicationHistory),
                };

                reports.Add(report);
            }

            return reports;
        }
        catch (Exception exception)
        {
            throw new Exception($"Error while trying to get reports ready for archiving. " +
                                $"Message: {exception.Message}");
        }
    }

    public ApplicationMapping DeteriminApplicationMapping(List<ApplicationMapping> applicationMappings, ApplicationHistory applicationHistory)
    {
        var applicationMapping = DeteriminApplicationMappingWithoutParameters(applicationMappings);
        if(applicationMapping != null)
        {
            return applicationMapping;
        }

        applicationMapping = DeteriminApplicationMappingByParameters(applicationMappings, applicationHistory);
        return applicationMapping;
    }

    public ApplicationMapping DeteriminApplicationMappingWithoutParameters(List<ApplicationMapping> possibleApplicationMappings)
    {
        var onlyASingleApplicationMapping = possibleApplicationMappings.Count == 1;
        if (onlyASingleApplicationMapping)
        {
            var singleApplicationMapping = possibleApplicationMappings.First();
            if (singleApplicationMapping.ParameterMappings == null ||
                !singleApplicationMapping.ParameterMappings.Any())
            {
                return singleApplicationMapping;
            }
        }

        return null;
    }

    public ApplicationMapping DeteriminApplicationMappingByParameters(List<ApplicationMapping> possibleApplicationMappings, ApplicationHistory applicationHistory)
    {
        foreach (var applicationMapping in possibleApplicationMappings)
        {
            bool containsAllParameter = false;
            foreach (var parameterMapping in applicationMapping.ParameterMappings)
            {
                containsAllParameter = applicationHistory.QueueApplicationParameters.Any(qap => qap.ParameterCode == parameterMapping.ParameterCode &&
                                                                                                qap.ParameterValue == parameterMapping.ParameterValue);

                if (!containsAllParameter)
                {
                    break;
                }
            }

            if (containsAllParameter)
            {
                return applicationMapping;
            }
        }

        return null;
    }
}