/*
 * 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: Add a phase itest tag when the integration testing phase exists
 * @goal verify
 * @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" 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 is the location is relative
                    file.setLocation(getAbsoluteFileToCheck(
                        new File(file.getLocation())).getPath());
                    verifyFile(file, results);
                }
            }
            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;
    }
}