file-folder-helper/Day/2024-Q2/Helper-2024-04-03.cs

using Microsoft.Extensions.Logging;
using System.Collections.ObjectModel;

namespace File_Folder_Helper.Day;

internal static partial class Helper20240403
{

    private record DynamicHostConfigurationProtocolConfiguration(string[] Columns,
                                                                 string Directory,
                                                                 string Ignore,
                                                                 int KeyIndex,
                                                                 string Pattern,
                                                                 string Primary);

    private static void AlertIfNewDeviceIsConnected(DynamicHostConfigurationProtocolConfiguration dynamicHostConfigurationProtocolConfiguration, ILogger<Worker> logger)
    {
        string[] files = Directory.GetFiles(dynamicHostConfigurationProtocolConfiguration.Directory, dynamicHostConfigurationProtocolConfiguration.Pattern, SearchOption.TopDirectoryOnly);
        string? match = GetMatch(dynamicHostConfigurationProtocolConfiguration, files);
        if (string.IsNullOrEmpty(match))
            throw new NotSupportedException($"{dynamicHostConfigurationProtocolConfiguration.Primary} doesn't exist!");
        ReadOnlyDictionary<string, int> keyToCounts = GetKeyToCounts(dynamicHostConfigurationProtocolConfiguration, files);
        foreach (KeyValuePair<string, int> keyToCount in keyToCounts)
        {
            if (keyToCount.Value < 2)
                continue;
            logger.LogInformation("{Key}: {Count}", keyToCount.Key, keyToCount.Value);
        }
        ReadOnlyDictionary<string, ReadOnlyDictionary<string, ReadOnlyCollection<string>>> keyValuePairs = GetKeyValuePairs(dynamicHostConfigurationProtocolConfiguration, files);
        foreach (KeyValuePair<string, ReadOnlyDictionary<string, ReadOnlyCollection<string>>> keyValuePair in keyValuePairs)
        {
            if (!keyValuePair.Key.EndsWith(dynamicHostConfigurationProtocolConfiguration.Primary))
                continue;
        }
    }

    internal static void AlertIfNewDeviceIsConnected(ILogger<Worker> logger, List<string> args)
    {
        string ignore = args[6];
        string pattern = args[2];
        string primary = args[3];
        string keyIndex = args[5];
        string directory = args[0];
        logger.LogInformation(directory);
        string[] columns = args[4].Split('|');
        DynamicHostConfigurationProtocolConfiguration dynamicHostConfigurationProtocolConfiguration = new(columns, directory, ignore, int.Parse(keyIndex), pattern, primary);
        AlertIfNewDeviceIsConnected(dynamicHostConfigurationProtocolConfiguration, logger);
    }

    private static string? GetMatch(DynamicHostConfigurationProtocolConfiguration dynamicHostConfigurationProtocolConfiguration, string[] files)
    {
        string? result = null;
        foreach (string file in files)
        {
            if (file.EndsWith(dynamicHostConfigurationProtocolConfiguration.Primary))
                result = file;
        }
        return result;
    }

    private static ReadOnlyDictionary<string, int> GetKeyToCounts(DynamicHostConfigurationProtocolConfiguration dynamicHostConfigurationProtocolConfiguration, string[] files)
    {
        Dictionary<string, int> results = [];
        bool check;
        string key;
        string[] lines;
        string[] segments;
        List<int>? collection;
        Dictionary<string, List<int>> keyValuePairs = [];
        int columnsLength = dynamicHostConfigurationProtocolConfiguration.Columns.Length;
        foreach (string file in files)
        {
            check = false;
            lines = File.ReadAllLines(file);
            foreach (string line in lines)
            {
                if (line.Length < 3 || line[0] != '|' || line[^1] != '|')
                    continue;
                segments = line.Split('|');
                if (segments.Length != columnsLength)
                    continue;
                key = segments[dynamicHostConfigurationProtocolConfiguration.KeyIndex].Trim();
                if (!check)
                {
                    if (!key.StartsWith('-') || !key.EndsWith('-'))
                        continue;
                    check = true;
                    continue;
                }
                if (key == dynamicHostConfigurationProtocolConfiguration.Ignore)
                    break;
                if (!keyValuePairs.TryGetValue(key, out collection))
                {
                    keyValuePairs.Add(key, []);
                    if (!keyValuePairs.TryGetValue(key, out collection))
                        throw new Exception();
                }
                collection.Add(1);
            }
        }
        foreach (KeyValuePair<string, List<int>> keyValuePair in keyValuePairs.OrderByDescending(l => l.Value.Count))
            results.Add(keyValuePair.Key, keyValuePair.Value.Count);
        return new(results);
    }

    private static ReadOnlyDictionary<string, ReadOnlyDictionary<string, ReadOnlyCollection<string>>> GetKeyValuePairs(DynamicHostConfigurationProtocolConfiguration dynamicHostConfigurationProtocolConfiguration, string[] files)
    {
        ReadOnlyDictionary<string, ReadOnlyDictionary<string, ReadOnlyCollection<string>>> results;
        bool check;
        string key;
        string[] lines;
        string[] segments;
        List<string> keys = [];
        Dictionary<string, ReadOnlyCollection<string>> keyValuePairs;
        Dictionary<string, ReadOnlyDictionary<string, ReadOnlyCollection<string>>> fileTo = [];
        int columnsLength = dynamicHostConfigurationProtocolConfiguration.Columns.Length;
        foreach (string file in files)
        {
            keys.Clear();
            check = false;
            keyValuePairs = [];
            lines = File.ReadAllLines(file);
            foreach (string line in lines)
            {
                if (line.Length < 3 || line[0] != '|' || line[^1] != '|')
                    continue;
                segments = line.Split('|');
                if (segments.Length != columnsLength)
                    continue;
                key = segments[dynamicHostConfigurationProtocolConfiguration.KeyIndex].Trim();
                if (!check)
                {
                    if (!key.StartsWith('-') || !key.EndsWith('-'))
                        continue;
                    check = true;
                    continue;
                }
                if (key == dynamicHostConfigurationProtocolConfiguration.Ignore)
                    break;
                if (keys.Contains(key))
                    throw new NotSupportedException($"{key}: is a duplicate!");
                keys.Add(key);
                keyValuePairs.Add(key, new(segments.Select(l => l.Trim()).ToArray()));
            }
            fileTo.Add(Path.GetFullPath(file), new(keyValuePairs));
        }
        results = new(fileTo);
        return results;
    }

}