namespace View_by_Distance.Shared.Models.Stateless.Methods;

internal abstract class Container
{

    internal static DateTime[] GetContainerDateTimes(Models.Item[] filteredItems)
    {
        DateTime[] results;
        DateTime? containerMinimumDateTime;
        DateTime? containerMaximumDateTime;
        containerMinimumDateTime = (from l in filteredItems select l.ImageFileHolder.LastWriteTime).Min();
        if (containerMinimumDateTime is null)
            containerMaximumDateTime = null;
        else
            containerMaximumDateTime = (from l in filteredItems select l.ImageFileHolder.LastWriteTime).Max();
        if (containerMinimumDateTime is null || containerMaximumDateTime is null)
            results = Array.Empty<DateTime>();
        else
            results = new DateTime[] { containerMinimumDateTime.Value, containerMaximumDateTime.Value };
        return results;
    }

    internal static Models.Item[] GetFilterItems(Properties.IPropertyConfiguration propertyConfiguration, Models.Container container)
    {
        List<Models.Item> results = new();
        foreach (Models.Item item in container.Items)
        {
            if (item.ImageFileHolder is not null
                && (item.Abandoned is null || !item.Abandoned.Value)
                && item.ValidImageFormatExtension
                && !propertyConfiguration.IgnoreExtensions.Contains(item.ImageFileHolder.ExtensionLowered))
                results.Add(item);
        }
        return results.ToArray();
    }

    internal static bool IsIgnoreRelativePath(Properties.IPropertyConfiguration propertyConfiguration, string[] ignoreRelativePaths, string directory)
    {
        bool result = false;
        string? checkDirectory = Path.GetFullPath(directory);
        for (int i = 0; i < int.MaxValue; i++)
        {
            if (ignoreRelativePaths.Contains(Path.GetFileName(checkDirectory)))
            {
                result = true;
                break;
            }
            checkDirectory = Path.GetDirectoryName(checkDirectory);
            if (string.IsNullOrEmpty(checkDirectory) || checkDirectory == propertyConfiguration.RootDirectory)
                break;
        }
        return result;
    }

    internal static Models.Container[] SortContainers(Properties.IPropertyConfiguration propertyConfiguration, string[] ignoreRelativePaths, bool argZeroIsConfigurationRootDirectory, string argZero, Models.Container[] containers)
    {
        List<Models.Container> results = new();
        Models.Item[] filteredItems;
        bool isIgnoreRelativePath;
        List<int> collection = new();
        for (int i = 1; i < 3; i++)
        {
            foreach (Models.Container container in containers)
            {
                if (!container.Items.Any())
                    continue;
                if (!argZeroIsConfigurationRootDirectory && !container.SourceDirectory.StartsWith(argZero))
                    continue;
                filteredItems = GetFilterItems(propertyConfiguration, container);
                if (!filteredItems.Any())
                    continue;
                isIgnoreRelativePath = ignoreRelativePaths.Any(l => container.SourceDirectory.Contains(l)) && IsIgnoreRelativePath(propertyConfiguration, ignoreRelativePaths, container.SourceDirectory);
                if (i == 1 && isIgnoreRelativePath)
                    continue;
                if (i == 2 && !isIgnoreRelativePath)
                    continue;
                foreach (Models.Item item in filteredItems)
                {
                    if (item.Property?.Id is null)
                        continue;
                    if (collection.Contains(item.Property.Id.Value))
                    {
                        if (i == 1)
                            continue;
                        continue;
                    }
                    collection.Add(item.Property.Id.Value);
                }
                results.Add(container);
            }
        }
        return results.ToArray();
    }

}