/*

         StatCvs - CVS statistics generation 

         Copyright (C) 2002  Lukasz Pekacki <lukasz@pekacki.de>

         http://statcvs.sf.net/

         This library is free software; you can redistribute it and/or

         modify it under the terms of the GNU Lesser General Public

         License as published by the Free Software Foundation; either

         version 2.1 of the License, or (at your option) any later version.

         This library is distributed in the hope that it will be useful,

         but WITHOUT ANY WARRANTY; without even the implied warranty of

         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

         Lesser General Public License for more details.

         You should have received a copy of the GNU Lesser General Public

         License along with this library; if not, write to the Free Software

         Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

         $RCSfile: Builder.java,v $

         $Date: 2008/04/02 11:22:14 $

 */

 package net.sf.statcvs.input;

 import java.io.IOException;

 import java.util.ArrayList;

 import java.util.Date;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Map;

 import java.util.Properties;

 import java.util.Set;

 import java.util.SortedSet;

 import java.util.TreeSet;

 import java.util.logging.Logger;

 import java.util.regex.Pattern;

 import net.sf.statcvs.model.Author;

 import net.sf.statcvs.model.Directory;

 import net.sf.statcvs.model.Repository;

 import net.sf.statcvs.model.SymbolicName;

 import net.sf.statcvs.model.VersionedFile;

 import net.sf.statcvs.output.ConfigurationOptions;

 import net.sf.statcvs.util.FilePatternMatcher;

 import net.sf.statcvs.util.FileUtils;

 /**

  * <p>Helps building the {@link net.sf.statcvs.model.Repository} from a CVS

  * log. The <tt>Builder</tt> is fed by some CVS history data source, for

  * example a CVS log parser. The <tt>Repository</tt> can be retrieved

  * using the {@link #createCvsContent} method.</p>

  * 

  * <p>The class also takes care of the creation of <tt>Author</tt> and 

  * </tt>Directory</tt> objects and makes sure that there's only one of these

  * for each author name and path. It also provides LOC count services.</p>

  * 

  * @author Richard Cyganiak <richard@cyganiak.de>

  * @version $Id: Builder.java,v 1.40 2008/04/02 11:22:14 benoitx Exp $

  */

 public class Builder implements CvsLogBuilder {

     private static Logger logger = Logger.getLogger(Builder.class.getName());

     private final RepositoryFileManager repositoryFileManager;

     private final FilePatternMatcher includePattern;

     private final FilePatternMatcher excludePattern;

     private final Pattern tagsPattern;

     private final Map authors = new HashMap();

     private final Map directories = new HashMap();

     private final Map symbolicNames = new HashMap();

     private final List fileBuilders = new ArrayList();

     private final Set atticFileNames = new HashSet();

     private FileBuilder currentFileBuilder = null;

     private Date startDate = null;

     private String projectName = null;

     private int countRejectedByExclude = 0;

     private int countAcceptedByExclude = 0;

     private int countRejectedByInclude = 0;

     private int countAcceptedByInclude = 0;

     private boolean flagOutOfSync = false;

     private boolean flagHasLocalCVSMetadata = false;

     private int countFoundLocalFiles = 0;

     private int countNotFoundLocalFiles = 0;

     /**

      * Creates a new <tt>Builder</tt>

      * @param repositoryFileManager the {@link RepositoryFileManager} that

      *                                                                 can be used to retrieve LOC counts for

      *                                                                 the files that this builder will create

      * @param includePattern a list of Ant-style wildcard patterns, seperated

      *                       by : or ;

      * @param excludePattern a list of Ant-style wildcard patterns, seperated

      *                       by : or ;

      * @param tagsPattern A regular expression; matching symbolic names are recorded

      */

     public Builder(final RepositoryFileManager repositoryFileManager, final FilePatternMatcher includePattern, final FilePatternMatcher excludePattern,

             final Pattern tagsPattern) {

         this.repositoryFileManager = repositoryFileManager;

         this.includePattern = includePattern;

         this.excludePattern = excludePattern;

         this.tagsPattern = tagsPattern;

         directories.put("", Directory.createRoot());

     }

     /**

      * Starts building the module.

      * 

      * @param moduleName name of the module

      */

     public void buildModule(final String moduleName) {

         this.projectName = moduleName;

     }

     /**

      * Starts building a new file. The files are not expected to be created

      * in any particular order.

      * @param filename the file's name with path, for example "path/file.txt"

      * @param isBinary <tt>true</tt> if it's a binary file

      * @param isInAttic <tt>true</tt> if the file is dead on the main branch

      * @param revBySymnames maps revision (string) by symbolic name (string)

      */

     public void buildFile(final String filename, final boolean isBinary, final boolean isInAttic, final Map revBySymnames) {

         if (currentFileBuilder != null) {

             fileBuilders.add(currentFileBuilder);

         }

         currentFileBuilder = new FileBuilder(this, filename, isBinary, revBySymnames);

         if (isInAttic) {

             atticFileNames.add(filename);

         }

     }

     /**

      * Adds a revision to the current file. The revisions must be added in

      * CVS logfile order, that is starting with the most recent one.

      * 

      * @param data the revision

      */

     public void buildRevision(final RevisionData data) {

         currentFileBuilder.addRevisionData(data);

         if (startDate == null || startDate.compareTo(data.getDate()) > 0) {

             startDate = data.getDate();

         }

     }

     /**

      * Returns a Repository object of all files.

      * 

      * @return Repository a Repository object

      */

     public Repository createCvsContent() {

         if (currentFileBuilder != null) {

             fileBuilders.add(currentFileBuilder);

             currentFileBuilder = null;

         }

         final Repository result = new Repository();

         final Iterator it = fileBuilders.iterator();

         while (it.hasNext()) {

             final FileBuilder fileBuilder = (FileBuilder) it.next();

             final VersionedFile file = fileBuilder.createFile(startDate);

             if (file == null) {

                 continue;

             }

             if (fileBuilder.hasUnexpectedLocalRevision()) {

                 this.flagOutOfSync = true;

             }

             if (fileBuilder.hasLocalCVSMetadata()) {

                 this.flagHasLocalCVSMetadata = true;

             }

             if (fileBuilder.hasLocalFileNotFound()) {

                 this.countNotFoundLocalFiles++;

                 this.flagOutOfSync = true;

             } else if (file.getCurrentLinesOfCode() > 0) {

                 this.countFoundLocalFiles++;

             }

             result.addFile(file);

             logger.finer("adding " + file.getFilenameWithPath() + " (" + file.getRevisions().size() + " revisions)");

         }

         // Uh oh...

         final SortedSet revisions = result.getRevisions();

         final List commits = new CommitListBuilder(revisions).createCommitList();

         result.setCommits(commits);

         result.setSymbolicNames(getMatchingSymbolicNames());

         return result;

     }

     public String getProjectName() {

         return projectName;

     }

     /**

      * Returns the <tt>Set</tt> of filenames that are "in the attic".

      * @return a <tt>Set</tt> of <tt>String</tt>s

      */

     public Set getAtticFileNames() {

         return atticFileNames;

     }

     /**

      * @return <tt>true</tt> if there was an exclude pattern, and it rejected all files

      */

     public boolean allRejectedByExcludePattern() {

         return this.countRejectedByExclude > 0 && this.countAcceptedByExclude == 0;

     }

     /**

      * @return <tt>true</tt> if there was an include pattern, and it rejected all files

      */

     public boolean allRejectedByIncludePattern() {

         return this.countRejectedByInclude > 0 && this.countAcceptedByInclude == 0;

     }

     /**

      * Returns <tt>true</tt> if the local working copy is out of

      * sync with the log. The current implementation spots if

      * local files have been deleted and not yet committed, or

      * if the log file was generated before the latest commit.

      */

     public boolean isLogAndLocalFilesOutOfSync() {

         return this.flagHasLocalCVSMetadata && this.flagOutOfSync;

     }

     /**

      * Returns <tt>true</tt> if no local copy was found for

      * the majority of files in the log. This is a strong indication

      * that the log is not for the specified local working copy. 

      */

     public boolean isLocalFilesNotFound() {

         return this.countNotFoundLocalFiles > this.countFoundLocalFiles;

     }

     /**

      * Returns <tt>true</tt> if at least some local files have matching

      * entries in local CVS metada directories. If this is not the case,

      * then the local copy is probably just an export, not a checkout,

      * and we can't check if the log and working copy are in sync.

      */

     public boolean hasLocalCVSMetadata() {

         return this.flagHasLocalCVSMetadata;

     }

     /**

      * returns the <tt>Author</tt> of the given name or creates it

      * if it does not yet exist. Author names are handled as case-insensitive.

      * @param name the author's name

      * @return a corresponding <tt>Author</tt> object

      */

     public Author getAuthor(final String name) {

         if (this.authors.containsKey(name.toLowerCase())) {

             return (Author) this.authors.get(name.toLowerCase());

         }

         final Properties p = ConfigurationOptions.getConfigProperties();

         final Author newAuthor = new Author(name);

         this.authors.put(name.toLowerCase(), newAuthor);

         if (p != null) {

             newAuthor.setRealName(p.getProperty("user." + name.toLowerCase() + ".realName"));

             newAuthor.setHomePageUrl(p.getProperty("user." + name.toLowerCase() + ".url"));

             newAuthor.setImageUrl(p.getProperty("user." + name.toLowerCase() + ".image"));

             newAuthor.setEmail(p.getProperty("user." + name.toLowerCase() + ".email"));

         }

         return newAuthor;

     }

     /**

      * Returns the <tt>Directory</tt> of the given filename or creates it

      * if it does not yet exist.

      * @param filename the name and path of a file, for example "src/Main.java"

      * @return a corresponding <tt>Directory</tt> object

      */

     public Directory getDirectory(final String filename) {

         final int lastSlash = filename.lastIndexOf('/');

         if (lastSlash == -1) {

             return getDirectoryForPath("");

         }

         return getDirectoryForPath(filename.substring(0, lastSlash + 1));

     }

     /**

      * Returns the {@link SymbolicName} with the given name or creates it

      * if it does not yet exist.

      * 

      * @param name the symbolic name's name

      * @return the corresponding symbolic name object

      */

     public SymbolicName getSymbolicName(final String name) {

         SymbolicName sym = (SymbolicName) symbolicNames.get(name);

         if (sym != null) {

             return sym;

         } else {

             sym = new SymbolicName(name);

             symbolicNames.put(name, sym);

             return sym;

         }

     }

     public int getLOC(final String filename) throws NoLineCountException {

         if (repositoryFileManager == null) {

             throw new NoLineCountException("no RepositoryFileManager");

         }

         return repositoryFileManager.getLinesOfCode(filename);

     }

     /**

      * @see RepositoryFileManager#getRevision(String)

      */

     public String getRevision(final String filename) throws IOException {

         if (repositoryFileManager == null) {

             throw new IOException("no RepositoryFileManager");

         }

         return repositoryFileManager.getRevision(filename);

     }

     /**

      * Matches a filename against the include and exclude patterns. If no

      * include pattern was specified, all files will be included. If no

      * exclude pattern was specified, no files will be excluded.

      * @param filename a filename

      * @return <tt>true</tt> if the filename matches one of the include

      *         patterns and does not match any of the exclude patterns.

      *         If it matches an include and an exclude pattern, <tt>false</tt>

      *         will be returned.

      */

     public boolean matchesPatterns(final String filename) {

         if (excludePattern != null) {

             if (excludePattern.matches(filename)) {

                 this.countRejectedByExclude++;

                 return false;

             } else {

                 this.countAcceptedByExclude++;

             }

         }

         if (includePattern != null) {

             if (includePattern.matches(filename)) {

                 this.countAcceptedByInclude++;

             } else {

                 this.countRejectedByInclude++;

                 return false;

             }

         }

         return true;

     }

     /**

      * @param path for example "src/net/sf/statcvs/"

      * @return the <tt>Directory</tt> corresponding to <tt>statcvs</tt>

      */

     private Directory getDirectoryForPath(final String path) {

         if (directories.containsKey(path)) {

             return (Directory) directories.get(path);

         }

         final Directory parent = getDirectoryForPath(FileUtils.getParentDirectoryPath(path));

         final Directory newDirectory = parent.createSubdirectory(FileUtils.getDirectoryName(path));

         directories.put(path, newDirectory);

         return newDirectory;

     }

     private SortedSet getMatchingSymbolicNames() {

         final TreeSet result = new TreeSet();

         if (this.tagsPattern == null) {

             return result;

         }

         for (final Iterator it = this.symbolicNames.values().iterator(); it.hasNext();) {

             final SymbolicName sn = (SymbolicName) it.next();

             if (sn.getDate() != null && this.tagsPattern.matcher(sn.getName()).matches()) {

                 result.add(sn);

             }

         }

         return result;

     }

 }