HoHCI-BikeSim/Assets/Scripts/Logging/FileLogger.cs

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Threading.Tasks;
using UnityEngine;
using Valve.VR.InteractionSystem;

namespace Logging
{
    public class FileLogger
    {
        #region signleton

        private static Lazy<FileLogger>
            instance =
                new Lazy<FileLogger>
                    (() => new FileLogger());

        public static FileLogger Instance => instance.Value;

        public static void DestroyInstance()
        {
            if (instance.IsValueCreated)
            {
                instance.Value.Dispose();
                instance =
                    new Lazy<FileLogger>
                        (() => new FileLogger());
            }
        }

        #endregion

        private readonly DateTime startTimestamp;
        private AsyncLogFileWriter writer;
        private readonly List<ILogable> logables;
        private bool writerAvailable = false;
        private readonly Dictionary<string, Dictionary<long, string[]>> waitingBuffers;

        private FileLogger()
        {
            waitingBuffers = new Dictionary<string, Dictionary<long, string[]>>();
            startTimestamp = DateTime.Now;
            logables = new List<ILogable>();
        }

        public void RegisterLogable(ILogable l) => logables.Add(l);


        private IEnumerable<string> MergedHeaders()
        {
            var headers = new List<string> {"timestamp"};
            foreach (var l in logables)
            {
                headers.AddRange(l.HeaderNames);
            }

            return headers.ToArray();
        }

        private HashSet<long> MergeTimestamps()
        {
            var allTimestamps = new HashSet<long>();
            Debug.Log("--- Merging Keys ---");

            long minBegin = -1;
            long minEnd = -1;
            foreach (var l in logables)
            {
                var keys = l.BufferLines.Keys.ToArray();
                var begin = keys.Length > 0 ? keys.First() : -1;
                var end = keys.Length > 0 ? keys.Last() : -1;

                if (minBegin == -1 || begin < minBegin) minBegin = begin;
                if (minEnd == -1 || end < minEnd) minEnd = end;
            }

            Debug.Log($"\t{minBegin} - {minEnd}");


            foreach (var l in logables)
            {
                Debug.Log($"\tGenerating timestamp list for {l.Key}");
                var bufferLines = l.BufferLines;
                var timestamps = new HashSet<long>(bufferLines.Keys);
                var logableKey = l.Key;
                var hasWaiting = waitingBuffers.TryGetValue(logableKey, out var waiting);

                if (hasWaiting)
                {
                    foreach (var waitingTs in waiting.Keys)
                    {
                        if (waitingTs >= minBegin && waitingTs <= minEnd)
                        {
                            allTimestamps.Add(waitingTs);
                        }
                    }
                }

                foreach (var t in timestamps)
                {
                    if (t >= minBegin && t <= minEnd)
                    {
                        allTimestamps.Add(t);
                    }
                    else
                    {
                        //Debug.Log($"\tt = {t} not in range for {l.Key}");
                        if (waitingBuffers.ContainsKey(l.Key))
                        {
                            waitingBuffers[l.Key][t] = bufferLines[t];
                        }
                        else
                        {
                            waitingBuffers[l.Key] = new Dictionary<long, string[]> {{t, bufferLines[t]}};
                        }
                    }
                }

                Debug.Log($"\tDone generating timestamp list for {l.Key}");
            }

            logables.ForEach(l => allTimestamps.UnionWith(l.BufferLines.Keys.Where(k => k >= minBegin && k <= minEnd)));

            Debug.Log("--- Done Merging Keys ---");

            return allTimestamps;
        }

        private IEnumerable<IEnumerable<string>> MergedLines()
        {
            var lines = new List<List<string>>();
            var allKeys = MergeTimestamps();

            Debug.Log("--- Merging Lines ---");
            var mergedDict = new SortedDictionary<long, List<string>>();
            foreach (var timestamp in allKeys)
            {
                var newItem = new List<string>();
                for (var index = 0; index < logables.Count; index++)
                {
                    var l = logables[index];
                    var logableKey = l.Key;
                    var hasWaiting = waitingBuffers.TryGetValue(logableKey, out var waiting);
                    string[] linePart;

                    if (l.BufferLines.ContainsKey(timestamp))
                    {
                        linePart = l.BufferLines[timestamp];
                    }
                    else if (hasWaiting && waiting.ContainsKey(timestamp))
                    {
                        Debug.Log($"\tAdd line from waiting for key {logableKey}");
                        linePart = waiting[timestamp];
                        waiting.Remove(timestamp);
                    }
                    else
                    {
                        //var lastAvailableKey =
                        l.BufferLines.Keys.Where(k => k < timestamp).DefaultIfEmpty(-1).LastOrDefault();
                        /*linePart = lastAvailableKey >= 0
                            ? l.BufferLines[lastAvailableKey]
                            : new string[l.HeaderNames.ToArray().Length];*/
                        linePart = new string[l.HeaderNames.ToArray().Length];
                    }

                    newItem.AddRange(linePart);
                }

                mergedDict[timestamp] = newItem;
            }

            mergedDict.ForEach(item =>
            {
                var listItem = new List<string> {item.Key.ToString("D")};
                listItem.AddRange(item.Value);
                lines.Add(listItem);
            });
            Debug.Log("--- Merged Lines ---");
            return lines;
        }

        public async Task UpdateRegisteredLogs()
        {
            Debug.Log("UpdateRegisteredLogs()");
            if (!writerAvailable)
            {
                writer = new AsyncLogFileWriter($"Assets/Logs/{startTimestamp:yyyy-MM-dd_HHmmss}.tsv");
                await writer.WriteDataLine(MergedHeaders());
                writerAvailable = true;
            }

            await writer.WriteDataLines(MergedLines());
            Debug.Log("Clearing Bufffers");
            logables.ForEach(l => l.ClearBuffer());
        }

        private void Dispose()
        {
            if (writerAvailable)
            {
                writer.Dispose();
            }

            logables.Clear();
        }
    }
}