LogFile.cpp

Go to the documentation of this file.

// Copyright (c) 2024 FrostBit Software Lab at the Lapland University of Applied Sciences
//
// This work is licensed under the terms of the MIT license.
// For a copy, see <https://opensource.org/licenses/MIT>.
 
#include "LogFile.h"
#include "Agrarsense/Game/AgrarsensePaths.h"
#include "Agrarsense/Utils/FileUtilities.h"
 
#include "Misc/Paths.h"
 
#include <filesystem>
#include <iostream>
#include <iomanip>
#include <ctime>
 
ULogFile* ULogFile::CreateLogFile(const FString& FileNameWithoutExtension, FLogFileSettings Settings)
{
    ULogFile* LogFile = NewObject<ULogFile>(ULogFile::StaticClass());
    LogFile->AddToRoot();
    if (LogFile)
    {
        LogFile->Create(FileNameWithoutExtension, Settings);
    }
 
    return LogFile;
}
 
ULogFile::ULogFile()
{
 
}
 
ULogFile::~ULogFile()
{
    WriteQueuedMessages();
    Close();
}
 
void ULogFile::Create(const FString& FileNameWithoutExtension, FLogFileSettings Settings)
{
    CurrentSettings = Settings;
 
    FString ProjectPath = UAgrarsensePaths::GetDataFolder();
    FString Folder = FString("/Logs/");
    FString LogDirPath = FPaths::Combine(*ProjectPath, *Folder);
 
    if (!std::filesystem::exists(TCHAR_TO_UTF8(*LogDirPath)))
    {
        if (!std::filesystem::create_directory(TCHAR_TO_UTF8(*LogDirPath)))
        {
            // Failed to create the directory, return
            return;
        }
    }
 
    FString LogFilePath;
 
    if (Settings.OverrideFilePath && !Settings.FilePath.IsEmpty()) 
    {
        LogFilePath = FPaths::Combine(*Settings.FilePath, *FileNameWithoutExtension) + TEXT(".txt");
    }
    else 
    {
        LogFilePath = FPaths::Combine(*LogDirPath, *FileNameWithoutExtension) + TEXT(".txt");
    }
 
    FilePath = LogFilePath;
 
    switch (CurrentSettings.FileCreationOptions)
    {
    case FFileCreationOptions::Overwrite:
        // Clear file if it exists
        Clear();
        break;
 
    case FFileCreationOptions::Append:
        // Append to existing file if it exists
        break;
 
    case FFileCreationOptions::CreateUnique:
    {
        // Create unique file by adding number to the end until we find unique filename
        int suffix = 0;
        FString UniqueFileName = FileNameWithoutExtension + TEXT("_") + FString::FromInt(suffix++);
        FString UniqueLogFilePath = FPaths::Combine(*LogDirPath, *UniqueFileName) + TEXT(".txt");
 
        while (std::filesystem::exists(TCHAR_TO_UTF8(*UniqueLogFilePath)))
        {
            UniqueFileName = FileNameWithoutExtension + TEXT("_") + FString::FromInt(suffix++) + TEXT(".txt");
            UniqueLogFilePath = FPaths::Combine(*LogDirPath, *UniqueFileName);
        }
 
        LogFilePath = UniqueLogFilePath;
        break;
    }
 
    default:
        break;
    }
 
    // Try to create the .txt file
    std::ofstream newFile(TCHAR_TO_UTF8(*LogFilePath), std::ios::app);
    if (newFile.is_open())
    {
        newFile.close();
    }
    else
    {
        std::ifstream file(TCHAR_TO_UTF8(*LogFilePath));
        if (file.good())
        {
            // The file already exists, return
            file.close();
        }
    }
}
 
void ULogFile::Write(const FString& Text)
{
    if (FilePath.IsEmpty() || !IsValid(this))
    {
        return;
    }
 
    if (CurrentSettings.FileWriteOptions == FFileWriteOptions::Queue)
    {
        if (MessageQueue.Num() == CurrentSettings.QueueLength)
        {
            WriteQueuedMessages();
        }
        else
        {
            // Add message to queue (with timestamp if CurrentSettings.Timestamp) and return
            FString MessageToAdd = Text;
            if (CurrentSettings.Timestamp)
            {
                std::time_t now = std::time(nullptr);
                std::tm tm_time = *std::localtime(&now);
                char timestamp[12];
                std::strftime(timestamp, sizeof(timestamp), "[%H:%M:%S] ", &tm_time);
                MessageToAdd = FString(timestamp) + Text;
            }
            MessageQueue.Add(MessageToAdd);
        }
 
        return;
    }
 
    WriteToFile(Text, true);
}
 
void ULogFile::Close()
{
    if (LogFileStream.is_open())
    {
        LogFileStream.close();
    }
}
 
void ULogFile::Clear()
{
    if (std::filesystem::exists(TCHAR_TO_UTF8(*FilePath)))
    {
        std::ofstream clearFile(TCHAR_TO_UTF8(*FilePath), std::ofstream::out | std::ofstream::trunc);
        clearFile.close();
    }
}
 
void ULogFile::Destroy()
{
    if (IsValid(this))
    {
        WriteQueuedMessages();
        Close();
        ConditionalBeginDestroy();
    }
}
 
void ULogFile::OpenFilePath()
{
    UFileUtilities::OpenFileExplorer(FilePath);
}
 
void ULogFile::WriteQueuedMessages()
{
    if (MessageQueue.IsEmpty() || FilePath.IsEmpty())
    {
        return;
    }
 
    if (!LogFileStream.is_open())
    {
        std::string filePathString(TCHAR_TO_UTF8(*FilePath));
        LogFileStream.open(filePathString, std::ios::app);
        if (!LogFileStream.is_open())
        {
            // Failed to open the file, return
            return;
        }
    }
 
    for (const FString& Message : MessageQueue)
    {
        WriteToFile(Message, false);
    }
 
    MessageQueue.Empty();
 
    if (!CurrentSettings.KeepFileOpen)
    {
        LogFileStream.close();
    }
}
 
void ULogFile::WriteToFile(const FString& Text, bool UseTimestamp)
{
    if (FilePath.IsEmpty() || !IsValid(this))
    {
        return;
    }
 
    if (!LogFileStream.is_open())
    {
        std::string filePathString(TCHAR_TO_UTF8(*FilePath));
        LogFileStream.open(filePathString, std::ios::app);
        if (!LogFileStream.is_open())
        {
            // Failed to open the file, return
            return;
        }
    }
 
    if (UseTimestamp && CurrentSettings.Timestamp)
    {
        std::time_t now = std::time(nullptr);
        std::tm tm_time = *std::localtime(&now);
        char timestamp[12];
        std::strftime(timestamp, sizeof(timestamp), "[%H:%M:%S] ", &tm_time);
 
        LogFileStream << timestamp << TCHAR_TO_UTF8(*Text) << std::endl;
    }
    else
    {
        LogFileStream << TCHAR_TO_UTF8(*Text) << std::endl;
    }
 
    if (!CurrentSettings.KeepFileOpen)
    {
        LogFileStream.close();
    }
}