using System;
using System.IO;
using System.Text;
using System.Xml;

/// <header>
/// <wox>
///     <version>1.0</version>
///     <author>Carlos R. Jaimez Gonzalez</author>
///     <author>Simon M. Lucas</author>
///     <site>http://woxserializer.sourceforge.net/</site>
/// </wox>
/// <wox>
///     <version>1.5</version>
///     <author>Steven M Lewis</author>
/// </wox>
/// <wox>
///     <version>2.0</version>
///     <author>George A Smith</author>
///     <svn>http://woxserializer.sourceforge.net/</svn>
///     <note>XML form for vs 2 is more compact and therefor incompatible with vs 1</note>
/// </wox>
/// </header>

namespace wox.serial
{
    public interface XMLreader : IDisposable
    {
        /// <summary>
        /// Advances the Cursor to the NEXT Start Element.
        /// Note: on creation, an XMLreader is positioned BEFORE any Elements / XML nodes
        /// </summary>
        /// <returns>true if found a Start Element</returns>
        bool ReadStartElement();

        bool HasAttributesOrElementText();

        /// <summary>
        /// Create a Subtree reader, which will an XMLreader that is positioned just before the currently read Start Element.
        /// As the next ReadStartElement would fetch the last read element "as" the root element of this XMLreader, the behavior
        /// is the same as a regular new XMLreader.
        /// Note: After the End Element of the fax root element, ReadStartElement will return false.
        /// </summary>
        XMLreader CreateSubtreeReader();

        string GetAttribute( string pName );

        string ReadElementText();
    }

    public interface XMLwriter : IDisposable
    {
        void WriteStartElement( string pName );

        void WriteAttributeString( string pName, string pValue );

        void WriteElementText( string pElementText );

        void WriteEndElement();
    }

    public class XMLreaderImpl : XMLreader
    {
        private readonly XmlReader mReader;

        public XMLreaderImpl( TextReader pReader )
        {
            mReader = new XmlTextReader( pReader )
                          {
                              WhitespaceHandling = WhitespaceHandling.None
                          };
        }

        private XMLreaderImpl( XmlReader pReader )
        {
            mReader = pReader;
        }

        public XMLreader CreateSubtreeReader()
        {
            return new XMLreaderImpl( mReader.ReadSubtree() );
        }

        public bool ReadStartElement()
        {
            while ( mReader.Read() )
            {
                if ( mReader.NodeType == XmlNodeType.Element )
                {
                    return true;
                }
            }
            return false;
        }

        public bool HasAttributesOrElementText()
        {
            return mReader.HasAttributes || !mReader.IsEmptyElement;
        }

        public string GetAttribute( string pName )
        {
            return XMLutils.DecodeText( mReader.GetAttribute( pName ) );
        }

        public string ReadElementText()
        {
            return XMLutils.DecodeText( mReader.ReadString() ?? "" );
        }

        public void Dispose()
        {
            try
            {
                mReader.Close();
            }
            catch ( Exception )
            {
                // Whatever!
            }
        }
    }

    public class XMLwriterImpl : XMLwriter
    {
        private readonly XmlTextWriter mWriter;

        public XMLwriterImpl( TextWriter pWriter, bool pPrettyPrint )
        {
            mWriter = new XmlTextWriter( pWriter );

            if ( pPrettyPrint )
            {
                mWriter.Formatting = Formatting.Indented;
            }
        }

        public void WriteStartElement( string pName )
        {
            mWriter.WriteStartElement( pName );
        }

        public void WriteAttributeString( string pName, string pValue )
        {
            mWriter.WriteAttributeString( pName, XMLutils.EncodeText( pValue ) );
        }

        public void WriteElementText( string pElementText )
        {
            mWriter.WriteString( XMLutils.EncodeText( pElementText ) );
        }

        public void WriteEndElement()
        {
            mWriter.WriteEndElement();
        }

        public void Dispose()
        {
            try
            {
                mWriter.Close();
            }
            catch ( Exception )
            {
                // Whatever!
            }
        }
    }

    public class XMLutils
    {
        public static string EncodeText( string pText )
        {
            if ( pText == null )
            {
                return null;
            }
            StringBuilder zSB = new StringBuilder();
            CharSource zSource = new CharSource( pText );
            for ( int c; -1 != (c = zSource.Get()); )
            {
                switch ( c )
                {
                    case '\\':
                        zSB.Append( '\\' );
                        zSB.Append( '\\' );
                        break;
                    case '\n':
                        zSB.Append( '\\' );
                        zSB.Append( 'n' );
                        break;
                    case '\r':
                        zSB.Append( '\\' );
                        zSB.Append( 'r' );
                        break;
                    case '\t':
                        zSB.Append( '\\' );
                        zSB.Append( 't' );
                        break;
                    default:
                        if ( (' ' <= c) && (c < 127) )
                        {
                            zSB.Append( (char) c );
                            break;
                        }
                        zSB.Append( '\\' );
                        zSB.Append( 'x' );
                        zSB.Append( ToHexDigit( c >> 24 ) );
                        zSB.Append( ToHexDigit( c >> 16 ) );
                        zSB.Append( ToHexDigit( c >> 8 ) );
                        zSB.Append( ToHexDigit( c ) );
                        break;
                }
            }
            return zSB.ToString();
        }

        public static string DecodeText( string pText )
        {
            if ( pText == null )
            {
                return null;
            }
            StringBuilder zSB = new StringBuilder();
            CharSource zSource = new CharSource( pText );
            for ( int c; -1 != (c = zSource.Get()); )
            {
                if ( (c < ' ') || (127 <= c) )
                {
                    throw new ArgumentException( "Decoding Error: Char[" + zSource.GetLastFrom() + "] Not between ' ' & Ascii 126 (inclusive)" );
                }
                if ( c != '\\' )
                {
                    zSB.Append( (char) c );
                    continue;
                }
                if ( -1 == (c = zSource.Get()) )
                {
                    throw new ArgumentException( "Decoding Error: No Char after escape \\" );
                }
                switch ( c )
                {
                    case '\\':
                        zSB.Append( (char) c );
                        break;
                    case 'n':
                        zSB.Append( '\n' );
                        break;
                    case 'r':
                        zSB.Append( '\r' );
                        break;
                    case 't':
                        zSB.Append( '\t' );
                        break;
                    case 'x':
                        int c1 = zSource.Get();
                        int c2 = zSource.Get();
                        int c3 = zSource.Get();
                        int c4 = zSource.Get();
                        if ( c4 == -1 )
                        {
                            throw new ArgumentException( "Decoding Error: Not enough Chars after \\x" );
                        }
                        try
                        {
                            int zChar = (FromHexDigit( (char) c1 ) << 24) + //
                                        (FromHexDigit( (char) c2 ) << 16) + //
                                        (FromHexDigit( (char) c3 ) << 8) + //
                                        FromHexDigit( (char) c4 );
                            zSB.Append( (char) zChar );
                        }
                        catch ( ArgumentException e )
                        {
                            throw new ArgumentException( "Decoding Error: After \\x expected 4 hex digits: " + e.Message );
                        }
                        break;
                    default:
                        throw new ArgumentException( "Decoding Error: Invalid Char '" + c + "' after escape \\" );
                }
            }
            return zSB.ToString();
        }

        public static char ToHexDigit( int pZeroTo15 )
        {
            pZeroTo15 &= 15;
            return (pZeroTo15 < 0) || (15 < pZeroTo15) ? '?' : HEX[pZeroTo15];
        }

        public static int FromHexDigit( char pHex )
        {
            int rv = HEX.IndexOf( pHex );
            if ( rv == -1 )
            {
                throw new ArgumentException( "Not a Hex digit '" + pHex + "': " + (int) pHex );
            }
            return rv;
        }

        private const String HEX = "0123456789ABCDEF";
    }
}