using MetadataExtractor;
using System.Collections.ObjectModel;
using System.Text.Json;
using View_by_Distance.Shared.Models;
using View_by_Distance.Shared.Models.Methods;
using View_by_Distance.Shared.Models.Properties;

namespace View_by_Distance.Metadata.Models;

public class A_Metadata : IMetadata<MetadataExtractor.Directory>
{

    private readonly bool _PropertiesChangedForMetadata;
    private readonly IPropertyConfiguration _PropertyConfiguration;
    private readonly bool _ForceMetadataLastWriteTimeToCreationTime;
    private readonly IReadOnlyDictionary<string, string[]> _FileGroups;

    public A_Metadata(IPropertyConfiguration propertyConfiguration, bool forceMetadataLastWriteTimeToCreationTime, bool propertiesChangedForMetadata)
    {
        _PropertyConfiguration = propertyConfiguration;
        _PropertiesChangedForMetadata = propertiesChangedForMetadata;
        _ForceMetadataLastWriteTimeToCreationTime = forceMetadataLastWriteTimeToCreationTime;
        string bResultsFullGroupDirectory = Property.Models.Stateless.IResult.GetResultsFullGroupDirectory(_PropertyConfiguration,
                                                                                                           nameof(A_Metadata),
                                                                                                           string.Empty,
                                                                                                           includeResizeGroup: false,
                                                                                                           includeModel: false,
                                                                                                           includePredictorModel: false);
        _FileGroups = Shared.Models.Stateless.Methods.IPath.GetKeyValuePairs(propertyConfiguration, bResultsFullGroupDirectory, [propertyConfiguration.ResultSingleton]);
    }

    public ReadOnlyDictionary<string, MetadataExtractorDirectory> GetMetadataCollection(string file)
    {
        Dictionary<string, MetadataExtractorDirectory>? results;
        string fileName = Path.GetFileName(file);
        string fileExtensionLowered = Path.GetExtension(file).ToLower();
        string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(file);
        (_, int directoryIndex) = Shared.Models.Stateless.Methods.IPath.GetDirectoryNameAndIndex(_PropertyConfiguration.ResultAllInOneSubdirectoryLength, fileName);
        FileInfo fileInfo = new(Path.Combine(_FileGroups[_PropertyConfiguration.ResultSingleton][directoryIndex], $"{fileNameWithoutExtension}{fileExtensionLowered}.json"));
        if (_ForceMetadataLastWriteTimeToCreationTime && !fileInfo.Exists && File.Exists(Path.ChangeExtension(fileInfo.FullName, ".delete")))
        {
            File.Move(Path.ChangeExtension(fileInfo.FullName, ".delete"), fileInfo.FullName);
            fileInfo.Refresh();
        }
        if (_ForceMetadataLastWriteTimeToCreationTime && fileInfo.Exists && fileInfo.LastWriteTime != fileInfo.CreationTime)
        {
            File.SetLastWriteTime(fileInfo.FullName, fileInfo.CreationTime);
            fileInfo.Refresh();
        }
        if (_PropertiesChangedForMetadata)
            results = null;
        else if (!fileInfo.Exists)
            results = null;
        else if (!fileInfo.FullName.EndsWith(".json") && !fileInfo.FullName.EndsWith(".old"))
            throw new ArgumentException("must be a *.json file");
        else
        {
            string json = File.ReadAllText(fileInfo.FullName);
            try
            {
                results = Stateless.Methods.Metadata.Deserialize(json);
                if (results is null)
                    throw new Exception();
            }
            catch (Exception)
            {
                results = null;
            }
        }
        if (results is null || results.Count == 0)
        {
            IReadOnlyList<MetadataExtractor.Directory> directories = ImageMetadataReader.ReadMetadata(file);
            results = Stateless.Methods.Metadata.Covert(directories);
            string json = JsonSerializer.Serialize(results, DictionaryStringMetadataExtractorDirectorySourceGenerationContext.Default.DictionaryStringMetadataExtractorDirectory);
            if (Shared.Models.Stateless.Methods.IPath.WriteAllText(fileInfo.FullName, json, updateDateWhenMatches: false, compareBeforeWrite: true, updateToWhenMatches: null) && _ForceMetadataLastWriteTimeToCreationTime)
            {
                File.SetLastWriteTime(fileInfo.FullName, fileInfo.CreationTime);
                fileInfo.Refresh();
            }
        }
        return new(results);
    }

    (DateTime?, DateTime?[]) IMetadata<MetadataExtractor.Directory>.GetDateTimes(FileHolder fileHolder, IReadOnlyList<MetadataExtractor.Directory> directories)
    {
        List<DateTime?> results = [];
        DateTime? result = null;
        return new(result, results.ToArray());
    }

}