/*

  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: 2004/12/14 13:38:13 $

  */

 package net.sf.statsvn.input;

 import java.io.IOException;

 import java.util.Date;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Locale;

 import java.util.Map;

 import java.util.Properties;

 import java.util.Set;

 import java.util.SortedSet;

 import java.util.TreeSet;

 import java.util.regex.Pattern;

 import net.sf.statcvs.Messages;

 import net.sf.statcvs.input.CommitListBuilder;

 import net.sf.statcvs.input.NoLineCountException;

 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;

 import net.sf.statsvn.output.SvnConfigurationOptions;

 /**

  * <p>

  * Helps building the {@link net.sf.statsvn.model.Repository} from a SVN log. The <tt>Builder</tt> is fed by some SVN history data source, for example a SVN

  * log parser. The <tt>Repository</tt> can be retrieved using the {@link #createRepository} 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>

  * @author Jason Kealey <jkealey@shade.ca>

  * @author Gunter Mussbacher <gunterm@site.uottawa.ca>

  * 

  * @version $Id: Builder.java 351 2008-03-28 18:46:26Z benoitx $

  * 

  */

 public class Builder implements SvnLogBuilder {

         private final Set atticFileNames = new HashSet();

         private final Map authors = new HashMap();

         private FileBuilder currentFileBuilder = null;

         private final Map directories = new HashMap();

         private final FilePatternMatcher excludePattern;

         private final Map fileBuilders = new HashMap();

         private final FilePatternMatcher includePattern;

         private String projectName = null;

         private final RepositoryFileManager repositoryFileManager;

         private Date startDate = null;

         private final Map symbolicNames = new HashMap();

         private final Pattern tagsPattern;

         /**

          * 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 ;

          */

         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());

         }

         /**

          * Adds a file to the attic. This method should only be called if our first invocation to (@link #buildFile(String, boolean, boolean, Map)) was given an

          * invalid isInAttic field.

          * 

          * This is a hack to handle post-processing of implicit deletions at the same time as the implicit additions that can be found in Subversion.

          * 

          * @param filename

          *            the filename to add to the attic.

          */

         public void addToAttic(final String filename) {

                 if (!atticFileNames.contains(filename)) {

                         atticFileNames.add(filename);

                 }

         }

         /**

          * <p>

          * Starts building a new file. The files are not expected to be created in any particular order. Subsequent calls to (@link #buildRevision(RevisionData))

          * will add revisions to this file.

          * </p>

          * 

          * <p>

          * New in StatSVN: If the method has already been invoked with the same filename, the original file will be re-loaded and the other arguments are ignored.

          * </p>

          * 

          * @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)

          * @param dateBySymnames

          *            maps date (date) by symbolic name (string)

          */

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

                 if (fileBuilders.containsKey(filename)) {

                         currentFileBuilder = (FileBuilder) fileBuilders.get(filename);

                 } else {

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

                         fileBuilders.put(filename, currentFileBuilder);

                         if (isInAttic) {

                                 addToAttic(filename);

                         }

                 }

         }

         /**

          * Starts building the module.

          * 

          * @param moduleName

          *            name of the module

          */

         public void buildModule(final String moduleName) {

                 this.projectName = moduleName;

         }

         /**

          * Adds a revision to the current file. The revisions must be added in SVN 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 createRepository() {

                 if (startDate == null) {

                         return new Repository();

                 }

                 final Repository result = new Repository();

                 final Iterator it = fileBuilders.values().iterator();

                 while (it.hasNext()) {

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

                         final VersionedFile file = fileBuilder.createFile(startDate);

                         if (file == null) {

                                 continue;

                         }

                         result.addFile(file);

                         SvnConfigurationOptions.getTaskLogger().log("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(new TreeSet(symbolicNames.values()));

                 result.setSymbolicNames(getMatchingSymbolicNames());

                 SvnConfigurationOptions.getTaskLogger().log("SYMBOLIC NAMES - " + symbolicNames);

                 return result;

         }

         /**

          * 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;

         }

         /**

          * 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(String name) {

                 if (name == null || name.length() == 0) {

                         name = Messages.getString("AUTHOR_UNKNOWN");

                 }

                 final String lowerCaseName = name.toLowerCase(Locale.getDefault());

                 final boolean bAnon = SvnConfigurationOptions.isAnonymize();

                 if (this.authors.containsKey(lowerCaseName)) {

                         return (Author) this.authors.get(lowerCaseName);

                 }

                 Author newAuthor;

                 if (bAnon) {

                         // The first time a particular name is encountered, create an anonymized name.

                         newAuthor = new Author(AuthorAnonymizingProvider.getNewName());

                 } else {

                         newAuthor = new Author(name);

                 }

                 final Properties p = ConfigurationOptions.getConfigProperties();

                 this.authors.put(lowerCaseName, newAuthor);

                 if (p != null && !bAnon) {

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

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

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

                         newAuthor.setEmail(p.getProperty("user." + lowerCaseName + ".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));

         }

         /**

          * @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;

         }

         /**

          * New in StatSVN: We need to have access to FileBuilders after they have been created to populate them with version numbers later on.

          * 

          * @todo Beef up this interface to better encapsulate the data structure.

          * 

          * @return this builder's contained (@link FileBuilder)s.

          */

         public Map getFileBuilders() {

                 return fileBuilders;

         }

         /**

          * @see RepositoryFileManager#getLinesOfCode(String)

          */

         public int getLOC(final String filename) throws NoLineCountException {

                 if (repositoryFileManager == null) {

                         throw new NoLineCountException("no RepositoryFileManager");

                 }

                 return repositoryFileManager.getLinesOfCode(filename);

         }

         public String getProjectName() {

                 return projectName;

         }

         /**

          * @see RepositoryFileManager#getRevision(String)

          */

         public String getRevision(final String filename) throws IOException {

                 if (repositoryFileManager == null) {

                         throw new IOException("no RepositoryFileManager");

                 }

                 return repositoryFileManager.getRevision(filename);

         }

         /**

          * 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, final Date date) {

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

                 if (sym != null) {

                         return sym;

                 } else {

                         sym = new SymbolicName(name, date);

                         symbolicNames.put(name, sym);

                         return sym;

                 }

         }

         /**

          * 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 && excludePattern.matches(filename)) {

                         return false;

                 }

                 if (includePattern != null) {

                         return includePattern.matches(filename);

                 }

                 return true;

         }

         /**

          * Matches a tag against the tag patterns. 

          * 

          * @param tag

          *            a tag

          * @return <tt>true</tt> if the tag matches the tag pattern.

          */

         public boolean matchesTagPatterns(final String tag) {

                 if (tagsPattern != null) {

                         return tagsPattern.matcher(tag).matches();

                 }

                 return false;

         }

         /**

          * New in StatSVN: Updates a particular revision for a file with new line count information. If the file or revision does not exist, action will do nothing.

          * 

          * Necessary because line counts are not given in the log file and hence can only be added in a second pass.

          * 

          * @param filename

          *            the file to be updated

          * @param revisionNumber

          *            the revision number to be updated

          * @param linesAdded

          *            the lines that were added

          * @param linesRemoved

          *            the lines that were removed

          */

         public synchronized void updateRevision(final String filename, final String revisionNumber, final int linesAdded, final int linesRemoved) {

                 final FileBuilder fb = (FileBuilder) fileBuilders.get(filename);

                 if (fb != null) {

                         fb.updateRevision(revisionNumber, linesAdded, linesRemoved);

                 }

         }

         /**

          * return only a set of matching tag names (from a list on the command line).

          */

         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;

         }

         private static final class AuthorAnonymizingProvider {

                 private AuthorAnonymizingProvider() {

                         // no access

                 }

                 private static int count = 0;

                 static synchronized String getNewName() {

                         return "author" + (String.valueOf(++count));

                 }

         }

 }