Untitled

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;

namespace ChunkFileProcessor
{
    struct MessageRecord
    {
        public string MessageText;
        public byte[] Header;
        public byte[] Footer;
    }

    class Program
    {
        const int FileHeaderSize = 280;
        const int MessageHeaderSize = 32;
        const int ChunkSizeOffset = 28;
        const int FooterSize = 84;

        static void Main(string[] args)
        {
            if (args.Length < 2)
            {
                Console.WriteLine("Usage: ChunkFileProcessor <inputfile> <outputfile>");
                return;
            }

            string inputPath = args[0];
            string outputPath = args[1];

            if (!File.Exists(inputPath))
            {
                Console.WriteLine("File not found: " + inputPath);
                return;
            }

            byte[] fileBytes = File.ReadAllBytes(inputPath);

            // Read file header
            byte[] fileHeader = new byte[FileHeaderSize];
            Array.Copy(fileBytes, 0, fileHeader, 0, FileHeaderSize);

            List<MessageRecord> records = new List<MessageRecord>();

            int pos = FileHeaderSize;
            while (pos < fileBytes.Length)
            {
                if (pos + MessageHeaderSize > fileBytes.Length) break;
                byte[] header = new byte[MessageHeaderSize];
                Array.Copy(fileBytes, pos, header, 0, MessageHeaderSize);
                pos += MessageHeaderSize;

                int chunkSizeOffset = pos - MessageHeaderSize + ChunkSizeOffset;
                if (chunkSizeOffset + 4 > fileBytes.Length) break;
                int chunkSize = BitConverter.ToInt32(fileBytes, chunkSizeOffset);

                if (pos + chunkSize > fileBytes.Length) break;
                byte[] chunkData = new byte[chunkSize];
                Array.Copy(fileBytes, pos, chunkData, 0, chunkSize);
                string message = Encoding.UTF8.GetString(chunkData);
                pos += chunkSize;

                if (pos + FooterSize > fileBytes.Length) break;
                byte[] footer = new byte[FooterSize];
                Array.Copy(fileBytes, pos, footer, 0, FooterSize);
                pos += FooterSize;

                records.Add(new MessageRecord
                {
                    MessageText = message,
                    Header = header,
                    Footer = footer
                });
            }

            // Example update/translation step
            for (int i = 0; i < records.Count; i++)
            {
                records[i] = new MessageRecord
                {
                    MessageText = records[i].MessageText.ToUpper(),
                    Header = records[i].Header,
                    Footer = records[i].Footer
                };
            }

            using (var ms = new MemoryStream())
            using (var bw = new BinaryWriter(ms))
            {
                bw.Write(fileHeader);

                foreach (var rec in records)
                {
                    bw.Write(rec.Header);
                    byte[] msgBytes = Encoding.UTF8.GetBytes(rec.MessageText);
                    bw.Write(msgBytes);
                    bw.Write(rec.Footer);
                }

                File.WriteAllBytes(outputPath, ms.ToArray());
            }

            Console.WriteLine($"Done. {records.Count} records processed.");
            Console.WriteLine($"Output written to: {outputPath}");
        }
    }
}