using System;
using System.Collections;
using System.Reflection;
using System.Xml;

using BLToolkit.TypeBuilder;

namespace BLToolkit.EditableObjects
{
    [Serializable]
    public class EditableXmlDocument: IEditable, ISetParent, IMemberwiseEditable, IPrintDebugState
    {
        private          Stack                      _changedNodes;
        private          XmlDocument                _original;
        private          XmlDocument                _current;
        private          IPropertyChanged           _parent;
        private          PropertyInfo               _propertyInfo;

        public EditableXmlDocument()
            : this(new XmlDocument())
        {
        }

        public EditableXmlDocument(XmlDocument value)
        {
            _changedNodes = null;
            _current      = value;
            _original     = value;

            StartXmlDocTracking();
        }

        [GetValue, SetValue]
        public XmlDocument Value
        {
            get { return _current; }
            set
            {
                if (_current == value)
                    return;

                if (_current == _original)
                    StopXmlDocTracking();

                // Drop changes, if any.
                //
                if (_changedNodes != null)
                    _changedNodes.Clear();

                _current = value;

                if (_current == _original)
                    StartXmlDocTracking();
            }
        }

        private void StartXmlDocTracking()
        {
            if (_current == null)
                return;

            _current.NodeInserted += HandleNodeChanged;
            _current.NodeRemoved  += HandleNodeChanged;
            _current.NodeChanged  += HandleNodeChanged;
        }

        private void StopXmlDocTracking()
        {
            if (_current == null)
                return;

            _current.NodeInserted -= HandleNodeChanged;
            _current.NodeRemoved  -= HandleNodeChanged;
            _current.NodeChanged  -= HandleNodeChanged;
        }

        private void HandleNodeChanged(object sender, XmlNodeChangedEventArgs ea)
        {
            if (ea.Action == XmlNodeChangedAction.Change && ea.NewValue == ea.OldValue)
            {
                // A void change can be ignored.
                //
                return;
            }

            if (_changedNodes == null)
                _changedNodes = new Stack();

            _changedNodes.Push(new XmlNodeTrackBack(ea));

            // Propagate changes to parent object, if set.
            //
            if (_parent != null)
                _parent.OnPropertyChanged(_propertyInfo);
        }

        #region IEditable Members

        public void AcceptChanges()
        {
            if (_original != _current)
            {
                _original = _current;
                StartXmlDocTracking();
            }
            else
            {
                // Let them go away.
                //
                if (_changedNodes != null)
                    _changedNodes.Clear();
            }
        }

        public void RejectChanges()
        {
            if (_original != _current)
            {
                _current = _original;
                StartXmlDocTracking();
            }
            else if (_changedNodes != null && _changedNodes.Count > 0)
            {
                // Don't fall into an infinite loop.
                //
                StopXmlDocTracking();

                // A Stack enumerates from back to front.
                //
                foreach (XmlNodeTrackBack nodeTrackBack in _changedNodes)
                {
                    switch (nodeTrackBack.Action)
                    {
                        case XmlNodeChangedAction.Insert:
                            if (nodeTrackBack.Node.NodeType == XmlNodeType.Attribute)
                                ((XmlElement)nodeTrackBack.Value).Attributes.Remove((XmlAttribute)nodeTrackBack.Node);
                            else
                                ((XmlNode)nodeTrackBack.Value).RemoveChild(nodeTrackBack.Node);
                            break;
                        case XmlNodeChangedAction.Remove:
                            // NB: The order of children nodes may change.
                            //
                            if (nodeTrackBack.Node.NodeType == XmlNodeType.Attribute)
                                ((XmlElement)nodeTrackBack.Value).Attributes.Append((XmlAttribute)nodeTrackBack.Node);
                            else
                                ((XmlNode)nodeTrackBack.Value).AppendChild(nodeTrackBack.Node);
                            break;
                        case XmlNodeChangedAction.Change:
                            nodeTrackBack.Node.Value = (string)nodeTrackBack.Value;
                            break;
                    }
                }

                _changedNodes.Clear();
                StartXmlDocTracking();
            }
        }

        public bool IsDirty
        {
            get
            {
                if (_current == _original)
                    return _changedNodes != null && _changedNodes.Count > 0;

                if (_current == null || _original == null)
                    return true;

                return _current.InnerXml.TrimEnd() != _original.InnerXml.TrimEnd();
            }
        }

        #endregion

        #region IMemberwiseEditable Members

        public bool AcceptMemberChanges(PropertyInfo propertyInfo, string memberName)
        {
            if (memberName != propertyInfo.Name)
                return false;

            AcceptChanges();

            return true;
        }

        public bool RejectMemberChanges(PropertyInfo propertyInfo, string memberName)
        {
            if (memberName != propertyInfo.Name)
                return false;

            RejectChanges();

            return true;
        }

        public bool IsDirtyMember(PropertyInfo propertyInfo, string memberName, ref bool isDirty)
        {
            if (memberName != propertyInfo.Name)
                return false;

            isDirty = IsDirty;

            return true;
        }

        public void GetDirtyMembers(PropertyInfo propertyInfo, ArrayList list)
        {
            if (IsDirty)
                list.Add(propertyInfo);
        }

        #endregion

        #region IPrintDebugState Members

        public void PrintDebugState(PropertyInfo propertyInfo, ref string str)
        {
            str += string.Format("{0,-20} {1} {2,-80}\r\n",
                propertyInfo.Name, IsDirty? "*": " ", _current != null? _current.OuterXml: "(null)");
        }

        #endregion

        #region ISetParent Members

        public void SetParent(object parent, PropertyInfo propertyInfo)
        {
            _parent       = parent as IPropertyChanged;
            _propertyInfo = propertyInfo;
        }

        #endregion

        #region Inner types

        private struct XmlNodeTrackBack
        {
            public readonly XmlNode              Node;
            public readonly XmlNodeChangedAction Action;
            public readonly object               Value;

            public XmlNodeTrackBack(XmlNodeChangedEventArgs ea)
            {
                Node   = ea.Node;
                Action = ea.Action;
                switch(ea.Action)
                {
                    case XmlNodeChangedAction.Insert:
                        Value = ea.NewParent;
                        break;
                    case XmlNodeChangedAction.Remove:
                        Value = ea.OldParent;
                        break;
                    case XmlNodeChangedAction.Change:
                        Value = ea.OldValue;
                        break;
                    default:
                        throw new ArgumentOutOfRangeException("ea", ea.Action, string.Format("Unknown XmlNodeChangedAction"));
                }
            }
        }

        #endregion

    }
}