using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Runtime.Serialization.Formatters;

using System.IO;

using System.Data;

using System.ComponentModel.DataAnnotations;

using System.Globalization;

using System.Reflection;

using System.Collections.ObjectModel;

using System.Xml.Linq;

using System.Runtime.Serialization.Json;

using System.Xml;

​

using NUnit.Framework; // Throws NUnit.Framework.AssertionException

​

//https://stackoverflow.com/questions/59839437/efficiently-replacing-properties-of-a-large-json-using-system-text-json

​

    public static class XmlWriterExtensions

    {

        // Adapted from this answer https://stackoverflow.com/a/28903486

        // to https://stackoverflow.com/questions/28891440/automating-replacing-tables-from-external-files/

        // By https://stackoverflow.com/users/3744182/dbc

​

        /// <summary>

        /// Make a DEEP copy of the current xmlreader node to xmlwriter, allowing the caller to transform selected elements.

        /// </summary>

        /// <param name="writer"></param>

        /// <param name="reader"></param>

        /// <param name="shouldTransform"></param>

        /// <param name="transform"></param>

        public static void WriteTransformedNode(this XmlWriter writer, XmlReader reader, Predicate<XmlReader> shouldTransform, Action<XmlReader, XmlWriter> transform)

        {

            if (reader == null || writer == null || shouldTransform == null || transform == null)

                throw new ArgumentNullException();

​

            int d = reader.NodeType == XmlNodeType.None ? -1 : reader.Depth;

            do

            {

                if (reader.NodeType == XmlNodeType.Element && shouldTransform(reader))

                {

                    using (var subReader = reader.ReadSubtree())

                    {

                        transform(subReader, writer);

                    }

                    // ReadSubtree() places us at the end of the current element, so we need to move to the next node.

                    reader.Read();

                }

                else

                {

                    writer.WriteShallowNode(reader);

                }

            }

            while (!reader.EOF && (d < reader.Depth || (d == reader.Depth && reader.NodeType == XmlNodeType.EndElement)));

        }

​

        /// <summary>

        /// Make a SHALLOW copy of the current xmlreader node to xmlwriter, and advance the XML reader past the current node.

        /// </summary>

        /// <param name="writer"></param>

        /// <param name="reader"></param>

        public static void WriteShallowNode(this XmlWriter writer, XmlReader reader)

        {

            // Adapted from https://docs.microsoft.com/en-us/archive/blogs/mfussell/combining-the-xmlreader-and-xmlwriter-classes-for-simple-streaming-transformations

            // By Mark Fussell https://docs.microsoft.com/en-us/archive/blogs/mfussell/

            // and rewritten to avoid using reader.Value, which fully materializes the text value of a node.

            if (reader == null)

                throw new ArgumentNullException("reader");

            if (writer == null)

                throw new ArgumentNullException("writer");

​

            switch (reader.NodeType)

            {   

                case XmlNodeType.None:

                    // This is returned by the System.Xml.XmlReader if a Read method has not been called.

                    reader.Read();

                    break;

​

                case XmlNodeType.Element:

                    writer.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI);

                    writer.WriteAttributes(reader, true);

                    if (reader.IsEmptyElement)

                    {

                        writer.WriteEndElement();

                    }

                    reader.Read();

                    break;

​

                case XmlNodeType.Text:

                case XmlNodeType.Whitespace:

                case XmlNodeType.SignificantWhitespace:

                case XmlNodeType.CDATA:

                case XmlNodeType.XmlDeclaration:

                case XmlNodeType.ProcessingInstruction:

                case XmlNodeType.EntityReference:

                case XmlNodeType.DocumentType:

                case XmlNodeType.Comment:

                    //Avoid using reader.Value as this will fully materialize the string value of the node.  Use WriteNode instead,

                    // it copies text values in chunks.  See: https://referencesource.microsoft.com/#system.xml/System/Xml/Core/XmlWriter.cs,368

                    writer.WriteNode(reader, true);

                    break;

​

                case XmlNodeType.EndElement:

                    writer.WriteFullEndElement();

                    reader.Read();

                    break;

​

                default:

                    throw new XmlException(string.Format("Unknown NodeType {0}", reader.NodeType));

            }

        }

    }

​

    public static partial class XmlReaderExtensions

    {

        // Taken from this answer https://stackoverflow.com/a/54136179/3744182

        // To https://stackoverflow.com/questions/54126687/xmlreader-how-to-read-very-long-string-in-element-without-system-outofmemoryex

        // By https://stackoverflow.com/users/3744182/dbc

        public static bool CopyBase64ElementContentsToFile(this XmlReader reader, string path)

        {

            using (var stream = File.Create(path))

            {

                byte[] buffer = new byte[8192];

                int readBytes = 0;

​

                while ((readBytes = reader.ReadElementContentAsBase64(buffer, 0, buffer.Length)) > 0)

                {

                    stream.Write(buffer, 0, readBytes);

                }

            }

            return true;

        }

    }

​

    public static class JsonPatchExtensions

    {

        public static string[] PatchFileContentToFileRoute(string oldJsonFileName, string newJsonFileName, FilenameGenerator generator)

        {

            var newNames = new List<string>();

​

            using (var inStream = File.OpenRead(oldJsonFileName))

            using (var outStream = File.Open(newJsonFileName, FileMode.Create))

            using (var xmlReader = JsonReaderWriterFactory.CreateJsonReader(inStream, XmlDictionaryReaderQuotas.Max))

            using (var xmlWriter = JsonReaderWriterFactory.CreateJsonWriter(outStream))

            {

                xmlWriter.WriteTransformedNode(xmlReader, 

                    r => r.LocalName == "fileContent" && r.NamespaceURI == "",

                    (r, w) =>

                    {

                        r.MoveToContent();

                        var name = generator.GenerateNewName();

                        r.CopyBase64ElementContentsToFile(name);

                        w.WriteStartElement("fileRoute", "");

                        w.WriteAttributeString("type", "string");

                        w.WriteString(name);

                        w.WriteEndElement();

                        newNames.Add(name);

                    });

            }

​

            return newNames.ToArray();

        }

    }

​

    public abstract class FilenameGenerator

    {

        public abstract string GenerateNewName();

    }

​

    // Replace the following with whatever algorithm you need to generate unique binary file names.

​

    public class IncrementalFilenameGenerator : FilenameGenerator

    {

        readonly string prefix;

        readonly string extension;

        int count = 0;

​

        public IncrementalFilenameGenerator(string prefix, string extension)

        {

            this.prefix = prefix;

            this.extension = extension;

        }

​

        public override string GenerateNewName()

        {

            var newName = Path.ChangeExtension(prefix + (++count).ToString(), extension);

            return newName;

        }

    }

​

    public class FileNameAndContent

    {

        public string name { get; set; }

        public byte [] fileContent { get; set; }

    }

​

    public class RootObject

    {

        public RootObject() { this.files = new List<FileNameAndContent>(); }

​

        public List<FileNameAndContent> files { get; set; }

    }

​

    public class OutFileNameAndContent

    {

        public string name { get; set; }

        public string fileRoute { get; set; }

    }

​

    public class OutRootObject

    {

        public OutRootObject() { this.files = new List<OutFileNameAndContent>(); }

​

        public List<OutFileNameAndContent> files { get; set; }

    }

​

    class TestClass

    {

        static string GetOldJsonFileName(int n) { return string.Format("{0}_{1}.json", "Question59839437", n); }

        static string GetNewJsonFileName(int n) { return string.Format("{0}_{1}_Patched.json", "Question59839437", n); }

​

        public static void Test()

        {

            Test(0, true);

            Test(1, true);

            Test(100, true);

            Test(1000, false);

            Test(100000, false);

            Test(400000, false);

​

            Console.WriteLine("All tests passed.");

        }

​

        public static void Test(int numberOfBytes, bool printFileContents)

        {

            Console.WriteLine();

            var oldFile = GetOldJsonFileName(numberOfBytes);

            var newFile = GetNewJsonFileName(numberOfBytes);

​

            // Create the JSON test case.

            CreateJson(oldFile, numberOfBytes);

​

            // Assert the reader can read in chunks

            using (var inStream = File.OpenRead(oldFile))

            using (var xmlReader = JsonReaderWriterFactory.CreateJsonReader(inStream, XmlDictionaryReaderQuotas.Max))

            {

                // Assert this reader actually supports reading values in chunks.

                Assert.IsTrue(xmlReader.CanReadValueChunk, "xmlReader.CanReadValueChunk");

            }

​

            // Test that the algorithm can read and write a file without changing it.

            TestNullPatch(oldFile, newFile);

​

            // Test that the algorithm can make the necessary patch

            var binaryFiles = TestPatch(oldFile, newFile, printFileContents);

​

            // Clean up.

            foreach (var f in binaryFiles.Concat(new [] { oldFile, newFile }))

                File.Delete(f);

        }

​

        static string[] TestPatch(string oldJsonFileName, string newJsonFileName, bool printFileContents)

        {

            var binaryFileNames = JsonPatchExtensions.PatchFileContentToFileRoute(

                oldJsonFileName, 

                newJsonFileName,

                // Replace the following with your actual binary file name generation algorithm

                new IncrementalFilenameGenerator("Question59839437_fileContent_", ".bin"));

​

            RootObject oldRoot;

​

            using (var textReader = new StreamReader(oldJsonFileName))

            using (var reader = new Newtonsoft.Json.JsonTextReader(textReader))

                oldRoot = Newtonsoft.Json.JsonSerializer.CreateDefault().Deserialize<RootObject>(reader);

​

            Assert.IsTrue(oldRoot.files.Count == binaryFileNames.Length);

            for (int i = 0; i < oldRoot.files.Count; i++)

            {

                var bytes = File.ReadAllBytes(binaryFileNames[i]);

​

                Assert.IsTrue(bytes.SequenceEqual(oldRoot.files[0].fileContent));

            }

​

            Console.WriteLine(string.Format("Patching of fileContent in {0} to fileRoute in {1} with binary files [{2}] resulted in identical binary data.", oldJsonFileName, newJsonFileName, string.Join(",", binaryFileNames)));

​

            if (printFileContents)

            {

                Console.WriteLine("Input file {0}:", oldJsonFileName);

                Console.Write("   ");

                Console.WriteLine(File.ReadAllText(oldJsonFileName));

                Console.WriteLine("Patched file {0}:", newJsonFileName);

                Console.Write("   ");

                Console.WriteLine(File.ReadAllText(newJsonFileName));

            }

            return binaryFileNames;

        }

​

        static void TestNullPatch(string oldJsonFileName, string newJsonFileName)

        {

            NullPatch(oldJsonFileName, newJsonFileName);

​

            Assert.IsTrue(EqualJsonFiles(oldJsonFileName, newJsonFileName));

            Console.WriteLine(string.Format("Null patch of {0} to {1} produced equivalent JSON files.", oldJsonFileName, newJsonFileName));

        }

​

        private static void NullPatch(string oldJsonFileName, string newJsonFileName)

        {

            // Stream from the old JSON file to the new without actually changing anything.  

            // For testing whether the basic logic works.

            using (var inStream = File.OpenRead(oldJsonFileName))

            using (var outStream = File.Open(newJsonFileName, FileMode.Create))

            using (var xmlReader = JsonReaderWriterFactory.CreateJsonReader(inStream, XmlDictionaryReaderQuotas.Max))

            using (var xmlWriter = JsonReaderWriterFactory.CreateJsonWriter(outStream))

            {

                xmlWriter.WriteTransformedNode(xmlReader, r => false, (r, w) => { });

            }

        }

​

        static void CreateJson(string fileName, int numberOfBytes)

        {

            var root = new RootObject

            {

                files =

                {

                    new FileNameAndContent { name = "One Name", fileContent = Enumerable.Range(0, numberOfBytes).Select(i => unchecked((byte)i)).ToArray() },

                },

            };

​

            using (var textWriter = new StreamWriter(fileName, false))

            using (var jsonWriter = new Newtonsoft.Json.JsonTextWriter(textWriter))

            {

                Newtonsoft.Json.JsonSerializer.CreateDefault().Serialize(jsonWriter, root);

            }

        }

​

        static bool EqualJsonFiles(string inFile, string outFile)

        {

            Newtonsoft.Json.Linq.JToken inToken, outToken;

​

            using (var textReader = new StreamReader(inFile))

            using (var reader = new Newtonsoft.Json.JsonTextReader(textReader))

                inToken = Newtonsoft.Json.Linq.JToken.Load(reader);

​

            using (var textReader = new StreamReader(inFile))

            using (var reader = new Newtonsoft.Json.JsonTextReader(textReader))

                outToken = Newtonsoft.Json.Linq.JToken.Load(reader);

​

            return Newtonsoft.Json.Linq.JToken.DeepEquals(inToken, outToken);

        }

​

        static XElement CreateOutputSample()

        {

            var outRoot = new OutRootObject

            {

                files =

                {

                    new OutFileNameAndContent { name = "One Name", fileRoute = "fooName1.json" }

                },

            };

​

            var json = Newtonsoft.Json.JsonConvert.SerializeObject(outRoot);

​

            using (var reader = JsonReaderWriterFactory.CreateJsonReader(new UTF8Encoding(false).GetBytes(json), XmlDictionaryReaderQuotas.Max))

            {

                return XElement.Load(reader);

            }

        }

    }

​

    public class Program

    {

        public static void Main()

        {

            Console.WriteLine("Environment version: {0} ({1})", System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription , GetNetCoreVersion());

            Console.WriteLine();

​

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

                Console.WriteLine("Failed with unhandled exception: ");

                Console.WriteLine(ex);

                throw;

            }

        }

        public static string GetNetCoreVersion()

        {

            //https://techblog.dorogin.com/how-to-detect-net-core-version-in-runtime-ecd65ad695be

            //

            var assembly = typeof(System.Runtime.GCSettings).GetTypeInfo().Assembly;

            var assemblyPath = assembly.CodeBase.Split(new[] { '/', '\\' }, StringSplitOptions.RemoveEmptyEntries);

            int netCoreAppIndex = Array.IndexOf(assemblyPath, "Microsoft.NETCore.App");

            if (netCoreAppIndex > 0 && netCoreAppIndex < assemblyPath.Length - 2)

                return assemblyPath[netCoreAppIndex + 1];

            return null;

        }

    }

​