/*
 *   Copyright (C) 2005 Christian Schulte <cs@schulte.it>
 *   All rights reserved.
 *
 *   Redistribution and use in source and binary forms, with or without
 *   modification, are permitted provided that the following conditions
 *   are met:
 *
 *     o Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *
 *     o Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in
 *       the documentation and/or other materials provided with the
 *       distribution.
 *
 *   THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
 *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 *   AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
 *   THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY DIRECT, INDIRECT,
 *   INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 *   NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 *   THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *   $JOMC: SectionEditorTest.java 5291 2016-08-29 17:31:15Z schulte $
 *
 */
package org.jomc.util.test;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringReader;
import java.util.concurrent.ExecutorService;
import org.apache.commons.io.IOUtils;
import org.jomc.util.LineEditor;
import org.jomc.util.Section;
import org.jomc.util.SectionEditor;
import org.junit.After;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

/**
 * Test cases for class {@code org.jomc.util.SectionEditor}.
 *
 * @author <a href="mailto:cs@schulte.it">Christian Schulte</a>
 * @version $JOMC: SectionEditorTest.java 5291 2016-08-29 17:31:15Z schulte $
 */
public class SectionEditorTest extends LineEditorTest
{

    /**
     * Constant to prefix relative resource names with.
     */
    private static final String ABSOLUTE_RESOURCE_NAME_PREFIX = "/org/jomc/util/test/";

    /**
     * The {@code ExecutorService} backing the tests.
     */
    private ExecutorService executorService;

    /**
     * Creates a new {@code SectionEditorTest} instance.
     */
    public SectionEditorTest()
    {
        super();
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public SectionEditor getLineEditor()
    {
        return (SectionEditor) super.getLineEditor();
    }

    /**
     * {@inheritDoc}
     */
    @Override
    protected SectionEditor newLineEditor()
    {
        final SectionEditor sectionEditor = new SectionEditor()
        {

            @Override
            protected void editSection( final Section section ) throws IOException
            {
                super.editSection( section );

                if ( section.getName() != null )
                {
                    section.getHeadContent().append( section.getName() ).append( " Head" ).
                        append( this.getLineSeparator() );

                    section.getTailContent().append( section.getName() ).append( " Tail" ).
                        append( this.getLineSeparator() );

                }
            }

        };

        sectionEditor.setExecutorService( this.getExecutorService() );
        return sectionEditor;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    protected SectionEditor newLineEditor( final LineEditor editor )
    {
        final SectionEditor sectionEditor = new SectionEditor( editor );
        sectionEditor.setExecutorService( this.getExecutorService() );
        return sectionEditor;
    }

    /**
     * Gets the {@code ExecutorService} backing the tests.
     *
     * @return The {@code ExecutorService} backing the tests.
     *
     * @see #newExecutorService()
     * @since 1.10
     */
    public final ExecutorService getExecutorService()
    {
        if ( this.executorService == null )
        {
            this.executorService = this.newExecutorService();
        }

        return this.executorService;
    }

    /**
     * Creates a new {@code ExecutorService} backing the tests.
     *
     * @return A new {@code ExecutorService} backing the tests, or {@code null}.
     *
     * @see #getExecutorService()
     * @since 1.10
     */
    protected ExecutorService newExecutorService()
    {
        return null;
    }

    /**
     * Shuts down the {@code ExecutorService} backing the tests, if not {@code null}.
     */
    @After
    public final void shutdown()
    {
        if ( this.executorService != null )
        {
            this.executorService.shutdown();
            this.executorService = null;
        }
    }

    @Test
    public final void testSectionEditor() throws Exception
    {
        String test = this.getResource( ABSOLUTE_RESOURCE_NAME_PREFIX + "TestSections.txt" );
        String expected =
            convertLineSeparator( this.getResource( ABSOLUTE_RESOURCE_NAME_PREFIX + "TestSectionsEdited.txt" ) );

        String edited = this.getLineEditor().edit( test );

        System.out.println( "TEST:" );
        System.out.println( test );
        System.out.println( "EXPECTED:" );
        System.out.println( expected );
        System.out.println( "EDITED:" );
        System.out.println( edited );

        assertEquals( expected, edited );
        assertTrue( this.getLineEditor().isSectionPresent( "1" ) );
        assertTrue( this.getLineEditor().isSectionPresent( "1.1" ) );
        assertTrue( this.getLineEditor().isSectionPresent( "1.1.1" ) );
        assertTrue( this.getLineEditor().isSectionPresent( "1.1.1.1" ) );
        assertTrue( this.getLineEditor().isSectionPresent( "1.2" ) );
        assertTrue( this.getLineEditor().isSectionPresent( "1.3" ) );
        assertTrue( this.getLineEditor().isSectionPresent( "1.4" ) );
        assertTrue( this.getLineEditor().isSectionPresent( "2" ) );
        assertTrue( this.getLineEditor().isSectionPresent( "3" ) );
        assertTrue( this.getLineEditor().isSectionPresent( "4" ) );
        assertTrue( this.getLineEditor().isSectionPresent( "5" ) );
        assertTrue( this.getLineEditor().isSectionPresent( "6" ) );
        assertTrue( this.getLineEditor().isSectionPresent( "7" ) );
        assertTrue( this.getLineEditor().isSectionPresent( "8" ) );
        assertTrue( this.getLineEditor().isSectionPresent( "9" ) );
        assertTrue( this.getLineEditor().isSectionPresent( "10" ) );

        test = this.getResource( ABSOLUTE_RESOURCE_NAME_PREFIX + "TestSectionsCont.txt" );
        expected =
            convertLineSeparator( this.getResource( ABSOLUTE_RESOURCE_NAME_PREFIX + "TestSectionsContEdited.txt" ) );

        edited = this.getLineEditor().edit( test );

        System.out.println( "TEST:" );
        System.out.println( test );
        System.out.println( "EXPECTED:" );
        System.out.println( expected );
        System.out.println( "EDITED:" );
        System.out.println( edited );

        assertEquals( expected, edited );
        assertTrue( this.getLineEditor().isSectionPresent( "1" ) );
        assertTrue( this.getLineEditor().isSectionPresent( "1.1" ) );
        assertTrue( this.getLineEditor().isSectionPresent( "1.1.1" ) );
        assertTrue( this.getLineEditor().isSectionPresent( "2" ) );
        assertFalse( this.getLineEditor().isSectionPresent( "10" ) );

        this.assertUnmatchedSections( ABSOLUTE_RESOURCE_NAME_PREFIX + "UnmatchedSectionTest.txt" );
        this.assertUnmatchedSections( ABSOLUTE_RESOURCE_NAME_PREFIX + "UnmatchedSectionsTest.txt" );
        this.assertUnmatchedSections( ABSOLUTE_RESOURCE_NAME_PREFIX + "UnmatchedSubsectionTest.txt" );
        this.assertUnmatchedSections( ABSOLUTE_RESOURCE_NAME_PREFIX + "UnmatchedSubsectionsTest.txt" );
        this.assertUnmatchedSections( ABSOLUTE_RESOURCE_NAME_PREFIX + "MissingSectionStartTest.txt" );
        this.assertUnmatchedSections( ABSOLUTE_RESOURCE_NAME_PREFIX + "MissingSectionsStartTest.txt" );

        final StringBuilder testNoSections = new StringBuilder();
        final StringBuilder expectedNoSections = new StringBuilder();

        for ( int i = 1000; i >= 0; i-- )
        {
            testNoSections.append( "Hello editor.\n" );
            expectedNoSections.append( "Hello editor." ).append( this.getLineEditor().getLineSeparator() );
        }

        assertEquals( expectedNoSections.toString(), this.getLineEditor().edit( testNoSections.toString() ) );

        try
        {
            this.getLineEditor().edit( "SECTION-START[Test\nSECTION-END\n" );
        }
        catch ( final IOException e )
        {
            assertNotNull( e.getMessage() );
            System.out.println( e.toString() );
        }
    }

    private void assertUnmatchedSections( final String resourceName ) throws Exception
    {
        try
        {
            this.getLineEditor().edit( this.getResource( resourceName ) );
            fail( "Expected IOException not thrown for resource '" + resourceName + "'." );
        }
        catch ( final IOException e )
        {
            assertNotNull( e.getMessage() );
            System.out.println( e.toString() );
        }
    }

    private static String convertLineSeparator( final String s ) throws IOException
    {
        BufferedReader reader = null;
        boolean suppressExceptionOnClose = true;

        try
        {
            final StringBuilder b = new StringBuilder();
            reader = new BufferedReader( new StringReader( s ) );

            String line;
            while ( ( line = reader.readLine() ) != null )
            {
                b.append( line ).append( System.getProperty( "line.separator", "\n" ) );
            }

            suppressExceptionOnClose = false;
            return b.toString();
        }
        finally
        {
            try
            {
                if ( reader != null )
                {
                    reader.close();
                }
            }
            catch ( final IOException e )
            {
                if ( !suppressExceptionOnClose )
                {
                    throw e;
                }
            }
        }
    }

    private String getResource( final String resourceName ) throws IOException
    {

        InputStream in = null;
        boolean suppressExceptionOnClose = true;
        assertTrue( resourceName.startsWith( "/" ) );

        try
        {
            in = this.getClass().getResourceAsStream( resourceName );
            assertNotNull( "Resource '" + resourceName + "' not found.", in );
            final String content = IOUtils.toString( in, this.getResourceEncoding() );
            suppressExceptionOnClose = false;
            return content;
        }
        finally
        {
            try
            {
                if ( in != null )
                {
                    in.close();
                }
            }
            catch ( final IOException e )
            {
                if ( !suppressExceptionOnClose )
                {
                    throw e;
                }
            }
        }
    }

}