using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;
using Phares.Shared;
using ShellProgressBar;
using View_by_Distance.Mirror.Length.Models;
using View_by_Distance.Shared.Models.Methods;

namespace View_by_Distance.Mirror.Length;

public class MirrorLength
{

    private readonly AppSettings _AppSettings;
    private readonly string _WorkingDirectory;
    private readonly Configuration _Configuration;
    private readonly IsEnvironment _IsEnvironment;
    private readonly IConfigurationRoot _ConfigurationRoot;
    private readonly Property.Models.Configuration _PropertyConfiguration;

    public MirrorLength(List<string> args, ILogger<Program> logger, IsEnvironment isEnvironment, IConfigurationRoot configurationRoot, AppSettings appSettings, string workingDirectory, bool isSilent, IConsole console)
    {
        if (isSilent)
        { }
        if (console is null)
        { }
        _AppSettings = appSettings;
        _IsEnvironment = isEnvironment;
        long ticks = DateTime.Now.Ticks;
        _WorkingDirectory = workingDirectory;
        _ConfigurationRoot = configurationRoot;
        Property.Models.Configuration propertyConfiguration = Property.Models.Binder.Configuration.Get(isEnvironment, configurationRoot);
        Configuration configuration = Models.Binder.Configuration.Get(isEnvironment, configurationRoot, propertyConfiguration);
        _PropertyConfiguration = propertyConfiguration;
        _Configuration = configuration;
        logger?.LogInformation(propertyConfiguration.RootDirectory);
        Verify();
        MirrorLengthFilesInDirectories(logger, ticks);
    }

    private void Verify()
    {
        if (_AppSettings is null)
            throw new NullReferenceException(nameof(_AppSettings));
        if (_IsEnvironment is null)
            throw new NullReferenceException(nameof(_IsEnvironment));
        if (_Configuration is null)
            throw new NullReferenceException(nameof(_Configuration));
        if (_ConfigurationRoot is null)
            throw new NullReferenceException(nameof(_ConfigurationRoot));
        if (_WorkingDirectory is null)
            throw new NullReferenceException(nameof(_WorkingDirectory));
        if (_PropertyConfiguration is null)
            throw new NullReferenceException(nameof(_PropertyConfiguration));
    }

    private static List<(string, string, DateTime, long)[]> GetToDoCollection(ProgressBar progressBar, List<string[]> filesCollection)
    {
        List<(string, string, DateTime, long)[]> results = new();
        FileInfo fileInfo;
        List<(string, string, DateTime, long)> collection;
        foreach (string[] files in filesCollection)
        {
            progressBar.Tick();
            collection = new();
            foreach (string file in files)
            {
                if (file.EndsWith("len"))
                    continue;
                fileInfo = new(file);
                if (string.IsNullOrEmpty(fileInfo.DirectoryName))
                    continue;
                collection.Add((fileInfo.DirectoryName, file, fileInfo.LastWriteTime, fileInfo.Length));
            }
            if (!collection.Any())
                continue;
            results.Add(collection.ToArray());
        }
        return results;
    }

    private List<(string, string, int)> GetToDoCollectionForMarkDown(string message, string today)
    {
        string[] files;
        string directoryName;
        ProgressBar progressBar;
        string subDirectoryName;
        string[] subDirectories;
        List<(string, string, int)> results = new();
        ProgressBarOptions options = new() { ProgressCharacter = '─', ProgressBarOnBottom = true, DisableBottomPercentage = true };
        string[] directories = Directory.GetDirectories(_PropertyConfiguration.RootDirectory, "*", SearchOption.TopDirectoryOnly);
        progressBar = new(directories.Length, message, options);
        foreach (string directory in directories)
        {
            progressBar.Tick();
            if (!directory.Contains(today))
                continue;
            directoryName = Path.GetFileName(directory);
            subDirectories = Directory.GetDirectories(directory, "*", SearchOption.TopDirectoryOnly);
            foreach (string subDirectory in subDirectories)
            {
                subDirectoryName = Path.GetFileName(subDirectory);
                files = Directory.GetFiles(subDirectory, "*len", SearchOption.AllDirectories);
                results.Add(new(directoryName, subDirectoryName, files.Length));
            }
        }
        progressBar.Dispose();
        return results;
    }

    private void Write(long ticks, bool inPlaceSave, ProgressBar progressBar, List<(string directory, string file, DateTime lastWriteTime, long length)[]> results)
    {
        string checkFile;
        string checkDirectory;
        string? firstDirectory;
        List<string> directories = new();
        foreach ((string Directory, string, DateTime, long)[] collection in results)
        {
            progressBar.Tick();
            directories.Clear();
            firstDirectory = collection.First().Directory;
            if (string.IsNullOrEmpty(firstDirectory))
                continue;
            checkDirectory = inPlaceSave ? firstDirectory : $"{_AppSettings.Destination}:/{ticks}/{firstDirectory[3..]}";
            if (!Directory.Exists(checkDirectory))
                _ = Directory.CreateDirectory(checkDirectory);
            else
            {
                if (!inPlaceSave)
                    continue;
            }
            foreach ((string directory, string _, DateTime _, long _) in collection)
            {
                checkDirectory = inPlaceSave ? directory : $"{_AppSettings.Destination}:/{ticks}/{directory[3..]}";
                if (directories.Contains(checkDirectory))
                    continue;
                directories.Add(checkDirectory);
                if (!Directory.Exists(checkDirectory))
                    _ = Directory.CreateDirectory(checkDirectory);
            }
            foreach ((string _, string file, DateTime lastWriteTime, long length) in collection)
            {
                checkFile = inPlaceSave ? $"{file}len" : $"{_AppSettings.Destination}:/{ticks}/{file[3..]}len";
                if (!Shared.Models.Stateless.Methods.IPath.WriteAllText(checkFile, length.ToString(), updateToWhenMatches: null, compareBeforeWrite: true, updateDateWhenMatches: false))
                    continue;
                File.SetLastWriteTime(checkFile, lastWriteTime);
            }
        }
    }

    private void Write(string today, List<(string directoryName, string subDirectoryName, int count)> collection)
    {
        string key;
        string text;
        string subKey;
        string checkFile;
        Dictionary<string, List<string>> directoryNameToCount = new();
        Dictionary<string, List<string>> subDirectoryNameToCount = new();
        foreach ((string directoryName, string subDirectoryName, int count) in collection)
        {
            key = directoryName.Replace(today, string.Empty).Replace(")", "-");
            subKey = subDirectoryName.Replace(today, string.Empty).Replace(") ", "-").Replace(" ", "-");
            if (!directoryNameToCount.ContainsKey(key))
                directoryNameToCount.Add(key, new() { "---", $"title: {key}", $"desc: '{directoryName}'", "---", string.Empty });
            if (count == 0)
                directoryNameToCount[key].Add($"- <00000000> '{subDirectoryName}'");
            else
                directoryNameToCount[key].Add($"- <{count:00000000}> [[{subKey}]]");
            if (!subDirectoryNameToCount.ContainsKey(subKey))
                subDirectoryNameToCount.Add(subKey, new() { "---", $"title: {subKey}", $"desc: '{subDirectoryName}'", "---", string.Empty });
            if (count == 0)
                subDirectoryNameToCount[subKey].Add($"- <00000000> '{directoryName}'");
            else
                subDirectoryNameToCount[subKey].Add($"- <{count:00000000}> [[{key}]]");
        }
        foreach (KeyValuePair<string, List<string>> keyValuePair in directoryNameToCount)
        {
            text = string.Join(Environment.NewLine, keyValuePair.Value);
            checkFile = Path.Combine(_PropertyConfiguration.RootDirectory, $"{keyValuePair.Key}.md");
            if (!Shared.Models.Stateless.Methods.IPath.WriteAllText(checkFile, text, updateToWhenMatches: null, compareBeforeWrite: true, updateDateWhenMatches: false))
                continue;
        }
        foreach (KeyValuePair<string, List<string>> keyValuePair in subDirectoryNameToCount)
        {
            text = string.Join(Environment.NewLine, keyValuePair.Value);
            checkFile = Path.Combine(_PropertyConfiguration.RootDirectory, $"{keyValuePair.Key}.md");
            if (!Shared.Models.Stateless.Methods.IPath.WriteAllText(checkFile, text, updateToWhenMatches: null, compareBeforeWrite: true, updateDateWhenMatches: false))
                continue;
        }
    }

    private void MirrorLengthFilesInDirectories(ILogger<Program>? logger, long ticks)
    {
        string message = nameof(MirrorLength);
        List<(string, string, int)> collectionForMarkDown;
        bool inPlaceSave = _PropertyConfiguration.RootDirectory.First() == _AppSettings.Destination;
        if (!inPlaceSave)
            collectionForMarkDown = new();
        else
        {
            string today = DateTime.Now.ToString("yyyy-MM-dd-");
            collectionForMarkDown = GetToDoCollectionForMarkDown(message, today);
            if (collectionForMarkDown.Any())
                Write(today, collectionForMarkDown);
        }
        if (!collectionForMarkDown.Any())
        {
            ProgressBar progressBar;
            const bool useCeilingAverage = true;
            const string fileSearchFilter = "*";
            const string directorySearchFilter = "*";
            List<string[]> filesCollection = Shared.Models.Stateless.Methods.IDirectory.GetFilesCollection(_PropertyConfiguration.RootDirectory, directorySearchFilter, fileSearchFilter, useCeilingAverage);
            ProgressBarOptions options = new() { ProgressCharacter = '─', ProgressBarOnBottom = true, DisableBottomPercentage = true };
            progressBar = new(filesCollection.Count, message, options);
            List<(string, string, DateTime, long)[]> collection = GetToDoCollection(progressBar, filesCollection);
            progressBar.Dispose();
            progressBar = new(filesCollection.Count, message, options);
            if (collection.Any())
                Write(ticks, inPlaceSave, progressBar, collection);
            progressBar.Dispose();
        }
    }

}