Blog

// * * * * *
// Original Author: Orcsune
// Date: July 27, 2025
// License: MIT License
// * * * * *

using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;

namespace Orcsune.Core.ODebug.Profiling {
    public class StopwatchGroup : IStopwatchInfoProvider {
        public static char sep = '/';
        public ConcurrentDictionary<string, StopwatchRecorder> stopwatchMap;
        public ConcurrentDictionary<string, StopwatchGroup> groupMap;
        private int defaultWindowSize;

        public StopwatchGroup() {
            defaultWindowSize = 30;
            stopwatchMap = new ConcurrentDictionary<string, StopwatchRecorder>();
            groupMap = new ConcurrentDictionary<string, StopwatchGroup>();
        }
        public StopwatchGroup(int windowSize) {
            defaultWindowSize = windowSize;
            stopwatchMap = new ConcurrentDictionary<string, StopwatchRecorder>();
            groupMap = new ConcurrentDictionary<string, StopwatchGroup>();
        }

        public Dictionary<string, IStopwatchInfo> GetLeafInfos(Dictionary<string, IStopwatchInfo> currentInfos = null, string currentPath="") {
            Dictionary<string, IStopwatchInfo> infos = currentInfos == null ?
                                                        new Dictionary<string, IStopwatchInfo>() :
                                                        currentInfos;
            foreach ((string name, StopwatchRecorder recorder) in stopwatchMap) {
                infos.Add(currentPath + sep + name, recorder.GetInfo());
            }
            foreach ((string name, StopwatchGroup subgroup) in groupMap) {
                subgroup.GetLeafInfos(infos, name);
            }
            return infos;
        }

        private StopwatchGroupInfo GetMyStopwatchInfo() {
            return new StopwatchGroupInfo(
                stopwatchMap.Values
                    .Select(sw => sw.GetInfo())
            );
        }
        public IStopwatchInfo GetInfo() {
            StopwatchGroupInfo consolidatedInfo = new StopwatchGroupInfo(
                stopwatchMap.Values
                    .Select(sw => sw.GetInfo())
                    .Concat(groupMap.Values
                        .Select(g => g.GetInfo()))
            );
            return consolidatedInfo;
        }

        private string[] SplitBaseName(string path) {
            return path.Split(sep, 2);
        }

        public bool TryGetInfoProvider(string path, out IStopwatchInfoProvider provider) {
            provider = GetInfoProvider(path);
            return provider != null;
        }
        public IStopwatchInfoProvider GetInfoProvider(string path) {
            string[] parts = SplitBaseName(path);
            string baseName = parts[0];
            // If we are on the last part of the path, then we need a provider now
            if (parts.Length == 1) {
                if (stopwatchMap.ContainsKey(baseName)) {
                    return stopwatchMap[baseName];
                }
                else if (groupMap.ContainsKey(baseName)) {
                    return groupMap[baseName];
                }
                else {
                    return null;
                }
            }
            // We are not at the end of the path, now look through my subgroups
            else {
                string extraPath = parts[1];
                // If we don't have a group called baseName, then we can't
                // look any further
                if (!groupMap.ContainsKey(baseName)) {
                    return null;
                }
                // By here, we MUST have a group called baseName,
                // so call GetInfoProvider on it
                return groupMap[baseName].GetInfoProvider(extraPath);
            }
        }

        public StopwatchRecorder GetRecorder(string path) {
            string[] parts = SplitBaseName(path);
            string baseName = parts[0];
            // If we are on the last part of the path, then we need a recorder now
            if (parts.Length == 1) {
                if (!stopwatchMap.ContainsKey(baseName)) {
                    CreateRecorderAtPath(baseName);
                }
                return stopwatchMap[baseName];
            }
            // We are not at the end of the path, now look through my subgroups
            else {
                string extraPath = parts[1];
                // If we don't have a group called baseName, then we know we must add it
                if (!groupMap.ContainsKey(baseName)) {
                    groupMap.TryAdd(baseName, new StopwatchGroup(defaultWindowSize));
                }
                // By here, we MUST have a group called baseName,
                // so call GetRecorder on it
                return groupMap[baseName].GetRecorder(extraPath);
            }
        }

        public void CreateRecorderAtPath(string path) {
            string[] parts = SplitBaseName(path);
            // We will have only 1 string if path is not nested
            // in which case we make a recorder with name 'path' in this StopwatchGroup
            if (parts.Length == 1) {
                if (!stopwatchMap.ContainsKey(path)) {
                    stopwatchMap.TryAdd(path, new StopwatchRecorder(defaultWindowSize));
                }
            }
            // We have more path to traverse.
            // Look in my subgroups to see if a group already exists
            else {
                string baseGroupName = parts[0];
                string extraPath = parts[1];
                if (!groupMap.ContainsKey(baseGroupName)) {
                    groupMap.TryAdd(baseGroupName, new StopwatchGroup(defaultWindowSize));
                }
                groupMap[baseGroupName].CreateRecorderAtPath(extraPath);
            }
            // Check problems with group names and recorder names overlapping
            if (stopwatchMap.ContainsKey(parts[0]) && groupMap.ContainsKey(parts[0])) {
                throw new System.Exception();
            }
        }
    }
}