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

/// <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 class SourceCodeGenerator
    {
        public static readonly SourceCodeGenerator[] EMPTY = new SourceCodeGenerator[0];

        protected static readonly string CSHARP_LANG_PACKAGE = "System.";

        public static readonly string[] ACCESS = new[] {"public ", "protected ", "private ", ""};

        public enum Access
        {
            PUBLIC = 0,
            PROTECTED,
            PRIVATE,
            PACKAGE
        }

        private static string GetAccessForm( Access pAccess )
        {
            return ACCESS[(int) pAccess];
        }

        public static readonly string INDENT = "    ";

        public interface MultiFactory
        {
            string GetName();

            SourceCodeGenerator[] GetSourceCodeGenerators();
        }

        private readonly string mReportingType;
        private readonly string mExternalReference; // eg a File...getPath()
        private Access mClassAccess = Access.PUBLIC;
        private string mClassModifiers = "";
        private string mCurTabDepth = "";
        private readonly StringBuilder mSourceCodeText = new StringBuilder();
        private bool mNamespaceAdded, mNamespaceOpen;
        private bool mOverwrite = true;

        public SourceCodeGenerator( string pReportingType, string pExternalReference )
        {
            mReportingType = pReportingType;
            mExternalReference = pExternalReference;
        }

        public string GetReportingType()
        {
            return mReportingType;
        }

        public string GetExternalReference()
        {
            return mExternalReference;
        }

        public bool IsOverwrite()
        {
            return mOverwrite;
        }

        public void SetOverwrite( bool pOverwrite )
        {
            mOverwrite = pOverwrite;
        }

        public void AddNamespace( string pNamespaceName )
        {
            if ( !IsNotNullOrEmpty( pNamespaceName ) )
            {
                throw new ArgumentException( "NamespaceName Required" );
            }
            AssertNamespaceNotAdded( "AddNamespace" );
            if ( mSourceCodeText.Length != 0 )
            {
                AddBlankLine();
            }
            AddLine( "namespace " + pNamespaceName.Trim() );
            mNamespaceAdded = mNamespaceOpen = true;
            AddBlockStart();
        }

        public void AddNamespaceEnd()
        {
            AssertNamespaceOpen( "AddNamespaceEnd" );
            AddBlockEnd();
            mNamespaceOpen = false;
        }

        public void IndentStart()
        {
            mCurTabDepth += INDENT;
        }

        public void IndentEnd()
        {
            if ( mCurTabDepth.StartsWith( INDENT ) )
            {
                mCurTabDepth = mCurTabDepth.Substring( INDENT.Length );
            }
        }

        public void IndentPlus( int pBy )
        {
            while ( pBy-- > 0 )
            {
                mCurTabDepth += " ";
            }
        }

        public void IndentMinus( int pBy )
        {
            while ( mCurTabDepth.StartsWith( " " ) && (pBy-- > 0) )
            {
                mCurTabDepth = mCurTabDepth.Substring( 1 );
            }
        }

        public void IndentedAddLine( string pLine )
        {
            IndentStart();
            AddLine( pLine );
            IndentEnd();
        }

        public void DoubleIndentedAddLine( string pLine )
        {
            IndentStart();
            IndentedAddLine( pLine );
            IndentEnd();
        }

        public void AddLineIf( string pLine, bool pAdd )
        {
            if ( pAdd )
            {
                AddLine( pLine );
            }
        }

        public void AddLine( string pLine )
        {
            if ( IsNotNullOrEmpty( pLine ) )
            {
                mSourceCodeText.Append( mCurTabDepth ).Append( pLine );
            }
            mSourceCodeText.Append( '\n' );
        }

        public void AddLines( params string[] pLines )
        {
            if ( pLines != null )
            {
                foreach ( string line in pLines )
                {
                    if ( line != null )
                    {
                        AddLine( line );
                    }
                }
            }
        }

        public void AddLines( List<string> pLines )
        {
            if ( pLines != null )
            {
                foreach ( string line in pLines )
                {
                    if ( line != null )
                    {
                        AddLine( line );
                    }
                }
            }
        }

        public void AddBlankLine()
        {
            mSourceCodeText.Append( '\n' );
        }

        public void AddBlockStart()
        {
            AssertNamespaceOpen( "AddBlockStart" );
            AddLine( "{" );
            IndentStart();
        }

        public void AddBlockStart( string pPlus )
        {
            AssertNamespaceOpen( "AddBlockStart" );
            AddLine( "{" + pPlus );
            IndentStart();
        }

        public void AddBlockEnd()
        {
            AssertNamespaceOpen( "AddBlockEnd" );
            IndentEnd();
            AddLine( "}" );
        }

        public void AddBlockEnd( string pPlus )
        {
            AssertNamespaceOpen( "AddBlockEnd" );
            IndentEnd();
            AddLine( "}" + pPlus );
        }

        public void AddUsings( params string[] pUsingRefs )
        {
            if ( pUsingRefs != null )
            {
                AssertNamespaceNotAdded( "AddUsings" );
                foreach ( string zImportRef in pUsingRefs )
                {
                    AddUsing( zImportRef );
                }
                AddBlankLine();
            }
        }

        public void AddUsing( string pUsingRef )
        {
            if ( pUsingRef != null )
            {
                AssertNamespaceNotAdded( "AddUsing" );
                if ( pUsingRef.Length != 0 )
                {
                    AddLine( "using " + pUsingRef );
                }
                else
                {
                    AddBlankLine();
                }
            }
        }

        public void AddInterfaceDefinition( string pInterfaceName, params string[] pExtendsNames )
        {
            AssertNamespaceOpen( "AddInterfaceDefinition" );
            AddLine( "public interface " + pInterfaceName );

            string extendsName = CsEm( pExtendsNames );

            if ( IsNotNullOrEmpty( extendsName ) )
            {
                DoubleIndentedAddLine( "extends " + extendsName );
            }
            AddBlockStart();
        }

        public void AddInterfaceEnd()
        {
            AssertNamespaceOpen( "AddInterfaceEnd" );
            AddBlockEnd();
        }

        public void MakeClassAbstract()
        {
            mClassModifiers += "abstract ";
        }

        public void MakeClassStatic()
        {
            mClassModifiers += "static ";
        }

        public void MakeClassPrivate()
        {
            mClassAccess = Access.PRIVATE;
        }

        public void MakeClassProtected()
        {
            mClassAccess = Access.PROTECTED;
        }

        public void MakeClassPackageFriendly()
        {
            mClassAccess = Access.PACKAGE;
        }

        private Access GetClassAccess()
        {
            Access rv = mClassAccess;
            mClassAccess = Access.PUBLIC;
            return rv;
        }

        private string GetClassModifiers()
        {
            string rv = mClassModifiers;
            mClassModifiers = "";
            return rv;
        }

        public void AddClassDefinition( string pClassName )
        {
            AddClassDefinition( pClassName, null, null );
        }

        // Note: Can NOT use VarArgs as they would collide with other method!
        public void AddClassDefinition( string pClassName, string[] pImplementsNames )
        {
            AddClassDefinition( pClassName, null, pImplementsNames );
        }

        public void AddClassDefinition( string pClassName, string pExtendsName, params string[] pImplementsNames )
        {
            AssertNamespaceOpen( "AddClassDefinition" );
            AddLine( GetAccessForm( GetClassAccess() ) + GetClassModifiers() + "class " + pClassName );

            if ( IsNotNullOrEmpty( pExtendsName ) )
            {
                DoubleIndentedAddLine( "extends " + pExtendsName.Trim() );
            }
            string implementsName = CsEm( pImplementsNames );
            if ( IsNotNullOrEmpty( implementsName ) )
            {
                DoubleIndentedAddLine( "implements " + implementsName.Trim() );
            }
            AddBlockStart();
        }

        public void AddClassEnd()
        {
            AssertNamespaceOpen( "AddClassEnd" );
            AddBlockEnd();
        }

        public void AddPSFS( string pConstantName, string pValue )
        {
            AssertNamespaceOpen( "AddPSFS" );
            AddLine( "public const string " + pConstantName + " = " + Quote( pValue ) + ";" );
        }

        public string Quote( string pValue )
        {
            return (pValue == null) ? "null" : "\"" + pValue + "\"";
        }

        public void AddConstructorPublic( string pClassName, params string[] pParameters )
        {
            AddConstructor( Access.PUBLIC, pClassName, pParameters );
        }

        public void AddConstructorProtected( string pClassName, params string[] pParameters )
        {
            AddConstructor( Access.PROTECTED, pClassName, pParameters );
        }

        public void AddConstructorPrivate( string pClassName, params string[] pParameters )
        {
            AddConstructor( Access.PRIVATE, pClassName, pParameters );
        }

        public void AddConstructorPackageFriendly( string pClassName, params string[] pParameters )
        {
            AddConstructor( Access.PACKAGE, pClassName, pParameters );
        }

        public void AddConstructor( Access pAccess, string pClassName, params string[] pParameters )
        {
            AssertNamespaceOpen( "AddConstructor" );
            AddLine( GetAccessForm( pAccess ) + pClassName + ParenEm( CsEm( pParameters ) ) );
            AddBlockStart();
        }

        public void AddMethodPublic( string pReturnType, string pMethodName, params string[] pParameters )
        {
            AddMethod( Access.PUBLIC, pReturnType, pMethodName, pParameters );
        }

        public void AddMethodProtected( string pReturnType, string pMethodName, params string[] pParameters )
        {
            AddMethod( Access.PROTECTED, pReturnType, pMethodName, pParameters );
        }

        public void AddMethodPrivate( string pReturnType, string pMethodName, params string[] pParameters )
        {
            AddMethod( Access.PRIVATE, pReturnType, pMethodName, pParameters );
        }

        public void AddMethodPackageFriendly( string pReturnType, string pMethodName, params string[] pParameters )
        {
            AddMethod( Access.PACKAGE, pReturnType, pMethodName, pParameters );
        }

        public void AddMethod( Access pAccess, string pReturnType, string pMethodName, params string[] pParameters )
        {
            AssertNamespaceOpen( "AddMethod" );
            AddLine( GetAccessForm( pAccess ) + pReturnType + " " + pMethodName + ParenEm( CsEm( pParameters ) ) );
            AddBlockStart();
        }

        public void AddStaticMethodPublic( string pReturnType, string pMethodName, params string[] pParameters )
        {
            AddStaticMethod( Access.PUBLIC, pReturnType, pMethodName, pParameters );
        }

        public void AddStaticMethodProtected( string pReturnType, string pMethodName, params string[] pParameters )
        {
            AddStaticMethod( Access.PROTECTED, pReturnType, pMethodName, pParameters );
        }

        public void AddStaticMethodPrivate( string pReturnType, string pMethodName, params string[] pParameters )
        {
            AddStaticMethod( Access.PRIVATE, pReturnType, pMethodName, pParameters );
        }

        public void AddStaticMethodPackageFriendly( string pReturnType, string pMethodName, params string[] pParameters )
        {
            AddStaticMethod( Access.PACKAGE, pReturnType, pMethodName, pParameters );
        }

        private void AddStaticMethod( Access pAccess, string pReturnType, string pMethodName, params string[] pParameters )
        {
            AssertNamespaceOpen( "AddStaticMethod" );
            AddLine( GetAccessForm( pAccess ) + "static " + pReturnType + " " + pMethodName + ParenEm( CsEm( pParameters ) ) );
            AddBlockStart();
        }

        public void AddAbstractMethodPublic( string pReturnType, string pMethodName, params string[] pParameters )
        {
            AddAbstractMethod( Access.PUBLIC, pReturnType, pMethodName, pParameters );
        }

        public void AddAbstractMethodProtected( string pReturnType, string pMethodName, params string[] pParameters )
        {
            AddAbstractMethod( Access.PROTECTED, pReturnType, pMethodName, pParameters );
        }

        private void AddAbstractMethod( Access pAccess, string pReturnType, string pMethodName, params string[] pParameters )
        {
            AssertNamespaceOpen( "AddAbstractMethod" );
            AddLine( "abstract " + GetAccessForm( pAccess ) + pReturnType + " " + pMethodName + ParenEm( CsEm( pParameters ) ) + ";" );
        }

        public void AddMethodEnd()
        {
            AssertNamespaceOpen( "AddMethodEnd" );
            AddBlockEnd();
            AddBlankLine();
        }

        public void AddInterfaceMethodDefinition( string pReturnType, string pMethodName, params string[] pParameters )
        {
            AssertNamespaceOpen( "AddInterfaceMethodDefinition" );
            AddLine( "public " + pReturnType + " " + pMethodName + ParenEm( CsEm( pParameters ) ) );
            AddBlankLine();
        }

        public void AddTryStart()
        {
            AssertNamespaceOpen( "AddTryStart" );
            AddLine( "try" );
            AddBlockStart();
        }

        public void AddTryEnd()
        {
            AssertNamespaceOpen("AddTryEnd");
            AddBlockEnd();
        }

        public void AddCatch(string pClause)
        {
            AssertNamespaceOpen( "AddCatch" );
            AddBlockEnd();
            AddLine( "catch ( " + pClause + " )" );
            AddBlockStart();
        }

        public void AddCatchEnd()
        {
            AssertNamespaceOpen( "AddCatchEnd" );
            AddBlockEnd();
        }

        private static string CsEm( string[] pNames )
        {
            if ( (pNames != null) && (pNames.Length > 0) )
            {
                StringBuilder sb = new StringBuilder();
                foreach ( string name in pNames )
                {
                    if ( IsNotNullOrEmpty( name ) )
                    {
                        sb.Append( ", " );
                        sb.Append( name );
                    }
                }
                if ( sb.Length != 0 )
                {
                    return sb.ToString().Substring( 2 );
                }
            }
            return null;
        }

        public string ParenEm( string pParameters )
        {
            return IsNotNullOrEmpty( pParameters ) ? "( " + pParameters.Trim() + " )" : "()";
        }

        public override string ToString()
        {
            return mSourceCodeText.ToString();
        }

        protected static bool IsNotNullOrEmpty( string pStringToCheck )
        {
            return ((pStringToCheck != null) && (pStringToCheck.Trim().Length != 0));
        }

        private void AssertNamespaceNotAdded( string pWhat )
        {
            if ( mNamespaceAdded )
            {
                throw new ApplicationException( "Can not '" + pWhat + "' because the 'namespace' has already been " + //
                                                (!mNamespaceOpen ? "closed/ended" : "added/opened") );
            }
        }

        private void AssertNamespaceOpen( string pWhat )
        {
            if ( !mNamespaceOpen )
            {
                throw new ApplicationException( "Can not '" + pWhat + "' because the 'namespace' has " + //
                                                (mNamespaceAdded ? "been closed/ended" : "not be added/opened") );
            }
        }
    }
}