Pf2eDataScrapper/Pf2eViewer/EntityTreeViewer/StructureBuilder.cs

using System.Collections;
using System.Reflection;
using LinqToDB.Extensions;
using Pf2eModel.Model.Common.I18n;

namespace Pf2eViewer.EntityTreeViewer;

internal class StructureBuilder
{
    private readonly List<StructureProcessedObject> _processedObjects = [];

    public StructureFieldComplex Create(string name, object value, int depth = 0)
    {
        _ = RegisterProcessed(value);

        StructureFieldComplex field = new(this, value, name, depth);

        CompleteProcessed(value, field);

        return field;
    }

    public bool RegisterProcessed(object value)
    {
        if (_processedObjects.Any(p => p.Value == value))
        {
            return false;
        }

        StructureProcessedObject processed = new(value);

        _processedObjects.Add(processed);

        return true;
    }

    public void CompleteProcessed(object value, StructureFieldComplex field)
    {
        StructureProcessedObject? q = _processedObjects.FirstOrDefault(p => p.Value == value);

        if (q == null)
        {
            return;
        }

        q.Field = field;
    }

    public StructureField Resolve(string name, object? value, int depth)
    {
        switch (GetFieldType(value))
        {
            case StructureFieldType.Null:
                return new StructureFieldNull(this, name, depth);

            case StructureFieldType.Primitive:
                return new StructureFieldPrimitive(this, value!, name, depth);

            case StructureFieldType.Enum:
                return new StructureFieldEnum(this, value!, name, depth);

            case StructureFieldType.Reference:
                break;

            case StructureFieldType.Complex:
            default:

                StructureProcessedObject? processed = _processedObjects.FirstOrDefault(p =>
                    p.Value == value
                );

                if (processed is null)
                {
                    return Create(name, value!, depth);
                }

                StructureFieldReference reference = new StructureFieldReference(
                    this,
                    name,
                    null,
                    depth
                );
                processed.AddReference(reference);
                return reference;
        }

        throw new("Impossible");
    }

    public static StructureFieldType GetFieldType(object? value)
    {
        if (value is null)
        {
            return StructureFieldType.Null;
        }

        Type type = value.GetType();

        if (type.IsEnum)
        {
            return StructureFieldType.Enum;
        }

        if (type.IsPrimitive || type == typeof(string))
        {
            return StructureFieldType.Primitive;
        }

        return StructureFieldType.Complex;
    }
}

internal class StructureProcessedObject(object value)
{
    public readonly object Value = value;

    private StructureFieldComplex? _field = null;

    public StructureFieldComplex? Field
    {
        get => _field;
        set
        {
            _field = value;
            foreach (StructureFieldReference reference in _references)
            {
                reference.Reference = Field;
            }
        }
    }

    private readonly List<StructureFieldReference> _references = [];

    public void AddReference(StructureFieldReference reference)
    {
        _references.Add(reference);

        if (_field is not null)
        {
            reference.Reference = Field;
        }
    }
}

internal enum StructureFieldType
{
    Null,
    Primitive,
    Enum,
    Complex,
    Reference,
}

internal enum LadderType
{
    Empty,
    Last,
    Through,
}

internal abstract class StructureField(StructureBuilder builder, string name, int depth)
{
    public readonly string Name = name;

    public abstract StructureFieldType FieldType { get; }

    public readonly StructureBuilder Builder = builder;

    public virtual bool Visible { get; set; } = true;

    public readonly int Depth = depth;

    public abstract string GetTypeString();

    public abstract string GetValueString();

    public virtual ICollection<EntityTreeViewerRow> GetTextRows(EntityTreeViewerControl control)
    {
        return [new(control, this)];
    }

    public virtual ICollection<T> GetRows<T>(Func<StructureField, T> func)
    {
        StructureField[] q = [this];
        return q.Select(func).ToList();
    }
}

internal class StructureFieldNull(StructureBuilder builder, string name, int depth)
    : StructureField(builder, name, depth)
{
    public override StructureFieldType FieldType => StructureFieldType.Null;

    public override string GetTypeString() => "null";

    public override string GetValueString() => "";
}

internal class StructureFieldPrimitive(
    StructureBuilder builder,
    object value,
    string name,
    int depth
) : StructureField(builder, name, depth)
{
    public override StructureFieldType FieldType => StructureFieldType.Primitive;

    public readonly object Value = value;

    public readonly Type Type = value.GetType();

    public override string GetTypeString()
    {
        return Type.GetTypeCode(Type) switch
        {
            TypeCode.Boolean => "bool",
            TypeCode.Int32 => "int",
            TypeCode.String => "string",
            TypeCode.Double => "double",
            _ => Type.Name,
        };
    }

    public override string GetValueString()
    {
        if (Type == typeof(string))
        {
            return "\"" + ((string)Value).Replace("\"", "\\\"") + "\"";
        }

        return Value.ToString() ?? string.Empty;
    }
}

internal class StructureFieldEnum(StructureBuilder builder, object value, string name, int depth)
    : StructureField(builder, name, depth)
{
    public override StructureFieldType FieldType => StructureFieldType.Enum;

    public readonly object Value = value;

    public readonly Type Type = value.GetType();

    public override string GetTypeString() => "enum";

    public override string GetValueString() => $"{Type.Name}.{Value}";
}

internal class StructureFieldComplex : StructureField
{
    public override StructureFieldType FieldType => StructureFieldType.Complex;

    public readonly List<StructureField> Fields = [];

    public readonly Type Type;

    public bool Collapsed
    {
        get => _collapsed;
        set
        {
            _collapsed = value;
            UpdateFieldVisibility();
        }
    }
    private bool _collapsed = false;

    public override bool Visible
    {
        get => _visible;
        set
        {
            _visible = value;
            UpdateFieldVisibility();
        }
    }
    private bool _visible = true;

    public StructureFieldComplex(StructureBuilder builder, object value, string name, int depth)
        : base(builder, name, depth)
    {
        Type = value.GetType();

        SetFields((dynamic)value);
    }

    private void UpdateFieldVisibility()
    {
        foreach (StructureField field in Fields)
        {
            field.Visible = Visible && !Collapsed;
        }
    }

    private void SetFields(LocaleString localeString)
    {
        SetFieldsFromRecords(
            localeString
                .Select(field => new FieldRecord(field.Locale.ToString(), field.Value))
                .ToList()
        );
    }

    private void SetFields(IEnumerable enumerable)
    {
        int i = 0;

        List<FieldRecord> records = [];

        foreach (object? item in enumerable)
        {
            records.Add(new($"[{i++}]", item));
        }

        SetFieldsFromRecords(records);
    }

    private void SetFields(object value)
    {
        Type type = value.GetType();
        PropertyInfo[] properties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);

        SetFieldsFromRecords(
            properties
                .Where(property =>
                    property.GetAttribute<Newtonsoft.Json.JsonIgnoreAttribute>() is null
                )
                .Select(property => new FieldRecord(property.Name, property.GetValue(value, null)))
                .ToList()
        );
    }

    private void SetFieldsFromRecords(List<FieldRecord> records)
    {
        foreach (
            FieldRecord record in records.Where(record =>
                record.FieldType == StructureFieldType.Complex
            )
        )
        {
            record.Allowed = Builder.RegisterProcessed(record.Value!);
        }

        foreach (FieldRecord record in records)
        {
            Fields.Add(
                record is { FieldType: StructureFieldType.Complex, Allowed: true }
                    ? Builder.Create(record.Name, record.Value!, Depth + 1)
                    : Builder.Resolve(record.Name, record.Value!, Depth + 1)
            );
        }
    }

    public override ICollection<EntityTreeViewerRow> GetTextRows(EntityTreeViewerControl control)
    {
        List<EntityTreeViewerRow> rows = base.GetTextRows(control).ToList();

        rows.AddRange(Fields.SelectMany(f => f.GetTextRows(control)).ToList());

        return rows;
    }

    public override ICollection<T> GetRows<T>(Func<StructureField, T> func)
    {
        return [.. base.GetRows(func), .. Fields.SelectMany(f => f.GetRows(func)).ToList()];
    }

    private class FieldRecord(string name, object? value)
    {
        public readonly string Name = name;

        public readonly object? Value = value;

        public StructureFieldType FieldType => StructureBuilder.GetFieldType(Value);

        public bool Allowed = true;
    }

    public override string GetTypeString()
    {
        if (Type.IsGenericEnumerableType())
        {
            Type elementType = Type.GetGenericArguments().Single();

            return $"{elementType.Name}[]";
        }
        else
        {
            return Type.Name;
        }
    }

    public override string GetValueString()
    {
        if (Type.IsGenericEnumerableType())
        {
            return Fields.Count.ToString() + (Fields.Count == 1 ? " item" : " items");
        }
        return "";
    }
}

internal class StructureFieldReference(
    StructureBuilder builder,
    string name,
    StructureFieldComplex? reference,
    int depth
) : StructureField(builder, name, depth)
{
    public StructureFieldComplex? Reference = reference;

    public override StructureFieldType FieldType => StructureFieldType.Reference;

    public override string GetTypeString() => Reference?.GetTypeString() ?? "???";

    public override string GetValueString() => "<Reference>";
}