mesa-fi-backlog/Adaptation/FileHandlers/json/WorkItems/Record.cs

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text.Json.Serialization;

namespace Adaptation.FileHandlers.json.WorkItems;

internal class Record
{

#nullable enable

    [JsonConstructor]
    public Record(WorkItem workItem, WorkItem? parent, Record[] children, Record[] related, Record[] successors)
    {
        WorkItem = workItem;
        Parent = parent;
        Children = children;
        Related = related;
        Successors = successors;
    }

    [JsonPropertyName("WorkItem")] public WorkItem WorkItem { get; set; }
    [JsonPropertyName("Parent")] public WorkItem? Parent { get; set; }
    [JsonPropertyName("Children")] public Record[] Children { get; set; }
    [JsonPropertyName("Related")] public Record[] Related { get; set; }
    [JsonPropertyName("Successors")] public Record[] Successors { get; set; }

    internal static Record GetWithoutNesting(Record record, string? violation)
    {
        Record result;
        WorkItem workItem = new(record.WorkItem.ActivatedDate,
                                record.WorkItem.AreaPath,
                                record.WorkItem.AssignedTo,
                                record.WorkItem.BusinessValue,
                                record.WorkItem.ChangedDate,
                                record.WorkItem.ClosedDate,
                                record.WorkItem.CommentCount,
                                record.WorkItem.CreatedDate,
                                record.WorkItem.Description,
                                record.WorkItem.Effort,
                                record.WorkItem.Id,
                                record.WorkItem.IterationPath,
                                record.WorkItem.Parent,
                                record.WorkItem.Priority,
                                record.WorkItem.Relations,
                                record.WorkItem.Requester,
                                record.WorkItem.ResolvedDate,
                                record.WorkItem.Revision,
                                record.WorkItem.RiskReductionMinusOpportunityEnablement,
                                record.WorkItem.StartDate,
                                record.WorkItem.State,
                                record.WorkItem.Tags,
                                record.WorkItem.TargetDate,
                                record.WorkItem.TimeCriticality,
                                record.WorkItem.Title,
                                record.WorkItem.Violation is null ? violation : record.WorkItem.Violation,
                                record.WorkItem.WeightedShortestJobFirst,
                                record.WorkItem.WorkItemType);
        result = new(workItem, record.Parent, Array.Empty<Record>(), Array.Empty<Record>(), Array.Empty<Record>());
        return result;
    }

    private static Record Get(Record record, bool keepRelations)
    {
        Record result;
        WorkItem? parentWorkItem = keepRelations ? record.Parent : WorkItem.GetWithOutRelations(record.Parent);
        WorkItem? workItem = keepRelations ? record.WorkItem : WorkItem.GetWithOutRelations(record.WorkItem) ?? throw new Exception();
        List<Record> childRecords = new();
        List<Record> relatedRecords = new();
        List<Record> successorRecords = new();
        foreach (Record r in record.Children)
            childRecords.Add(Get(r, keepRelations));
        foreach (Record r in record.Related)
            relatedRecords.Add(Get(r, keepRelations));
        foreach (Record r in record.Successors)
            successorRecords.Add(Get(r, keepRelations));
        result = new(workItem, parentWorkItem, childRecords.ToArray(), relatedRecords.ToArray(), successorRecords.ToArray());
        return result;
    }

    internal static Record Get(WorkItem workItem, WorkItem? parent, ReadOnlyCollection<Record> children, ReadOnlyCollection<Record> related, ReadOnlyCollection<Record> successors, bool keepRelations)
    {
        Record result;
        Record record = new(workItem, parent, children.ToArray(), related.ToArray(), successors.ToArray());
        result = Get(record, keepRelations);
        return result;
    }

    internal static ReadOnlyCollection<Record> GetKeyValuePairs(ReadOnlyDictionary<int, WorkItem> keyValuePairs, WorkItem workItem, string relationName, List<bool> nests, bool keepRelations)
    {
        List<Record> results = new();
        Record record;
        nests.Add(true);
        WorkItem? parentWorkItem;
        WorkItem? relationWorkItem;
        List<WorkItem> collection = new();
        ReadOnlyCollection<Record> childRecords;
        ReadOnlyCollection<Record> relatedRecords;
        ReadOnlyCollection<Record> successorRecords;
        if (workItem.Relations is not null && workItem.Relations.Length > 0)
        {
            collection.Clear();
            foreach (Relation relation in workItem.Relations)
            {
                if (relation.Attributes.Name != relationName)
                    continue;
                if (workItem.Parent is not null && relation.Id == workItem.Parent.Value)
                    continue;
                if (!keyValuePairs.TryGetValue(relation.Id, out relationWorkItem))
                    continue;
                collection.Add(relationWorkItem);
            }
            collection = (from l in collection orderby l.State != "Closed", l.Id select l).ToList();
            foreach (WorkItem w in collection)
            {
                if (nests.Count > 99)
                    break;
                if (w.Parent is null)
                    parentWorkItem = null;
                else
                    _ = keyValuePairs.TryGetValue(w.Parent.Value, out parentWorkItem);
                childRecords = GetKeyValuePairs(keyValuePairs, w, "Child", nests, keepRelations); // Forward
                // successorRecords = GetKeyValuePairs(keyValuePairs, w, "Successor", nests); // Forward
                successorRecords = new(Array.Empty<Record>());
                // predecessorRecords = GetKeyValuePairs(keyValuePairs, w, "Predecessor", nests); // Reverse
                relatedRecords = GetKeyValuePairs(keyValuePairs, w, "Related", nests, keepRelations); // Related
                record = Get(w, parentWorkItem, childRecords, relatedRecords, successorRecords, keepRelations);
                results.Add(record);
            }
        }
        return new(results);
    }

}

[JsonSourceGenerationOptions(WriteIndented = true)]
[JsonSerializable(typeof(Record))]
internal partial class RecordSourceGenerationContext : JsonSerializerContext
{
}

[JsonSourceGenerationOptions(WriteIndented = true)]
[JsonSerializable(typeof(Record[]))]
internal partial class RecordCollectionSourceGenerationContext : JsonSerializerContext
{
}