/*

* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Searches files from given directories

 *

*/

package com.nokia.tools.themeinstaller.localisation;

import java.io.File;

import java.io.FileFilter;

import java.util.Vector;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

/**

 * Searches files that's name matches the regular expression.

 * Search operations can be executed in one or multiple directories

 * and also including subfolders in the search can activated.

 *

 * There are two versions for searching: recursive and non-recursive.

 * Recursive version is used when flooding the search to subfolders

 */

public class FileSearch

    {

    private static Vector iFiles;

    /**

     * Find files in directories.

     *

     * @param aRootDirs The root directories where the search is initiated

     * @param aFileNameExpression The file name expression

     * @param aIncludeSubfolders Include subfolders in the search or not

     * @param aAllowSameName Allow same filenames

     *

     * @return Found files in a vector

     */

    public static Vector findFiles( Vector aRootDirs,

            String aFileNameExpression, boolean aIncludeSubfolders,

            boolean aAllowSame )

        {

        Vector allFiles = new Vector();

        Vector fileFromOneSearch = new Vector();

        for ( int i = 0; i < aRootDirs.size(); i++ )

            {

            fileFromOneSearch = findFiles( ( String ) aRootDirs.elementAt( i ),

                    aFileNameExpression, aIncludeSubfolders, aAllowSame );

            for ( int j = 0; j < fileFromOneSearch.size(); j++ )

                {

                if ( aAllowSame && !allFiles.contains( fileFromOneSearch.get( j ) ) )

                    {

                    allFiles.add( fileFromOneSearch.get( j ) );

                    }

                if ( !aAllowSame

                        && !hasSameName( allFiles, ( File ) fileFromOneSearch.get( j ) ) )

                    {

                    allFiles.add( fileFromOneSearch.get( j ) );

                    }

                }

            }

        return allFiles;

        }

    /**

     * Find files in directories.

     *

     * @param aRootDirs The root directories where the search is initiated

     * @param aFileNameExpression The file name expression

     * @param aIncludeSubfolders Include subfolders in the search or not

     *

     * @return Found files in a vector

     */

    public static Vector findFiles( Vector aRootDirs,

            String aFileNameExpression, boolean aIncludeSubfolders )

        {

        return findFiles( aRootDirs, aFileNameExpression, aIncludeSubfolders,

                true );

        }

    /**

     * Find one file in directories. Returns the first one found.

     *

     * @param aRootDirs The root directories where the search is initiated

     * @param aFileNameExpression The file name expression

     * @param aIncludeSubfolders Include sub folders in the search or not

     *

     * @return Found file

     */

    public static File findFile( Vector aRootDirs,

            String aFileNameExpression, boolean aIncludeSubfolders )

        {

        Vector results = findFiles( aRootDirs, aFileNameExpression, aIncludeSubfolders,

                true );

        if( results.size() == 0 )

            {

            throw new IllegalArgumentException( "Localisation: File Search: " +

            		"File not found: " + aFileNameExpression );

            }

        return ( File ) results.elementAt( 0 );

        }

    /**

     * Find files in directory.

     *

     * @param aRootDir The root directory where the search is initiated

     * @param aFileNameExpression The file name expression

     * @param aIncludeSubfolders Include subfolders in the search or not

     * @param aAllowSameName Allow same filenames

     *

     * @return Found files in a vector

     */

    public static Vector findFiles( String aRootDir,

            String aFileNameExpression, boolean aIncludeSubfolders,

            boolean aAllowSameName )

        {

        iFiles = new Vector();

        // If subfolders included, use recursive version

        if ( aIncludeSubfolders )

            {

            findFilesInSubfolder( new File( aRootDir ), aFileNameExpression,

                    aAllowSameName );

            }

        // If no subfolders included, use non-recursive version

        if ( !aIncludeSubfolders )

            {

            findFilesInFolder( new File( aRootDir ), aFileNameExpression,

                    aAllowSameName );

            }

        return iFiles;

        }

    /**

     * Find files in directory.

     *

     * @param aRootDir The root directory where the search is initiated

     * @param aFileNameExpression The file name expression

     * @param aIncludeSubfolders Include subfolders in the search or not

     *

     * @return Found files in a vector

     */

    public static Vector findFiles( String aRootDir,

            String aFileNameExpression, boolean aIncludeSubfolders )

        {

        return findFiles( aRootDir, aFileNameExpression, aIncludeSubfolders, true );

        }

    /**

     * Find files in folder. Non-recursive version

     *

     * @param dir Directory to search in

     * @param aFileNameExpression The file name expression

     * @param aAllowSameName Allow same filename

     */

    private static void findFilesInFolder( File dir,

            final String aFileNameExpression, boolean aAllowSameName )

        {

        // Condition that file must fulfill

        FileFilter fileFilter = new FileFilter()

            {

            public boolean accept( File file )

                {

                return ( !file.isDirectory() && match( aFileNameExpression,

                        file.getName() ) );

                }

            };

        // Files that match the condition

        File[] files = dir.listFiles( fileFilter );

        for ( int i = 0; i < files.length; i++ )

            {

            if ( aAllowSameName )

                {

                iFiles.add( files[ i ] );

                }

            if ( !aAllowSameName && !hasSameName( iFiles, files[ i ] ) )

                {

                iFiles.add( files[ i ] );

                }

            }

        }

    /**

     * Find files in folder and it's subfolder. Recursive version

     *

     * @param dir Root directory to start search

     * @param aFileNameExpression the a file name expression

     * @param aAllowSameName Allow same filenames

     */

    private static void findFilesInSubfolder( File dir,

            final String aFileNameExpression, boolean aAllowSameName )

        {

        // Flood the search to subdirectories:

        if ( dir.isDirectory() )

            {

            File[] files = dir.listFiles();

            for ( int i = 0; i < files.length; i++ )

                {

                findFilesInSubfolder( files[ i ], aFileNameExpression,

                        aAllowSameName );

                }

            }

        // If not directory, add files that match conditions

        else

            {

            if ( match( aFileNameExpression, dir.getName() ) )

                {

                if ( aAllowSameName )

                    {

                    iFiles.add( dir );

                    }

                if ( !aAllowSameName && !hasSameName( iFiles, dir ) )

                    {

                    iFiles.add( dir );

                    }

                }

            }

        }

    /**

     * Match regular expression with string.

     *

     * @param patternStr Regular expression for match

     * @param input String to compare the regular expression

     *

     * @return true, if input matches the regular expression

     */

    private static boolean match( String patternStr, CharSequence input )

        {

        Pattern pattern = Pattern.compile( patternStr );

        Matcher matcher = pattern.matcher( input );

        if ( matcher.matches() )

            {

            return true;

            }

        return false;

        }

    /**

     * Checks if vector already has file with same name.

     *

     * @param aFiles Files to check

     * @param aFile Reference file

     *

     * @return true, if vector already has file with same name

     */

    private static boolean hasSameName( Vector aFiles, File aFile )

        {

        for ( int i = 0; i < aFiles.size(); i++ )

            {

            if ( ( ( File ) aFiles.get( i ) ).getName()

                    .equals( aFile.getName() ) )

                {

                return true;

                }

            }

        return false;

        }

    }