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

import org.litesoft.commonfoundation.base.*;
import org.litesoft.commonfoundation.typeutils.*;
import org.litesoft.util.*;
import org.litesoft.xml.*;

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

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 = ConstrainTo.significantOrNull( 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 = Confirm.significant( "Section", mParser.getAttributeValue( "of" ) );
                    while ( PullParserProxy.START_TAG == mParser.getNextTag( "Section" ) ) {
                        mParser.validateIsStartTag( "Step" );
                        mStepNumber = ConstrainTo.notNull( mParser.getAttributeValue( "number" ) ).trim();
                        parseStep();
                    }
                    continue;
                }
                if ( "Capture".equals( zTagName ) ) {
                    String zSet = Confirm.significant( "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( ConstrainTo.notNull( 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 );
        }
    }
}