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

import java.io.*;
import java.util.*;

import org.litesoft.core.typeutils.*;
import org.litesoft.util.*;
import org.litesoft.xml.*;

public class TestPlanParser
{
    protected List<TestPlanStep> mSteps = new ArrayList<TestPlanStep>();
    private InnerParser mParser;

    public TestPlanParser( String pTestPlanFilePath )
    {
        (mParser = createInnerParser( pTestPlanFilePath )).addStep();
    }

    public TestPlanStep[] toSteps()
    {
        return mSteps.toArray( new TestPlanStep[mSteps.size()] );
    }

    public TestPlanParser parse()
    {
        mParser.parse();
        return this;
    }

    protected InnerParser createInnerParser( String pTestPlanFilePath, PullParserProxy pParser )
    {
        return new InnerParser( pTestPlanFilePath, pParser );
    }

    protected InnerParser createInnerParser( String pTestPlanFilePath )
    {
        FileReader zReader;
        try
        {
            zReader = new FileReader( pTestPlanFilePath );
        }
        catch ( FileNotFoundException e )
        {
            throw new XML_RuntimeException( e );
        }
        return createInnerParser( pTestPlanFilePath, new PullParserProxy().setInput( zReader ) );
    }

    protected void processCapture( String pTestPlanFilePath, String pSet )
    {
        pSet = Utils.relativePath( pTestPlanFilePath, pSet );
        int zPreCapture = mSteps.size();
        createInnerParser( pSet ).parse();
        int zPostCapture = mSteps.size();
        if ( zPostCapture > zPreCapture )
        {
            String zTo = Utils.relativePath( pSet, "Current" );
            if ( !new File( zTo ).isDirectory() )
            {
                System.out.println( "Not a Directory; Capture To:" + zTo );
            }
            else
            {
                String zFrom = Strings.noEmpty( System.getProperty( "CaptureFrom" ) );
                if ( zFrom != null )
                {
                    if ( !new File( zFrom = Utils.relativePath( pSet, zFrom ) ).isDirectory() )
                    {
                        System.out.println( "Not a Directory; Capture From:" + zFrom );
                    }
                    else
                    {
                        mSteps.get( zPostCapture - 1 ).setFromTo( zFrom, zTo );
                    }
                }
            }
        }
    }

    protected class InnerParser
    {
        private String mTestPlanFilePath;
        protected PullParserProxy mParser;
        protected String mStepNumber = "";
        protected String mSection = null;
        protected TestPlanAction mAction = null;
        protected String mPreText = null;
        protected String mPostText = null;

        protected InnerParser( String pTestPlanFilePath, PullParserProxy pParser )
        {
            mTestPlanFilePath = pTestPlanFilePath;
            mParser = pParser;
        }

        protected void addStep()
        {
            mSteps.add( new TestPlanStep( mSection, mStepNumber, mAction, mPreText, mPostText ) );
        }

        protected void parse()
        {
            mParser.validateNextIsStartTag( "Plan" );
            while ( PullParserProxy.START_TAG == mParser.getNextTag( "Plan" ) )
            {
                if ( !mParser.isStartTag() )
                {
                    throw new XML_RuntimeException( "Child of Plan not STart Tag | " + mTestPlanFilePath );
                }
                String zTagName = mParser.getTagName();
                if ( "Section".equals( zTagName ) )
                {
                    mSection = Strings.assertNotNullNotEmpty( "Section", mParser.getAttributeValue( "of" ) );
                    while ( PullParserProxy.START_TAG == mParser.getNextTag( "Section" ) )
                    {
                        mParser.validateIsStartTag( "Step" );
                        mStepNumber = Strings.deNull( mParser.getAttributeValue( "number" ) ).trim();
                        parseStep();
                    }
                    continue;
                }
                if ( "Capture".equals( zTagName ) )
                {
                    String zSet = Strings.assertNotNullNotEmpty( "Capture set", mParser.getAttributeValue( "set" ) );
                    mParser.validateNextIsEndTag( "Capture" );
                    processCapture( mTestPlanFilePath, zSet );
                    continue;
                }
                throw new XML_RuntimeException( "Child of Plan not: Section or Capture; but '" + zTagName + "' | " + mTestPlanFilePath );
            }
        }

        protected void parseStep()
        {
            mAction = null;
            mPreText = null;
            mPostText = null;
            while ( PullParserProxy.START_TAG == mParser.getNextTag( "Step" ) )
            {
                String zTagName = mParser.getTagName();
                if ( "Text".equals( zTagName ) )
                {
                    if ( mPreText != null )
                    {
                        processTextFor( "Pre", mPreText );
                    }
                    else if ( mPostText != null )
                    {
                        processTextFor( "Post", mPostText );
                    }
                    else
                    {
                        mPreText = mPostText = processTextFor( "Text", null );
                    }
                }
                else if ( "Pre".equals( zTagName ) )
                {
                    mPreText = processTextFor( "Pre", mPreText );
                }
                else if ( "Post".equals( zTagName ) )
                {
                    mPostText = processTextFor( "Post", mPostText );
                }
                else if ( mAction == null )
                {
                    mAction = parseActionTag( mParser, mStepNumber, mTestPlanFilePath );
                }
                else
                {
                    throw new XML_RuntimeException( "Appears to be Multiple Actions in Step " + mStepNumber + ", at: " + zTagName + " | " + mTestPlanFilePath );
                }
            }
            addStep();
        }

        protected String processTextFor( String pTag, String pExisting )
        {
            if ( pExisting != null )
            {
                throw new XML_RuntimeException( "ALready " + pTag + " text in Step: " + mStepNumber + " | " + mTestPlanFilePath );
            }
            String rv = Strings.normalizeNewLines( Strings.deNull( mParser.getTextFromTextElement() ).trim() );
            rv = Strings.replace( rv, '\t', " " );
            while ( rv.contains( "\n " ) )
            {
                rv = Strings.replace( rv, "\n ", "\n" );
            }
            while ( rv.contains( " \n" ) )
            {
                rv = Strings.replace( rv, " \n", "\n" );
            }
            while ( rv.contains( "  " ) )
            {
                rv = Strings.replace( rv, "  ", " " );
            }
            return rv;
        }
    }

    protected Map<String, TestPlanActionFactory> mFactories = new HashMap<String, TestPlanActionFactory>();

    protected TestPlanAction parseActionTag( PullParserProxy pParser, String pStepNumber, String pTestPlanFilePath )
    {
        Exception zError = null;
        String zTagName = pParser.getTagName();
        String zClassName = getClass().getName() + "ActionFactory" + zTagName;
        TestPlanActionFactory zFactory = mFactories.get( zTagName );
        if ( zFactory == null )
        {
            try
            {
                Class<?> zClass = Class.forName( zClassName );
                zFactory = (TestPlanActionFactory) zClass.newInstance();
            }
            catch ( Exception e )
            {
                zError = e;
            }
        }
        if ( zFactory == null )
        {
            throw new XML_RuntimeException( "Unknown Action Tag in Step " + pStepNumber + ", of: " + zTagName + " | " + pTestPlanFilePath + " using: " + zClassName, zError );
        }
        mFactories.put( zTagName, zFactory );
        try
        {
            return zFactory.parse( pParser );
        }
        catch ( RuntimeException e )
        {
            throw new XML_RuntimeException( "Unable to parse Action Tag in Step " + pStepNumber + ", of: " + zTagName + " | " + pTestPlanFilePath + " using: " + zClassName, e );
        }
    }
}