// This Source Code is in the Public Domain per: http://litesoft.org/License.txt
package org.litesoft.core.hierarchicaldata;

import junit.framework.*;

import org.litesoft.commonfoundation.typeutils.*;

public class HierarchicalDataSimpleFactoryTest extends TestCase
{
    public static TestSuite suite()
    {
        return new TestSuite( HierarchicalDataSimpleFactoryTest.class );
    }

    public HierarchicalDataSimpleFactoryTest( String name )
    {
        super( name );
    }

    public static void main( String[] args )
    {
        junit.textui.TestRunner.run( suite() );
    }

    private void validateBadName_createRootNode( HierarchicalDataSink pSink, String pName )
    {
        try
        {
            pSink.createRootNode( pName );
            fail( "Allowed createRootNode of Bad Name '" + pName + "'" );
        }
        catch ( IllegalArgumentException expected )
        {
            //
        }
    }

    private void validateBadName_createChildNode( HierarchicalDataSink.Node pNode, String pName )
    {
        try
        {
            pNode.createChildNode( pName );
            fail( "Allowed createChildNode of Bad Name '" + pName + "'" );
        }
        catch ( IllegalArgumentException expected )
        {
            //
        }
    }

    private void validateBadName_addAttribute( HierarchicalDataSink.Node pNode, String pName )
    {
        try
        {
            pNode.setAttribute( pName, "A" );
            fail( "Allowed addAttribute of Bad Name '" + pName + "'" );
        }
        catch ( IllegalArgumentException expected )
        {
            //
        }
    }

    public void testSink()
            throws Exception
    {
        StringBuilder actual = new StringBuilder();
        HierarchicalDataSink sink = HierarchicalDataSimpleFactory.INSTANCE.createSink( actual );

        validateBadName_createRootNode( sink, null );
        validateBadName_createRootNode( sink, "" );
        validateBadName_createRootNode( sink, "  " );
        validateBadName_createRootNode( sink, "Bad-Name" );
        validateBadName_createRootNode( sink, "Bad Name" );
        validateBadName_createRootNode( sink, "Bad|Name" );
        validateBadName_createRootNode( sink, "_BadName" );
        validateBadName_createRootNode( sink, "9BadName" );

        HierarchicalDataSink.Node node = sink.createRootNode( " ABC  " );

        validateBadName_createChildNode( node, null );
        validateBadName_createChildNode( node, "" );
        validateBadName_createChildNode( node, "  " );
        validateBadName_createChildNode( node, "Bad-Name" );
        validateBadName_createChildNode( node, "Bad Name" );
        validateBadName_createChildNode( node, "Bad|Name" );
        validateBadName_createChildNode( node, "_BadName" );
        validateBadName_createChildNode( node, "9BadName" );

        try
        {
            sink.createRootNode( "ShouldError" );
            fail( "Allowed 2nd createRootNode" );
        }
        catch ( IllegalStateException expected )
        {
        }

        validateBadName_addAttribute( node, null );
        validateBadName_addAttribute( node, "" );
        validateBadName_addAttribute( node, "  " );
        validateBadName_addAttribute( node, "Bad-Name" );
        validateBadName_addAttribute( node, "Bad Name" );
        validateBadName_addAttribute( node, "Bad|Name" );
        validateBadName_addAttribute( node, "_BadName" );
        validateBadName_addAttribute( node, "9BadName" );

        node.setAttribute( "b", "B" );
        node.setAttribute( "a", "A" );
        node.setAttribute( "c", "C" );
        HierarchicalDataSink.Node node1 = node.createChildNode( "D.E.F_" );

        try
        {
            node.setAttribute( "Should", "Error" );
            fail( "Allowed addAttribute after createChildNode" );
        }
        catch ( IllegalStateException expected )
        {
        }

        node1.setAttribute( "e", "E" );
        HierarchicalDataSink.Node node11 = node1.createChildNode( "GHI" );
        node11.setAttribute( " g_  ", "G" );
        node11.done();
        node1.done();
        HierarchicalDataSink.Node node2 = node.createChildNode( "DEF2" );
        node2.setAttribute( "f", "F" );
        node2.done();

        try
        {
            node2.setAttribute( "Should", "Error" );
            fail( "Allowed addAttribute after done" );
        }
        catch ( IllegalStateException expected )
        {
        }
        try
        {
            node2.createChildNode( "ShouldError" );
            fail( "Allowed createChildNode after done" );
        }
        catch ( IllegalStateException expected )
        {
        }

        node.done();

        assertEquals( "" + //
                      "ABC(a=A b=B c=C)\n" + //
                      ".D.E.F_(e=E)\n" + //
                      "..GHI(g_=G)\n" + //
                      ".DEF2(f=F)\n" + //
                      "", actual.toString() );
    }

    public void testSource()
            throws Exception
    {
        String sourceString = "" + //
                              "ABC(a=A b=B c=C)\n" + //
                              ".DEF(e=E)\n" + //
                              "..GHI(g=G)\n" + //
                              ".DEF2(f=F)\n" + //
                              "";
        HierarchicalDataSource source = HierarchicalDataSimpleFactory.INSTANCE.createSource( sourceString );

        HierarchicalDataSource.Node node = source.getRootNode();

        try
        {
            source.getRootNode();
            fail( "Allowed 2nd getRootNode" );
        }
        catch ( IllegalStateException expected )
        {
        }

        assertEquals( "ABC", node.getName() );
        assertEquals( "a\nb\nc\n", Strings.linesToString( node.getAttributeNames() ) );

        assertEquals( "A", node.getAttributeValue( "a" ) );
        assertEquals( "B", node.getAttributeValue( "b" ) );
        assertEquals( "C", node.getAttributeValue( "c" ) );

        HierarchicalDataSource.Node node1 = node.getNextChild();
        assertEquals( "DEF", node1.getName() );
        assertEquals( "e\n", Strings.linesToString( node1.getAttributeNames() ) );

        assertEquals( "E", node1.getAttributeValue( "e" ) );

        HierarchicalDataSource.Node node11 = node1.getNextChild();
        assertEquals( "GHI", node11.getName() );
        assertEquals( "g\n", Strings.linesToString( node11.getAttributeNames() ) );

        assertEquals( "G", node11.getAttributeValue( "g" ) );

        assertNull( node11.getNextChild() );

        assertNull( node1.getNextChild() );

        HierarchicalDataSource.Node node2 = node.getNextChild();
        assertEquals( "DEF2", node2.getName() );
        assertEquals( "f\n", Strings.linesToString( node2.getAttributeNames() ) );

        assertEquals( "F", node2.getAttributeValue( "f" ) );

        assertNull( node2.getNextChild() );

        assertNull( node.getNextChild() );
    }

    public void testSource2()
            throws Exception
    {
        String sourceString = "" + //
                              "ABC()\n" + //
                              ".  DEF  (e_.=E)\n" + //
                              "..GHI(  g  =  G   )\n" + //
                              "";
        HierarchicalDataSource source = HierarchicalDataSimpleFactory.INSTANCE.createSource( sourceString );

        HierarchicalDataSource.Node node = source.getRootNode();

        assertEquals( "ABC", node.getName() );
        String[] names = node.getAttributeNames();
        assertEquals( 0, names.length );

        HierarchicalDataSource.Node node1 = node.getNextChild();
        assertEquals( "DEF", node1.getName() );
        assertEquals( "e_.\n", Strings.linesToString( node1.getAttributeNames() ) );

        assertEquals( "E", node1.getAttributeValue( "e_." ) );

        HierarchicalDataSource.Node node11 = node1.getNextChild();
        assertEquals( "GHI", node11.getName() );
        assertEquals( "g\n", Strings.linesToString( node11.getAttributeNames() ) );

        assertEquals( "G", node11.getAttributeValue( "g" ) );

        assertNull( node11.getNextChild() );

        assertNull( node1.getNextChild() );

        assertNull( node.getNextChild() );
    }

    public void testRoundTrip()
            throws Exception
    {
        chkRoundTrip( "ABC(a=A b=B c=C)\n" + //
                      ".DEF(e=E)\n" + //
                      "..GHI(g=G)\n" + //
                      ".DEF2(f=F)\n" + //
                      "" );
        chkRoundTrip( "ABC(a='  \\r\\n\\\\'' \\x001F')\n" );
    }

    private void chkRoundTrip( String pSourceString )
            throws Exception
    {
        StringBuilder zSinkBuffer = new StringBuilder();

        HierarchicalDataFactory factory = HierarchicalDataSimpleFactory.INSTANCE;

        HierarchicalDataSource.Node sourceNode = factory.createSource( pSourceString ).getRootNode();
        HierarchicalDataSink.Node sinkNode = factory.createSink( zSinkBuffer ).createRootNode( sourceNode.getName() );

        copy( sourceNode, sinkNode );

        String zSinkString = zSinkBuffer.toString();

        assertEquals( pSourceString, zSinkString );
    }

    private void copy( HierarchicalDataSource.Node pFrom, HierarchicalDataSink.Node pTo )
    {
        String[] names = pFrom.getAttributeNames();
        if ( names != null )
        {
            for ( String name : names )
            {
                pTo.setAttribute( name, pFrom.getAttributeValue( name ) );
            }
        }

        for ( HierarchicalDataSource.Node child; null != (child = pFrom.getNextChild()); )
        {
            copy( child, pTo.createChildNode( child.getName() ) );
        }
        pTo.done();
    }
}