using System;
using System.Collections.Generic;
using System.Text;
using System.Xml;

namespace Aneef.XMLCompare
{
    class XmlCompare
    {
        XmlDocument output = new XmlDocument();
        XmlNode properties;

        /// <summary>
        /// Compares 2 XML and returns an output xml of updated properties
        /// Developed by: Aneef Fashir
		/// Blog: http://www.aneef.net        
        /// Date : 10/09/2008
        /// </summary>
        /// <param name="existing"> Existing Property XML</param>
        /// <param name="Updated">New Objects Property XML</param>
        /// <returns>XMLDocument Document</returns>
        public  XmlDocument compare(string existing, string Updated)
        {

            XmlDocument currentXML = new XmlDocument();
            currentXML.LoadXml(existing);

            XmlDocument updatedXML = new XmlDocument();
            updatedXML.LoadXml(Updated);

            XmlNode cProperty = currentXML.SelectSingleNode("Properties").CloneNode(true);
            XmlNode nProperty = updatedXML.SelectSingleNode("Properties").CloneNode(true);
            prepareOutput(cProperty.CloneNode(false));
            try
            {
                foreach (XmlNode child in cProperty.ChildNodes)
                {

                    foreach (XmlNode uChild in nProperty.ChildNodes)
                    {

                        if (child.OuterXml == uChild.OuterXml)
                        {
                            addNode(child);
                        }
                        else
                        {
                            if (child.Attributes["Name"].Value == uChild.Attributes["Name"].Value)
                            {
                                updateMatchingName(child.InnerXml, uChild);
                            }
                        }
                    }
                }
                foreach (XmlNode updnode in nProperty.ChildNodes)
                {
                    bool isExists = false;
                    foreach (XmlNode mynode in properties.ChildNodes)
                    {
                        if (mynode.Attributes["Name"].Value == updnode.Attributes["Name"].Value)
                        {
                            isExists = true;
                        }
                    }

                    if (isExists == false)
                    {
                        addNode(updnode);
                    }
                }

                return output;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }


        /// <summary>
        /// Prepare Parent Properties Node
        /// </summary>
        /// <param name="parentnode">XMLNode ParentNode</param>
        private  void prepareOutput(XmlNode parentnode)
        {
            try
            {
                properties = output.CreateElement("Properties");
                addAttributes(ref properties, parentnode);
                output.AppendChild(properties);
            }
            catch (Exception ex)
            {
                
                throw ex;
            }
           
        }
        /// <summary>
        /// Add Attributes of updated nodes to the output node
        /// </summary>
        /// <param name="outputNode">XMLNode output</param>
        /// <param name="ExistingNode">XMLNode existingnode</param>
        private  void addAttributes(ref XmlNode outputNode,XmlNode ExistingNode)
        {

            try
            {
                XmlAttribute[] atribs = new XmlAttribute[ExistingNode.Attributes.Count];

                ExistingNode.Attributes.CopyTo(atribs, 0);

                foreach (XmlAttribute atb in atribs)
                {
                    XmlAttribute bt = outputNode.OwnerDocument.CreateAttribute(atb.Name);
                    bt.Value = atb.Value;
                    outputNode.Attributes.Append(bt);
                }
            }
            catch (Exception ex)
            {
                
                throw ex;
            }
          
        }


        /// <summary>
        /// Add an entire node from existing to the new one
        /// </summary>
        /// <param name="outputnode">XMLNode Output</param>
        private  void addNode(XmlNode outputnode)
        {
            try
            {
                XmlNode property = output.CreateElement(outputnode.Name);
                addAttributes(ref property, outputnode);
                property.InnerXml = outputnode.InnerXml;
                properties.AppendChild(property);
            }
            catch (Exception ex)
            {
                
                throw ex;
            }
                       
        }

        /// <summary>
        /// Update Nodes which their Name attributes values are equal.
        /// element value will be taken from exisiting node, and the atttributes will be taken from the new node.
        /// </summary>
        /// <param name="innerValue">Existing Nodes Element value</param>
        /// <param name="node">XMLNode Updated Node</param>
        private void updateMatchingName(string innerValue, XmlNode node)
        {
            try
            {
                XmlNode property = output.CreateElement(node.Name);
                addAttributes(ref property, node);
                property.InnerXml = innerValue;
                properties.AppendChild(property);
            }
            catch (Exception ex)
            {
                
                throw;
            }
          
        }

    }
}