/*
 * Copyright 2005 The Apache Software Foundation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.maven.plugin.verifier;

import java.io.File;
import java.io.FileReader;
import java.io.Reader;
import java.util.Iterator;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.maven.plugin.AbstractPlugin;
import org.apache.maven.plugin.PluginExecutionException;
import org.apache.maven.plugin.verifier.model.Verifications;
import org.apache.maven.plugin.verifier.model.io.xpp3.VerificationsXpp3Reader;

/**
 * TODO: Bind to an itest phase when it exists
 * @goal verify
 * @phase test
 * @description verifies existence or non-existence of files/directories an optionally checks
 *   file content against a regexp
 * @parameter name="verificationFile" type="java.io.File" required="true" validator="" 
 *   expression="${basedir}/src/test/verifier/verifications.xml" description=""
 * @parameter name="basedir" type="String" required="true" validator=""
 *   expression="${basedir}" description=""
 * @parameter name="failOnError" type="boolean" required="true" validator=""
 *   expression="true" description=""
 *   
 * @author <a href="vmassol@apache.org">Vincent Massol</a>
 * @version $Id: $
 */
public class VerifierMojo
    extends AbstractPlugin
{
    private String basedir;

    private File verificationFile;

    private boolean failOnError;

    private VerificationResultPrinter resultPrinter = new ConsoleVerificationResultPrinter( getLog() );

    public void execute()
        throws PluginExecutionException
    {
        VerificationResult results = verify();
        this.resultPrinter.print( results );

        // Fail the build if there are errors
        if ( this.failOnError && results.hasFailures() )
        {
            throw new PluginExecutionException( "There are test failures" );
        }
    }

    /**
     * @param file the file path of the file to check (can be relative or absolute). If relative
     *        the project's basedir will be prefixed.
     * @return the absolute file path of the file to check 
     */
    protected File getAbsoluteFileToCheck( File file )
    {
        File result = file;
        if ( !file.isAbsolute() )
        {
            result = new File( new File( this.basedir ), file.getPath() );
        }
        return result;
    }

    private VerificationResult verify()
        throws PluginExecutionException
    {
        VerificationResult results = new VerificationResult();

        try
        {
            Reader reader = new FileReader( this.verificationFile );
            try
            {
                VerificationsXpp3Reader xppReader = new VerificationsXpp3Reader();
                Verifications verifications = xppReader.read( reader );

                for ( Iterator i = verifications.getFiles().iterator(); i.hasNext(); )
                {
                    org.apache.maven.plugin.verifier.model.File file = (org.apache.maven.plugin.verifier.model.File) i
                        .next();

                    // Transform the file to check into an absolute path prefixing the basedir if 
                    // the location is relative
                    if ( file.getLocation() != null )
                    {
                        file.setLocation( getAbsoluteFileToCheck( new File( file.getLocation() ) ).getPath() );
                        verifyFile( file, results );
                    }
                    else
                    {
                        throw new PluginExecutionException( "Missing <location> element" );
                    }
                }
            }
            finally
            {
                reader.close();
            }
        }
        catch ( Exception e )
        {
            throw new PluginExecutionException( "Error while verifying files", e );
        }

        return results;
    }

    private boolean verifyFile( org.apache.maven.plugin.verifier.model.File fileCheck, VerificationResult results )
        throws Exception
    {
        boolean result;

        result = verifyFileExistence( fileCheck, results );
        if ( result && fileCheck.getContains() != null )
        {
            result = result && verifyFileContent( fileCheck, results );
        }

        return result;
    }

    private String readFileInMemory( File file )
        throws Exception
    {
        StringBuffer memoryFile = new StringBuffer();

        Reader reader = new FileReader( file );

        char[] buffer = new char[16384];
        int count;

        while ( -1 != reader.read( buffer ) )
        {
            memoryFile.append( buffer );
        }

        reader.close();

        return memoryFile.toString();
    }

    private boolean verifyFileContent( org.apache.maven.plugin.verifier.model.File fileCheck, VerificationResult results )
        throws Exception
    {
        boolean result = false;

        Pattern pattern = Pattern.compile( fileCheck.getContains() );

        // Note: Very inefficient way as we load the whole file in memory. If you have a better 
        // idea, please submit it!
        Matcher matcher = pattern.matcher( readFileInMemory( new File( fileCheck.getLocation() ) ) );

        if ( matcher.find() )
        {
            result = true;
        }
        else
        {
            results.addContentFailure( fileCheck );
        }

        return result;
    }

    private boolean verifyFileExistence( org.apache.maven.plugin.verifier.model.File fileCheck,
                                        VerificationResult results )
    {
        boolean result = false;

        File physicalFile = new File( fileCheck.getLocation() );
        if ( fileCheck.isExists() )
        {
            result = physicalFile.exists();
            if ( !result )
            {
                results.addExistenceFailure( fileCheck );
            }
        }
        else
        {
            result = !physicalFile.exists();
            if ( !result )
            {
                results.addNonExistenceFailure( fileCheck );
            }
        }

        return result;
    }

    public void setBaseDir( String basedir )
    {
        this.basedir = basedir;
    }

    public void setVerificationFile( File file )
    {
        this.verificationFile = file;
    }

    public void setVerificationResultPrinter( VerificationResultPrinter printer )
    {
        this.resultPrinter = printer;
    }

    public void setFailOnError( boolean failOnError )
    {
        this.failOnError = failOnError;
    }
}