using Microsoft.Extensions.Configuration;
using Phares.Shared;
using Serilog;
using ShellProgressBar;
using View_by_Distance.Copy.Distinct.Models;
using View_by_Distance.Shared.Models;
using View_by_Distance.Shared.Models.Methods;

namespace View_by_Distance.Copy.Distinct;

public class CopyDistinct
{

    private readonly AppSettings _AppSettings;
    private readonly string _WorkingDirectory;
    private readonly Configuration _Configuration;
    private readonly IsEnvironment _IsEnvironment;
    private readonly IConfigurationRoot _ConfigurationRoot;
    private readonly IReadOnlyDictionary<string, string[]> _JsonGroups;
    private readonly Property.Models.Configuration _PropertyConfiguration;

    public CopyDistinct(List<string> args, IsEnvironment isEnvironment, IConfigurationRoot configurationRoot, AppSettings appSettings, string workingDirectory, bool isSilent, IConsole console)
    {
        if (isSilent)
        { }
        if (console is null)
        { }
        _AppSettings = appSettings;
        _IsEnvironment = isEnvironment;
        _WorkingDirectory = workingDirectory;
        _ConfigurationRoot = configurationRoot;
        string[] directories = new string[] { "()" };
        ILogger? log = Log.ForContext<CopyDistinct>();
        Property.Models.Configuration propertyConfiguration = Property.Models.Binder.Configuration.Get(isEnvironment, configurationRoot);
        _JsonGroups = Shared.Models.Stateless.Methods.IPath.GetKeyValuePairs(propertyConfiguration.ResultAllInOne, appSettings.CopyTo, directories, appSettings.MaxValue);
        Configuration configuration = Models.Binder.Configuration.Get(isEnvironment, configurationRoot, propertyConfiguration);
        _PropertyConfiguration = propertyConfiguration;
        _Configuration = configuration;
        propertyConfiguration.Update();
        log.Information(propertyConfiguration.RootDirectory);
        Verify();
        List<string> lines = CopyDistinctFilesInDirectories(log);
        File.WriteAllLines($"D:/Tmp/Phares/{DateTime.Now.Ticks}.tsv", lines);
        if (lines.Any())
            _ = Shared.Models.Stateless.Methods.IPath.DeleteEmptyDirectories(propertyConfiguration.RootDirectory);
    }

    private void Verify()
    {
        if (_AppSettings is null)
        { }
        if (_IsEnvironment is null)
        { }
        if (_Configuration is null)
        { }
        if (_ConfigurationRoot is null)
        { }
        if (_WorkingDirectory is null)
        { }
        if (_PropertyConfiguration is null)
        { }
    }

    private static (List<string>, List<string>) Get(List<string[]> filesCollection)
    {
        List<string> results = new();
        string? directory;
        List<string> directories = new();
        foreach (string[] files in filesCollection)
        {
            if (!files.Any())
                continue;
            directory = Path.GetDirectoryName(files.First());
            if (directory is null)
                continue;
            if (!directories.Contains(directory))
                directories.Add(directory);
            results.AddRange(files);
        }
        return (directories, results);
    }

    private List<(FileHolder, string)> GetToDoCollection(ProgressBar progressBar, List<string> files)
    {
        List<(FileHolder, string)> results = new();
        string directory;
        string checkFile;
        int directoryIndex;
        FileHolder fileHolder;
        bool isIgnoreExtension;
        List<string> distinct = new();
        bool isValidImageFormatExtension;
        bool nameWithoutExtensionIsIdFormat;
        foreach (string file in files)
        {
            progressBar.Tick();
            fileHolder = new(file);
            if (fileHolder.ExtensionLowered == ".id" || fileHolder.ExtensionLowered == ".lsv" || fileHolder.DirectoryName is null)
                continue;
            if (files.Contains($"{fileHolder.FullName}.id"))
                continue;
            isValidImageFormatExtension = _PropertyConfiguration.ValidImageFormatExtensions.Contains(fileHolder.ExtensionLowered);
            isIgnoreExtension = isValidImageFormatExtension && _PropertyConfiguration.IgnoreExtensions.Contains(fileHolder.ExtensionLowered);
            if (isIgnoreExtension || !isValidImageFormatExtension)
                continue;
            nameWithoutExtensionIsIdFormat = Shared.Models.Stateless.Methods.IProperty.NameWithoutExtensionIsIdFormat(fileHolder);
            if (!nameWithoutExtensionIsIdFormat)
                continue;
            directory = Shared.Models.Stateless.Methods.IDirectory.GetDirectory(fileHolder.NameWithoutExtension, 2);
            if (!int.TryParse(directory, out directoryIndex))
                continue;
            checkFile = Path.Combine(_JsonGroups["()"][directoryIndex], fileHolder.Name);
            if (distinct.Contains(checkFile))
                continue;
            distinct.Add(checkFile);
            results.Add(new(fileHolder, checkFile));
        }
        return results;
    }

    private static List<string> Copy(ILogger log, List<(FileHolder, string)> toDoCollection)
    {
        List<string> results = new();
        ConsoleKey? consoleKey = null;
        log.Information($"Ready to Copy {toDoCollection.Count} file(s)?");
        for (int y = 0; y < int.MaxValue; y++)
        {
            log.Information("Press \"Y\" key to copy file(s), \"N\" key to log file(s) or close console to not copy files");
            consoleKey = System.Console.ReadKey().Key;
            if (consoleKey is ConsoleKey.Y or ConsoleKey.N)
                break;
        }
        log.Information(". . .");
        if (consoleKey is null || consoleKey.Value != ConsoleKey.Y)
            log.Information("Nothing copied!");
        else
        {
            foreach ((FileHolder fileHolder, string to) in toDoCollection)
            {
                results.Add(fileHolder.NameWithoutExtension);
                try
                { File.Copy(fileHolder.FullName, to); }
                catch (Exception) { }
            }
            log.Information("Done copying");
        }
        return results;
    }

    private List<string> CopyDistinctFilesInDirectories(ILogger log)
    {
        List<string> results = new();
        const string fileSearchFilter = "*";
        string message = nameof(CopyDistinct);
        const string directorySearchFilter = "*";
        List<string[]> filesCollection = Shared.Models.Stateless.Methods.IDirectory.GetFilesCollection(_PropertyConfiguration.RootDirectory, directorySearchFilter, fileSearchFilter);
        (_, List<string> allFiles) = Get(filesCollection);
        ProgressBarOptions options = new() { ProgressCharacter = '─', ProgressBarOnBottom = true, DisableBottomPercentage = true };
        ProgressBar progressBar = new(allFiles.Count, message, options);
        List<(FileHolder, string)> toDoCollection = GetToDoCollection(progressBar, allFiles);
        results.AddRange(Copy(log, toDoCollection));
        progressBar.Dispose();
        return results;
    }

}