view-by-distance-mklink-console/Property/Models/Named.cs

using System.Text.Json.Serialization;
using View_by_Distance.Shared.Models;
using View_by_Distance.Shared.Models.Properties;

namespace View_by_Distance.Property.Models;

public class Named
{

    protected readonly bool? _IsWrongYear;
    protected readonly DateTime _MinimumDateTime;
    protected readonly int? _NormalizedPixelPercentage;
    protected readonly PersonBirthday? _PersonBirthday;
    public bool? IsWrongYear => _IsWrongYear;
    public DateTime MinimumDateTime => _MinimumDateTime;
    public int? NormalizedPixelPercentage => _NormalizedPixelPercentage;
    public PersonBirthday? PersonBirthday => _PersonBirthday;

    [JsonConstructor]
    public Named(bool? isWrongYear, DateTime minimumDateTime, int? normalizedPixelPercentage, PersonBirthday? personBirthday)
    {
        _IsWrongYear = isWrongYear;
        _MinimumDateTime = minimumDateTime;
        _NormalizedPixelPercentage = normalizedPixelPercentage;
        _PersonBirthday = personBirthday;
    }

    public Named(bool? isWrongYear, DateTime minimumDateTime, PersonBirthday? personBirthday) :
        this(isWrongYear, minimumDateTime, null, personBirthday)
    { }

    private static double GetDeterministicHashCodeFileName(int id, int normalizedPixelPercentage)
        => double.Parse($"{id}.{normalizedPixelPercentage}");

    public static double GetDeterministicHashCodeKey(Item item, Closest closest)
    {
        double result;
        if (item.Property?.Id is null || item.ImageFileHolder is null || closest.NormalizedPixelPercentage is null)
            throw new NullReferenceException();
        result = GetDeterministicHashCodeFileName(item.Property.Id.Value, closest.NormalizedPixelPercentage.Value);
        return result;
    }

    public static double GetDeterministicHashCodeKey(Item item, IFace face)
    {
        double result;
        if (item.Property?.Id is null || item.ImageFileHolder is null || face.Location?.NormalizedPixelPercentage is null)
            throw new NullReferenceException();
        result = GetDeterministicHashCodeFileName(item.Property.Id.Value, face.Location.NormalizedPixelPercentage.Value);
        return result;
    }

    public static double? GetReversedDeterministicHashCode(string fileName)
    {
        double? result;
        if (fileName.Length < 2 || fileName[1..].Contains('-'))
            result = null;
        else
        {
            string[] segments = fileName.Split('.');
            if (segments.Length < 2)
                throw new Exception();
            string id = segments[0];
            string normalizedPixelPercentage = segments[1];
            if (!double.TryParse(string.Concat(id, '.', normalizedPixelPercentage), out double resultValue))
                result = null;
            else
                result = resultValue;
        }
        return result;
    }

    public static (string?, double?) GetReversedDeterministicHashCode(Dictionary<int, List<IFace>> keyValuePairs, string file)
    {
        double? result;
        string? check;
        string fileName = Path.GetFileName(file);
        if (!fileName.Contains('-'))
        {
            check = null;
            result = null;
        }
        else
        {
            string id;
            int? normalizedPixelPercentage;
            if (!keyValuePairs.Any())
            {
                check = null;
                id = string.Empty;
                normalizedPixelPercentage = null;
            }
            else
            {
                string[] segments = fileName.Split(' ');
                if (segments.Length < 3)
                    throw new Exception();
                id = segments[2].Split('.')[0];
                string locationIdex = segments[0];
                if (!int.TryParse(id, out int idValue) || !int.TryParse(locationIdex, out int locationIndexValue) || !keyValuePairs.ContainsKey(idValue))
                {
                    check = null;
                    id = string.Empty;
                    normalizedPixelPercentage = null;
                }
                else
                {
                    List<IFace> faces = keyValuePairs[idValue];
                    if (faces.Count <= locationIndexValue)
                    {
                        check = null;
                        id = string.Empty;
                        normalizedPixelPercentage = null;
                    }
                    else
                    {
                        IFace face = faces[locationIndexValue];
                        if (face.Location?.NormalizedPixelPercentage is null)
                        {
                            check = null;
                            id = string.Empty;
                            normalizedPixelPercentage = null;
                        }
                        else
                        {
                            string extensionLowered = Path.GetExtension(file).ToLower();
                            normalizedPixelPercentage = face.Location.NormalizedPixelPercentage.Value;
                            double deterministicHashCodeKey = GetDeterministicHashCodeFileName(idValue, normalizedPixelPercentage.Value);
                            check = Path.Combine(string.Concat(Path.GetDirectoryName(file)), $"{deterministicHashCodeKey}{extensionLowered}");
                        }
                    }
                }
            }
            if (normalizedPixelPercentage is null || !double.TryParse(string.Concat(id, '.', normalizedPixelPercentage.Value), out double resultValue))
                result = null;
            else
                result = resultValue;
        }
        return new(check, result);
    }

}