using System.Drawing;
using System.Drawing.Imaging;
using System.Reflection;
using System.Text.Json;
using System.Text.Json.Serialization;
using View_by_Distance.FaceRecognitionDotNet;
using View_by_Distance.Metadata.Models;
using View_by_Distance.Property.Models;
using View_by_Distance.Resize.Models;
using View_by_Distance.Shared.Models;
using View_by_Distance.Shared.Models.Stateless;

namespace View_by_Distance.Face.Models;

/// <summary>
// List<D_Faces>
/// </summary>
public class D_Face
{

    public List<string> AngleBracketCollection { get; }

    protected readonly string _FileNameExtension;
    public string FileNameExtension => _FileNameExtension;

    protected readonly string _HiddenFileNameExtension;
    public string HiddenFileNameExtension => _HiddenFileNameExtension;

    private readonly Model _Model;
    private readonly string _ArgZero;
    private readonly Serilog.ILogger? _Log;
    private readonly Configuration _Configuration;
    private readonly ImageCodecInfo _ImageCodecInfo;
    private readonly ModelParameter _ModelParameter;
    private readonly PredictorModel _PredictorModel;
    private readonly ConstructorInfo _ConstructorInfo;
    private readonly EncoderParameters _EncoderParameters;
    private readonly ImageCodecInfo _HiddenImageCodecInfo;
    private readonly EncoderParameters _HiddenEncoderParameters;
    private readonly JsonSerializerOptions _WriteIndentedAndWhenWritingNull;

    private readonly bool _CheckDFaceAndUpWriteDates;
    private readonly int _FaceDistanceHiddenImageFactor;
    private readonly bool _ForceFaceLastWriteTimeToCreationTime;
    private readonly int _LocationDigits;
    private readonly int _LocationFactor;
    private readonly int _NumberOfJitters;
    private readonly int _NumberOfTimesToUpsample;
    private readonly bool _OverrideForFaceImages;
    private readonly bool _PropertiesChangedForFaces;

    public D_Face(
        string argZero,
        bool checkDFaceAndUpWriteDates,
        Configuration configuration,
        EncoderParameters encoderParameters,
        int faceDistanceHiddenImageFactor,
        string filenameExtension,
        bool forceFaceLastWriteTimeToCreationTime,
        EncoderParameters hiddenEncoderParameters,
        string hiddenFileNameExtension,
        ImageCodecInfo hiddenImageCodecInfo,
        ImageCodecInfo imageCodecInfo,
        int locationDigits,
        int locationFactor,
        Model model,
        ModelParameter modelParameter,
        int numberOfJitters,
        int numberOfTimesToUpsample,
        bool overrideForFaceImages,
        PredictorModel predictorModel,
        bool propertiesChangedForFaces)
    {
        _Model = model;
        _ArgZero = argZero;
        _Configuration = configuration;
        _ImageCodecInfo = imageCodecInfo;
        _LocationDigits = locationDigits;
        _LocationFactor = locationFactor;
        _ModelParameter = modelParameter;
        _PredictorModel = predictorModel;
        _NumberOfJitters = numberOfJitters;
        _EncoderParameters = encoderParameters;
        _FileNameExtension = filenameExtension;
        _Log = Serilog.Log.ForContext<D_Face>();
        AngleBracketCollection = new List<string>();
        _HiddenImageCodecInfo = hiddenImageCodecInfo;
        _OverrideForFaceImages = overrideForFaceImages;
        _HiddenEncoderParameters = hiddenEncoderParameters;
        _HiddenFileNameExtension = hiddenFileNameExtension;
        _NumberOfTimesToUpsample = numberOfTimesToUpsample;
        _CheckDFaceAndUpWriteDates = checkDFaceAndUpWriteDates;
        _PropertiesChangedForFaces = propertiesChangedForFaces;
        _FaceDistanceHiddenImageFactor = faceDistanceHiddenImageFactor;
        _ForceFaceLastWriteTimeToCreationTime = forceFaceLastWriteTimeToCreationTime;
        ConstructorInfo? constructorInfo = typeof(PropertyItem).GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public, null, Array.Empty<Type>(), null);
        if (constructorInfo is null)
            throw new Exception();
        _ConstructorInfo = constructorInfo;
        _WriteIndentedAndWhenWritingNull = new JsonSerializerOptions { WriteIndented = true, DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull };
    }

    public override string ToString()
    {
        string result = JsonSerializer.Serialize(this, new JsonSerializerOptions() { WriteIndented = true });
        return result;
    }

#pragma warning disable CA1416

    private static byte[] GetBytes(string value)
    {
        byte[] results = new byte[value.Length + 1];
        for (int i = 0; i < value.Length; i++)
            results[i] = (byte)value[i];
        results[value.Length] = 0x00;
        return results;
    }

    private PropertyItem GetPropertyItem(int id, string value)
    {
        PropertyItem result = (PropertyItem)_ConstructorInfo.Invoke(null);
        byte[] bytes = GetBytes(value);
        result.Id = id;
        result.Len = value.Length + 1;
        result.Type = 2;
        result.Value = bytes;
        return result;
    }

    private void SaveFaces(FileHolder resizedFileHolder, List<(Shared.Models.Face, FileInfo?, string)> collection)
    {
        int pixel;
        int width;
        int height;
        string json;
        Bitmap bitmap;
        Graphics graphics;
        Location? location;
        Rectangle rectangle;
        PropertyItem? propertyItem;
        int userComment = (int)IExif.Tags.UserComment;
        using Bitmap source = new(resizedFileHolder.FullName);
        foreach ((Shared.Models.Face face, FileInfo? fileInfo, string fileName) in collection)
        {
            if (fileInfo is null)
                continue;
            if (face.FaceEncoding is null || face?.Location?.NormalizedPixelPercentage is null || face?.OutputResolution is null)
                continue;
            location = Shared.Models.Stateless.Methods.ILocation.GetLocation(face.Location, _LocationDigits, _LocationFactor, source.Height, source.Width, collection.Count);
            if (location is null)
                continue;
            width = location.Right - location.Left;
            height = location.Bottom - location.Top;
            json = JsonSerializer.Serialize(face.FaceEncoding);
            pixel = Shared.Models.Stateless.Methods.ILocation.GetNormalizedPixelPercentage(face.Location, _LocationDigits, _LocationFactor, face.OutputResolution);
            rectangle = new Rectangle(location.Left, location.Top, width, height);
            using (bitmap = new(width, height))
            {
                using (graphics = Graphics.FromImage(bitmap))
                    graphics.DrawImage(source, new Rectangle(0, 0, width, height), rectangle, GraphicsUnit.Pixel);
                propertyItem = GetPropertyItem(userComment, json);
                bitmap.SetPropertyItem(propertyItem);
                bitmap.Save(fileInfo.FullName, _ImageCodecInfo, _EncoderParameters);
            }
            if (File.Exists(fileName))
                File.Delete(fileName);
            location = Shared.Models.Stateless.Methods.ILocation.GetLocation(_FaceDistanceHiddenImageFactor, face.Location, _LocationDigits, _LocationFactor, source.Height, source.Width, collection.Count);
            if (location is null)
                continue;
            width = location.Right - location.Left;
            height = location.Bottom - location.Top;
            rectangle = new Rectangle(location.Left, location.Top, width, height);
            using (bitmap = new(width, height))
            {
                using (graphics = Graphics.FromImage(bitmap))
                    graphics.DrawImage(source, new Rectangle(0, 0, width, height), rectangle, GraphicsUnit.Pixel);
                bitmap.Save(fileName, _HiddenImageCodecInfo, _HiddenEncoderParameters);
            }
            File.SetAttributes(fileName, FileAttributes.Hidden);
        }
    }

    private List<Shared.Models.Face> GetFaces(Item item, Shared.Models.Property property, int outputResolutionWidth, int outputResolutionHeight, int outputResolutionOrientation)
    {
        List<Shared.Models.Face> results = new();
        if (item.ImageFileHolder is null)
            throw new NullReferenceException(nameof(item.ImageFileHolder));
        if (item.ResizedFileHolder is null)
            throw new NullReferenceException(nameof(item.ResizedFileHolder));
        FaceRecognitionDotNet.Image? unknownImage;
        if (!item.ResizedFileHolder.Exists)
            unknownImage = null;
        else
        {
            try
            { unknownImage = FaceRecognition.LoadImageFile(item.ResizedFileHolder.FullName); }
            catch (Exception)
            { unknownImage = null; }
        }
        if (unknownImage is null)
            results.Add(new(property, outputResolutionWidth, outputResolutionHeight, outputResolutionOrientation, item.RelativePath, i: null, location: null));
        else
        {
            List<(int, Location Location, FaceRecognitionDotNet.FaceEncoding? FaceEncoding, Dictionary<FacePart, FacePoint[]>? FaceParts)> collection;
            FaceRecognition faceRecognition = new(_NumberOfTimesToUpsample, _NumberOfJitters, _PredictorModel, _Model, _ModelParameter);
            collection = faceRecognition.GetCollection(unknownImage, includeFaceEncoding: true, includeFaceParts: true, sortByNormalizedPixelPercentage: true);
            if (!collection.Any())
                results.Add(new(property, outputResolutionWidth, outputResolutionHeight, outputResolutionOrientation, item.RelativePath, i: null, location: null));
            else
            {
                double[] rawEncoding;
                Shared.Models.Face face;
                Shared.Models.FaceEncoding convertedFaceEncoding;
                foreach ((int locationIndex, Location location, FaceRecognitionDotNet.FaceEncoding? faceEncoding, Dictionary<FacePart, FacePoint[]>? faceParts) in collection)
                {
                    face = new(property, outputResolutionWidth, outputResolutionHeight, outputResolutionOrientation, item.RelativePath, locationIndex, location);
                    if (faceEncoding is not null)
                    {
                        rawEncoding = faceEncoding.GetRawEncoding();
                        convertedFaceEncoding = new(rawEncoding, faceEncoding.Size);
                        face.SetFaceEncoding(convertedFaceEncoding);
                    }
                    if (faceParts is not null)
                        face.SetFaceParts(faceParts);
                    results.Add(face);
                }
            }
            unknownImage.Dispose();
            faceRecognition.Dispose();
        }
        if (!results.Any())
            throw new Exception();
        return results;
    }

#pragma warning restore CA1416

    public List<Shared.Models.Face> GetFaces(string dResultsFullGroupDirectory, List<Tuple<string, DateTime>> subFileTuples, List<string> parseExceptions, Item item, Shared.Models.Property property, int outputResolutionWidth, int outputResolutionHeight, int outputResolutionOrientation)
    {
        List<Shared.Models.Face>? results;
        if (item.Property?.Id is null)
            throw new NullReferenceException(nameof(item.Property.Id));
        if (item.ImageFileHolder is null)
            throw new NullReferenceException(nameof(item.ImageFileHolder));
        if (string.IsNullOrEmpty(dResultsFullGroupDirectory))
            throw new NullReferenceException(nameof(dResultsFullGroupDirectory));
        string json;
        int?[] normalizedPixelPercentageCollection;
        int normalizedPixelPercentageDistinctCount;
        string[] changesFrom = new string[] { nameof(A_Property), nameof(B_Metadata), nameof(C_Resize) };
        List<DateTime> dateTimes = (from l in subFileTuples where changesFrom.Contains(l.Item1) select l.Item2).ToList();
        string usingRelativePath = Path.Combine(AngleBracketCollection[0].Replace("<>", "[]"), $"{item.ImageFileHolder.NameWithoutExtension}.json");
        string dCollectionFile = Path.Combine(dResultsFullGroupDirectory, "[]", _Configuration.ResultAllInOne, $"{item.Property.Id.Value}{item.ImageFileHolder.ExtensionLowered}.json");
        FileInfo fileInfo = new(dCollectionFile);
        if (!fileInfo.Exists)
        {
            if (File.Exists(usingRelativePath))
            {
                File.Move(usingRelativePath, fileInfo.FullName);
                fileInfo.Refresh();
            }
            if (!fileInfo.Exists)
            {
                if (fileInfo.Directory?.Parent is null)
                    throw new Exception();
                string parentCheck = Path.Combine(fileInfo.Directory.Parent.FullName, fileInfo.Name);
                if (File.Exists(parentCheck))
                {
                    File.Move(parentCheck, fileInfo.FullName);
                    fileInfo.Refresh();
                }
            }
        }
        if (_ForceFaceLastWriteTimeToCreationTime && !fileInfo.Exists && File.Exists(Path.ChangeExtension(fileInfo.FullName, ".delete")))
        {
            File.Move(Path.ChangeExtension(fileInfo.FullName, ".delete"), fileInfo.FullName);
            fileInfo.Refresh();
        }
        if (_ForceFaceLastWriteTimeToCreationTime && fileInfo.Exists && fileInfo.LastWriteTime != fileInfo.CreationTime)
        {
            File.SetLastWriteTime(fileInfo.FullName, fileInfo.CreationTime);
            fileInfo.Refresh();
        }
        if (_PropertiesChangedForFaces)
            results = null;
        else if (!fileInfo.Exists)
            results = null;
        else if (_CheckDFaceAndUpWriteDates && dateTimes.Any() && dateTimes.Max() > fileInfo.LastWriteTime)
            results = null;
        else
        {
            json = Shared.Models.Stateless.Methods.IFace.GetJson(fileInfo.FullName);
            try
            {
                results = JsonSerializer.Deserialize<List<Shared.Models.Face>>(json);
                if (results is null)
                    throw new NullReferenceException(nameof(results));
                if (!_ForceFaceLastWriteTimeToCreationTime)
                {
                    normalizedPixelPercentageCollection = Shared.Models.Stateless.Methods.IFace.GetInts(results);
                    normalizedPixelPercentageDistinctCount = normalizedPixelPercentageCollection.Distinct().Count();
                    if (normalizedPixelPercentageDistinctCount != normalizedPixelPercentageCollection.Length)
                        throw new Exception($"Not distinct! <{fileInfo.FullName}>");
                }
                subFileTuples.Add(new Tuple<string, DateTime>(nameof(D_Face), fileInfo.LastWriteTime));
            }
            catch (Exception)
            {
                results = null;
                parseExceptions.Add(nameof(D_Face));
            }
        }
        if (results is null)
        {
            results = GetFaces(item, property, outputResolutionWidth, outputResolutionHeight, outputResolutionOrientation);
            json = JsonSerializer.Serialize(results, _WriteIndentedAndWhenWritingNull);
            bool updateDateWhenMatches = dateTimes.Any() && fileInfo.Exists && dateTimes.Max() > fileInfo.LastWriteTime;
            DateTime? dateTime = !updateDateWhenMatches ? null : dateTimes.Max();
            if (Shared.Models.Stateless.Methods.IPath.WriteAllText(fileInfo.FullName, json, updateDateWhenMatches, compareBeforeWrite: true, updateToWhenMatches: dateTime))
                subFileTuples.Add(new Tuple<string, DateTime>(nameof(D_Face), DateTime.Now));
        }
        if (_ForceFaceLastWriteTimeToCreationTime)
        {
            results = (from l in results select new Shared.Models.Face(_LocationDigits, _LocationFactor, results.Count, l)).ToList();
            normalizedPixelPercentageCollection = Shared.Models.Stateless.Methods.IFace.GetInts(results);
            normalizedPixelPercentageDistinctCount = normalizedPixelPercentageCollection.Distinct().Count();
            if (normalizedPixelPercentageDistinctCount != normalizedPixelPercentageCollection.Length)
                throw new Exception($"Not distinct! <{fileInfo.FullName}>");
            json = JsonSerializer.Serialize(results, _WriteIndentedAndWhenWritingNull);
            bool updateDateWhenMatches = dateTimes.Any() && fileInfo.Exists && dateTimes.Max() > fileInfo.LastWriteTime;
            DateTime? dateTime = !updateDateWhenMatches ? null : dateTimes.Max();
            if (Shared.Models.Stateless.Methods.IPath.WriteAllText(fileInfo.FullName, json, updateDateWhenMatches, compareBeforeWrite: true, updateToWhenMatches: dateTime))
            {
                File.SetLastWriteTime(fileInfo.FullName, fileInfo.CreationTime);
                fileInfo.Refresh();
                subFileTuples.Add(new Tuple<string, DateTime>(nameof(D_Face), fileInfo.CreationTime));
            }
        }
        return results;
    }

    public void SaveFaces(string dResultsFullGroupDirectory, List<Tuple<string, DateTime>> subFileTuples, List<string> parseExceptions, Item item, List<Shared.Models.Face> faceCollection)
    {
        if (item.ImageFileHolder is null)
            throw new NullReferenceException(nameof(item.ImageFileHolder));
        if (item.ResizedFileHolder is null)
            throw new NullReferenceException(nameof(item.ResizedFileHolder));
        FileInfo fileInfo;
        bool check = false;
        string parentCheck;
        string deterministicHashCodeKeyDisplay;
        List<(Shared.Models.Face, FileInfo?, string)> collection = new();
        string[] changesFrom = new string[] { nameof(A_Property), nameof(B_Metadata), nameof(C_Resize) };
        string facesDirectory = Path.Combine(AngleBracketCollection[0].Replace("<>", "()"), item.ImageFileHolder.NameWithoutExtension);
        List<DateTime> dateTimes = (from l in subFileTuples where changesFrom.Contains(l.Item1) select l.Item2).ToList();
        if (!Directory.Exists(facesDirectory))
            _ = Directory.CreateDirectory(facesDirectory);
        foreach (Shared.Models.Face face in faceCollection)
        {
            if (item.Property?.Id is null || face.FaceEncoding is null || face.Location?.NormalizedPixelPercentage is null)
            {
                collection.Add(new(face, null, string.Empty));
                continue;
            }
            deterministicHashCodeKeyDisplay = Shared.Models.Stateless.Methods.IMapping.GetDeterministicHashCodeKey(item.Property.Id.Value, face.Location.NormalizedPixelPercentage.Value);
            fileInfo = new FileInfo(Path.Combine(facesDirectory, $"{deterministicHashCodeKeyDisplay}{item.ImageFileHolder.ExtensionLowered}{_FileNameExtension}"));
            if (!fileInfo.Exists)
            {
                if (fileInfo.Directory?.Parent is null)
                    throw new Exception();
                parentCheck = Path.Combine(fileInfo.Directory.Parent.FullName, fileInfo.Name);
                if (File.Exists(parentCheck))
                    File.Delete(parentCheck);
            }
            collection.Add(new(face, fileInfo, Path.Combine(facesDirectory, $"{deterministicHashCodeKeyDisplay}{item.ImageFileHolder.ExtensionLowered}{_HiddenFileNameExtension}")));
            if (_OverrideForFaceImages)
                check = true;
            else if (!fileInfo.Exists)
                check = true;
            else if (_CheckDFaceAndUpWriteDates && dateTimes.Any() && dateTimes.Max() > fileInfo.LastWriteTime)
                check = true;
        }
        if (check)
            SaveFaces(item.ResizedFileHolder, collection);
    }

}