GPALLogger.cs

// =============================================================================
// GPAL - Generally Positive Automation Library
// Copyright © 2026 Software Decisions, Inc. All rights reserved.
//
// This file is part of GPAL.
// Licensed under the Business Source License 1.1
//
// Primary development, architecture, and vision by Michael B. Vederman,
// CEO of Software Decisions, Inc., Texas.
//
// Internal development maintained privately.
// Public releases appear on GitHub: https://github.com/SoftwareDecisionsInc/GPAL.
//
// See LICENSE for full terms, including Additional Use Grant.
// =============================================================================
 
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static GenerallyPositive.Enums;
 
namespace GenerallyPositive
{

    public class GPALLogger : IGPALLogger
    {
        private string RootDirectory { get; set; }
        private DirectoryStructure DirectoryStructure { get; set; }
        private string Filename { get; set; }
        private FilenamePattern FilenamePattern { get; set; }
        private string Delimiter { get; set; }
        private GPALDatabase Database { get; set; }
        private LogDateFormat LogDateFormat { get; set; } = LogDateFormat.NOTSET;
        private bool LogDateAsAttribute { get; set; } = false;

        public string LogDirectory { get; private set; }
        public string LogFilename { get; private set; }
        public string LogFullPath { get; private set; }
 
        private bool noTargetReported = false;
 
        // one per logger, not one for all of them. writing publishes events of its own, and with a logger
        // attached to the publish path that lands in another logger's Log - which took this same converter,
        // reset its input and output, and left the write that was already in progress to save the wrong thing
        private GPALConverter converter = new GPALConverter();
        private LogType LogType { get; set; } = LogType.INFO;
        private GPALEventType LogEventTypes { get; set; } = GPALEventType.All;

        public IGPALLogger ToGPALObject()
        {
            return this;
        }

        internal GPALLogger()
        {
            IGPALConverter converter = GPAL.Converter.ToGPALObject();
            // Default values
            RootDirectory = Directory.GetCurrentDirectory();
            DirectoryStructure = DirectoryStructure.None;
            FilenamePattern = FilenamePattern.None;
        }
        public IAllowLoggingAndSetting WithLogEventTypes(GPALEventType logEventTypes)
        {
            LogEventTypes = logEventTypes;
            return this;
        }
 
        public IAllowLoggingAndSetting WithLogType(LogType logType)
        {
            LogType = logType;
            return this;
        }
        public IAllowLoggingSettings WithDatabase(GPALDatabase database)
        {
            Database = database;
            return this;
        }

        public IAllowLoggingSettings WithRootDirectory(string path)
        {
            RootDirectory = path;
            return this;
        }

        public IAllowLoggingSettings WithDirectoryStructure(DirectoryStructure type)
        {
            DirectoryStructure = type;
            return this;
        }

        public IAllowLoggingSettings WithFilename(string name)
        {
            Filename = name;
            return this;
        }

        public IAllowLoggingSettings WithFilenamePattern(FilenamePattern pattern)
        {
            FilenamePattern = pattern;
            return this;
        }

        public IAllowLoggingAndSetting WithDelimiter(char delimiter)
        {
            Delimiter = delimiter.ToString();
            converter.ConverterSettings.InDelimiter = delimiter;
            return this;
        }

        public IAllowLoggingAndSetting WithLoggingFormat(LogDateFormat logDateFormat)
        {
            LogDateFormat = logDateFormat;
            return this;
        }

        public IAllowLoggingAndSetting WithLogDateAsAttribute(bool logDateAsAttribute = true)
        {
            LogDateAsAttribute = logDateAsAttribute;
            return this;
        }

        private string GetLogFilePath()
        {
            string logDirectory = FileHelper.EnsureDirectoryEndsWithBackslash(RootDirectory);
            string year = DateTime.Now.ToString("yyyy");
            string month = DateTime.Now.ToString("MM");
            string day = DateTime.Now.ToString("dd");
            string hr = DateTime.Now.ToString("HH");
            string julian = DateTime.Now.DayOfYear.ToString("000");
 
 
            // Create directory if it doesn't exist
            Directory.CreateDirectory(logDirectory);
 
            // Adjust directory structure based on the selected type
            switch (DirectoryStructure)
            {
                case DirectoryStructure.YM:
                    // Create year and month directories
                    logDirectory = Path.Combine(logDirectory, year);
                    Directory.CreateDirectory(logDirectory);
 
                    logDirectory = Path.Combine(logDirectory, month);
                    Directory.CreateDirectory(logDirectory);
 
                    break;
                case DirectoryStructure.YMD:
                    // Create year, month, and day directories
                    logDirectory = Path.Combine(logDirectory, year);
                    Directory.CreateDirectory(logDirectory);
 
                    logDirectory = Path.Combine(logDirectory, month);
                    Directory.CreateDirectory(logDirectory);
 
                    logDirectory = Path.Combine(logDirectory, day);
                    Directory.CreateDirectory(logDirectory);
                    break;
                case DirectoryStructure.YMDH:
                    // Create year, month, day, and hour directories
                    logDirectory = Path.Combine(logDirectory, year);
                    Directory.CreateDirectory(logDirectory);
 
                    logDirectory = Path.Combine(logDirectory, month);
                    Directory.CreateDirectory(logDirectory);
 
                    logDirectory = Path.Combine(logDirectory, day);
                    Directory.CreateDirectory(logDirectory);
 
                    logDirectory = Path.Combine(logDirectory, hr);
                    Directory.CreateDirectory(logDirectory);
                    break;
                case DirectoryStructure.MDH:
                    logDirectory = Path.Combine(logDirectory, month);
                    Directory.CreateDirectory(logDirectory);
 
                    logDirectory = Path.Combine(logDirectory, day);
                    Directory.CreateDirectory(logDirectory);
 
                    logDirectory = Path.Combine(logDirectory, hr);
                    Directory.CreateDirectory(logDirectory);
                    break;
                case DirectoryStructure.MD:
                    logDirectory = Path.Combine(logDirectory, month);
                    Directory.CreateDirectory(logDirectory);
 
                    logDirectory = Path.Combine(logDirectory, day);
                    Directory.CreateDirectory(logDirectory);
                    break;
                case DirectoryStructure.M:
                    logDirectory = Path.Combine(logDirectory, month);
                    Directory.CreateDirectory(logDirectory);
                    break;
                case DirectoryStructure.DH:
                    logDirectory = Path.Combine(logDirectory, day);
                    Directory.CreateDirectory(logDirectory);
 
                    logDirectory = Path.Combine(logDirectory, hr);
                    Directory.CreateDirectory(logDirectory);
                    break;
                case DirectoryStructure.D:
                    logDirectory = Path.Combine(logDirectory, day);
                    Directory.CreateDirectory(logDirectory);
                    break;
                case DirectoryStructure.H:
                    logDirectory = Path.Combine(logDirectory, hr);
                    Directory.CreateDirectory(logDirectory);
                    break;
                case DirectoryStructure.Julian:
                    logDirectory = Path.Combine(logDirectory, julian);
                    Directory.CreateDirectory(logDirectory);
                    break;
                case DirectoryStructure.None:
                    break;
                default:
                    GPAL.PublishSimpleEvent(GPALEventType.WARNING, $"Unable to figure out directory structure [{DirectoryStructure}]", this, GPALObjectType.Logger);
                    break;
            }
 
            // Generate filename based on pattern
            string timestamp = string.Empty;
            string fileExtension = Filename.Split('.').Last();
            string filenameWithoutExtension = Filename.Substring(0, Filename.LastIndexOf('.'));
 
            switch (FilenamePattern)
            {
                case FilenamePattern.YMDHMSm:
                    timestamp = DateTime.Now.ToString("yyyyMMddHHmmssfff");
                    break;
                case FilenamePattern.YMDHMS:
                    timestamp = DateTime.Now.ToString("yyyyMMddHHmmss");
                    break;
                case FilenamePattern.YMDHM:
                    timestamp = DateTime.Now.ToString("yyyyMMddHHmm");
                    break;
                case FilenamePattern.YMDH:
                    timestamp = DateTime.Now.ToString("yyyyMMddHH");
                    break;
                case FilenamePattern.YMD:
                    timestamp = DateTime.Now.ToString("yyyyMMdd");
                    break;
                case FilenamePattern.YM:
                    timestamp = DateTime.Now.ToString("yyyyMM");
                    break;
                case FilenamePattern.MM:
                    timestamp = DateTime.Now.ToString("MM");
                    break;
                case FilenamePattern.Y:
                    timestamp = DateTime.Now.ToString("yyyy");
                    break;
                case FilenamePattern.MDHMSm:
                    timestamp = DateTime.Now.ToString("MMddHHmmssfff");
                    break;
                case FilenamePattern.MDHMS:
                    timestamp = DateTime.Now.ToString("MMddHHmmss");
                    break;
                case FilenamePattern.MDHM:
                    timestamp = DateTime.Now.ToString("MMddHHmm");
                    break;
                case FilenamePattern.MDH:
                    timestamp = DateTime.Now.ToString("MMddHH");
                    break;
                case FilenamePattern.DHMSm:
                    timestamp = DateTime.Now.ToString("ddHHmmssfff");
                    break;
                case FilenamePattern.DHMS:
                    timestamp = DateTime.Now.ToString("ddHHmmss");
                    break;
                case FilenamePattern.DHM:
                    timestamp = DateTime.Now.ToString("ddHHmm");
                    break;
                case FilenamePattern.DH:
                    timestamp = DateTime.Now.ToString("ddHH");
                    break;
                case FilenamePattern.D:
                    timestamp = DateTime.Now.Day.ToString();
                    break;
                case FilenamePattern.HMSm:
                    timestamp = DateTime.Now.ToString("HHmmssfff");
                    break;
                case FilenamePattern.HMS:
                    timestamp = DateTime.Now.ToString("HHmmss");
                    break;
                case FilenamePattern.HM:
                    timestamp = DateTime.Now.ToString("HHmm");
                    break;
                case FilenamePattern.H:
                    timestamp = DateTime.Now.ToString("HH");
                    break;
                case FilenamePattern.MSm:
                    timestamp = DateTime.Now.ToString("mmssfff");
                    break;
                case FilenamePattern.MS:
                    timestamp = DateTime.Now.ToString("mmss");
                    break;
                case FilenamePattern.M:
                    timestamp = DateTime.Now.ToString("mm");
                    break;
                case FilenamePattern.Sm:
                    timestamp = DateTime.Now.ToString("ssfff");
                    break;
                case FilenamePattern.S:
                    timestamp = DateTime.Now.ToString("ss");
                    break;
                case FilenamePattern.m:
                    timestamp = DateTime.Now.ToString("fff");
                    break;
                case FilenamePattern.Julian:
                    timestamp = julian;
                    break;
                case FilenamePattern.None:
                    return Path.Combine(logDirectory, Filename);
                default:
                    GPAL.PublishSimpleEvent(GPALEventType.WARNING, $"Unable to determine filename patter [{FilenamePattern}]. Using [{Filename}].", this, GPALObjectType.Logger);
                    return Path.Combine(logDirectory, Filename);
            }
 
            if (!string.IsNullOrEmpty(timestamp))
                filenameWithoutExtension = $"{filenameWithoutExtension}_{timestamp}";
 
            return Path.Combine(logDirectory, $"{filenameWithoutExtension}.{fileExtension}");
        }
        public static string GetFormatString(LogDateFormat format)
        {
            switch (format)
            {
                case LogDateFormat.YMD_HMS:
                    return "yyyy-MM-dd HH:mm:ss";
                case LogDateFormat.YMD_HMS_FFF:
                    return "yyyy-MM-dd HH:mm:ss.fff";
                case LogDateFormat.DMY_HMS:
                    return "dd-MM-yyyy HH:mm:ss";
                case LogDateFormat.MDY_HMS:
                    return "MM-dd-yyyy HH:mm:ss";
                case LogDateFormat.DMY:
                    return "dd-MM-yyyy";
                case LogDateFormat.MDY:
                    return "MM-dd-yyyy";
                case LogDateFormat.YMD:
                    return "yyyy-MM-dd";
                case LogDateFormat.HMS:
                    return "HH:mm:ss";
                case LogDateFormat.HM:
                    return "HH:mm";
                case LogDateFormat.MDY_Long:
                    return "MMMM dd, yyyy";
                default:
                    throw new ArgumentException("Unknown LogDateFormat value");
            }
        }

        // one writer at a time. every entry arrives on whatever thread published it, and GPAL.Workflow and
        // the puppeteer receive loop both publish while a workflow is running. AppendAllText opens the file
        // with FileShare.Read, so a second thread writing at the same moment is refused and that entry is
        // lost. static rather than per instance, because two loggers pointed at one filename collide too
        private static readonly object writeLock = new object();

        internal IAllowLoggingSettings Log(string logThis, string raisedBy, LogType entryType)
        {
            lock (writeLock)
                WriteEntry(logThis, raisedBy, entryType);
 
            return this;
        }
 
        private void WriteEntry(string logThis, string raisedBy, LogType entryType)
        {
            // the names are kept the same on both enums so this maps without a table. an entry whose type is not
            // in the set is not written
            if (false == Enum.TryParse(entryType.ToString(), out GPALEventType logEventType) || false == LogEventTypes.HasFlag(logEventType))
                return;
 
            DateTime currentDate = DateTime.Now;
            string formattedDate;
            string logFilePath = null;
 
            // whoever raised the event, which the publisher already worked out. the stack only knows who called
            // Log, and that is always the publisher now, so every entry would say PublishSimpleEvent
            string name = raisedBy;
 
            if (true == string.IsNullOrEmpty(name))
            {
                var st = new StackTrace();
                var sf = st.GetFrame(1);
 
                name = sf.GetMethod().Name;
 
                if (name.Equals("MoveNext"))
                {
                    // We're inside an async method
                    name = sf.GetMethod().ReflectedType.Name
                             .Split(new char[] { '<', '>' }, StringSplitOptions.RemoveEmptyEntries)[0];
                }
            }
 
            // one event, one entry. working out what a caller handed over was for a Log a workflow could
            // call, and a workflow raises events now - a grid or a class in a file is what the converter is for
            List<string> entries = new List<string> { logThis ?? "NULL" };
 
            if (null != Filename)
            {
                logFilePath = GetLogFilePath();
 
                // where this entry went, so a workflow can attach or move the file without working the
                // folder and the date out for itself. the path is recorded as it is written, not worked out
                // on request: GetLogFilePath creates folders and reads the clock, so asking before the first
                // entry would make empty folders and asking after midnight would name a file nobody wrote
                LogFullPath = logFilePath;
                LogDirectory = Path.GetDirectoryName(logFilePath);
                LogFilename = Path.GetFileName(logFilePath);
 
                if (LogDateFormat.NOTSET != LogDateFormat)
                    formattedDate = string.Format("{0:" + GetFormatString(LogDateFormat) + "}", currentDate);
                else
                    formattedDate = string.Format("{0:" + GetFormatString(LogDateFormat.MDY_HMS) + "}", currentDate);
 
                // written as text, which is all a log entry is. the converter used to own this write, and a line
                // that needs no conversion paid for all of it: the entry was handed back to be detected, so a
                // "name: value" read as yaml, the extension chose a format a line at a time could not build, and
                // the write announced itself into the very file it was writing.
                // converting a finished log to another format is its own step, run by someone who wants it
                // spaced, so a line reads rather than having to be picked apart by eye
                string separator = $" {Delimiter ?? "|"} ";
                StringBuilder lines = new StringBuilder();
 
                foreach (string entry in entries)
                    lines.Append($"{formattedDate}{separator}{entryType}{separator}{name}{separator}{entry}{Environment.NewLine}");
 
                File.AppendAllText(logFilePath, lines.ToString());
            }
            else if (null != Database)
            {
                // one value, with the type in front of it. a database fills in its own timestamp but has no way
                // to know what kind of event this was, so the entry carries it - and one parameter means one
                // insert to write, rather than a table having to declare one or two depending
                IGPALGrid<string> rows = GPAL.Grid.ToGPALObject();
 
                foreach (string entry in entries)
                    rows.AddRow(new List<string> { $"{entryType} {Delimiter ?? "|"} {entry}" });
 
                converter.WithInput(rows);
                converter.SaveTo(Database);
            }
            else if (false == noTargetReported)
            {
                // nowhere to write it. said once: attached to the publish path it would otherwise raise an error
                // for every event in the run, and each of those is another event
                noTargetReported = true;
 
                GPAL.PublishSimpleEvent(GPALEventType.ERROR, $"Nothing logged: this logger was given no file and no database to write to", this, GPALObjectType.Logger);
            }
 
            // nothing published about having logged. a logger saying it logged is a diagnostic whose one reliable
            // destination is a log file, and with a logger on the publish path it lands in someone else's
        }
 
        // Helper method to get week number
        private int GetWeekNumber(DateTime date)
        {
            return (date.DayOfYear - 1) / 7 + 1;
        }
    }
}