File Versioning

using System;
using System.IO;
using System.Linq;
using static System.Text.Encoding;

namespace JasonStorey
{
    /// <summary>
    /// This class provides functions to manage versioning of files. It includes functions to write, check, change and strip headers, as well as to read the file content without the header and to write the header to a file.
    /// </summary>
    public static class FileVersioning
    {
        /// <summary>
        /// Writes a version header to a file.
        /// </summary>
        /// <param name="filePath">The path to the file.</param>
        /// <param name="keyword">The keyword used to calculate the header value.</param>
        /// <param name="version">The version number to write to the header.</param>
        public static void WriteVersionToFile(string filePath,string keyword, int version)
        {
            int asciiNumber = keyword.Sum(c => c);
            using var fileStream = new FileStream(filePath, FileMode.Create, FileAccess.Write);
            var bytesToWrite = new byte[3];
            bytesToWrite[0] = (byte)asciiNumber;
            bytesToWrite[1] = (byte)(version >> 8);
            bytesToWrite[2] = (byte)version;
            fileStream.Write(bytesToWrite, 0, 3);
        }

        /// <summary>
        /// Checks if a file has a valid version header and returns the version number.
        /// </summary>
        /// <param name="filePath">The path to the file.</param>
        /// <param name="keyword">The keyword used to calculate the expected header value.</param>
        /// <param name="version">The version number found in the header.</param>
        /// <returns>True if the file has a valid header, false otherwise.</returns>
        public static bool CheckFileVersion(string filePath,string keyword, out int version)
        {
            version = 0;
            if (!File.Exists(filePath))
                return false;
            using var fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read);
            byte[] headerBytes = new byte[3];
            int bytesRead = fileStream.Read(headerBytes, 0, 3);
            if (bytesRead < 3)
                return false;
            int asciiNumber = headerBytes[0];
            if (!asciiNumber.Equals(keyword.Sum(c => c))) return false;
            int versionBytes = (headerBytes[1] << 8) | headerBytes[2];
            version = versionBytes;
            string headerString = ASCII.GetString(headerBytes).Aggregate("", (current, c) => current + c);
            string expectedHeader = asciiNumber.ToString("D3") + versionBytes.ToString("D5");
            return headerString == expectedHeader;
        }

        /// <summary>
        /// Changes the version number in the header of a file.
        /// </summary>
        /// <param name="filePath">The path to the file.</param>
        /// <param name="keyword">The keyword used to check the header value.</param>
        /// <param name="newVersion">The new version number to write to the header.</param>
        /// <returns>True if the file has a valid header and the version number was changed, false otherwise.</returns>
        public static bool ChangeFileVersion(string filePath,string keyword, int newVersion)
        {
            if (!CheckFileVersion(filePath,keyword, out _))
                return false;
            using var fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Write);
            var versionBytes = BitConverter.GetBytes(newVersion);
            fileStream.Seek(1, SeekOrigin.Begin);
            fileStream.Write(versionBytes, 0, 2);
            return true;
        }


        /// <summary>
        /// Removes the version information and keyword header from a file.
        /// </summary>
        /// <param name="filePath">The path of the file to modify.</param>
        /// <param name="keyword">The keyword used for the file header.</param>
        /// <returns>True if the file exists </returns>
        public static bool StripHeaderFromFile(string filePath,string keyword)
        {
            if (!CheckFileVersion(filePath,keyword, out _))
                return false;
            byte[] fileBytes = File.ReadAllBytes(filePath);
            byte[] newFileBytes = new byte[fileBytes.Length - 3];
            Array.Copy(fileBytes, 3, newFileBytes, 0, newFileBytes.Length);
            using var fileStream = new FileStream(filePath, FileMode.Truncate);
            fileStream.Write(newFileBytes, 0, newFileBytes.Length);
            return true;
        }

        /// <summary>
        /// Reads the content of a file at the specified file path without the header and returns it as a string.
        /// </summary>
        /// <param name="filePath">The path of the file to be read.</param>
        /// <param name="keyword">The keyword associated with the header of the file.</param>
        /// <param name="expectedVersion">The expected version of the file.</param>
        /// <returns>The content of the file as a string.</returns>
        public static string ReadFileTextWithoutHeader(string filePath,string keyword, int expectedVersion) =>
            ASCII.GetString(ReadFileWithoutHeader(filePath,keyword,expectedVersion));

        /// <summary>
        /// Reads the content of a file at the specified file path without the header and returns it as a byte array.
        /// </summary>
        /// <param name="filePath">The path of the file to be read.</param>
        /// <param name="keyword">The keyword associated with the header of the file.</param>
        /// <param name="expectedVersion">The expected version of the file.</param>
        /// <returns>The content of the file as a byte array.</returns>
        public static byte[] ReadFileWithoutHeader(string filePath,string keyword, int expectedVersion)
        {
            if (!CheckFileVersion(filePath, keyword,out var currentVersion) || currentVersion != expectedVersion)
                return null;
            byte[] fileBytes = File.ReadAllBytes(filePath);
            byte[] contentBytes = new byte[fileBytes.Length - 3];
            Array.Copy(fileBytes, 3, contentBytes, 0, contentBytes.Length);
            return contentBytes;
        }

        /// <summary>
        /// Writes a header to a file at the specified file path.
        /// </summary>
        /// <param name="filePath">The path of the file to be written.</param>
        /// <param name="keyword">The keyword to be associated with the header of the file.</param>
        /// <param name="version">The version of the file.</param>
        public static void WriteHeaderToFile(string filePath, string keyword,int version)
        {
            byte[] versionBytes = ASCII.GetBytes(version.ToString());
            byte[] keywordBytes = ASCII.GetBytes(keyword);
            byte[] fileBytes = File.ReadAllBytes(filePath);
            byte[] newFileBytes = new byte[versionBytes.Length + keywordBytes.Length + fileBytes.Length];
            Array.Copy(versionBytes, 0, newFileBytes, 0, versionBytes.Length);
            Array.Copy(keywordBytes, 0, newFileBytes, versionBytes.Length, keywordBytes.Length);
            Array.Copy(fileBytes, 0, newFileBytes, versionBytes.Length + keywordBytes.Length, fileBytes.Length);
            using var fileStream = new FileStream(filePath, FileMode.Create);
            fileStream.Write(newFileBytes, 0, newFileBytes.Length);
        }

    }
}