/* This software was designed and created by Jason Carroll.
    * Copyright (c) 2002, 2003, 2004 Jason Carroll.
    * The author can be reached at jcarroll@cowsultants.com
    * ITracker website: http://www.cowsultants.com
    * ITracker forums: http://www.cowsultants.com/phpBB/index.php
    *
    * This program is free software; you can redistribute it and/or modify
    * it only under the terms of the GNU General Public License as published by
    * the Free Software Foundation; either version 2 of the License, or
   * (at your option) any later version.
   *
   * This program 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 General Public License for more details.
   */
  package org.itracker.model;
  
  import java.io.Serializable;
  import java.util.Comparator;
  
  import org.apache.commons.lang.builder.CompareToBuilder;
  import org.apache.commons.lang.builder.ToStringBuilder;
  
  /**
   * A Project version.
   * 
   * <p>
   * A Version can only belong to 1 Project (composition).
   * </p>
   * 
   * @author ready
   */
  public class Version extends AbstractEntity implements Comparable<Entity> {
  
  	/**
  	 * 
  	 */
  	private static final long serialVersionUID = 1L;
  
  	/**
  	 * Invariant: never <tt>null</tt>.
  	 */
  	private Project project;
  
  	/**
  	 * Invariant: never <tt>null</tt>.
  	 */
  	private String number;
  
  	/*
  	 * major and minor are only used to compare Versions. They can be computed
  	 * from the <code>number</code> attribute, PENDING: We should also allow
  	 * to specify them separately in order not to impose any constraint on the
  	 * format of the version number.
  	 */
  	private int major;
  	private int minor;
  
  	private String description;
  
  	/**
  	 * Version status.
  	 * <p>
  	 * Invariant: never <tt>null</tt>.
  	 * </p>
  	 */
  	private Status status;
  
  	/*
  	 * This class used to have a <code>issues</code> attribute, which was a
  	 * Collection<Issue>. This has been removed because the association Version -
  	 * Issue doesn't need to be navigatable in this direction.
  	 */
  
  	public static final Comparator<Version> VERSION_COMPARATOR = new VersionComparator();
  
  	/**
  	 * Default constructor (required by Hibernate).
  	 * 
  	 * <p>
  	 * PENDING: should be <code>private</code> so that it can only be used by
  	 * Hibernate, to ensure that <code>project</code> and <code>number</code>,
  	 * which form an instance's identity, are never <tt>null</tt>.
  	 * </p>
  	 */
  	public Version() {
  	}
  
  	/**
  	 * Creates a new active Version for the given Project.
  	 * 
  	 * @param project
  	 *            project to which this version belongs
  	 * @param number
  	 *            unique within the project
  	 */
  	public Version(Project project, String number) {
  		setProject(project);
 		setVersionInfo(number);
 
 		// A new version is active by default.
 		this.status = Status.ACTIVE;
 	}
 
 	public int getMajor() {
 		return major;
 	}
 
 	public void setMajor(int getMajor) {
 		this.major = getMajor;
 	}
 
 	public int getMinor() {
 		return minor;
 	}
 
 	public void setMinor(int getMinor) {
 		this.minor = getMinor;
 	}
 
 	public String getNumber() {
 		return number;
 	}
 
 	public void setNumber(String getNumber) {
 		this.number = getNumber;
 	}
 
 	public String getDescription() {
 		return description;
 	}
 
 	public void setDescription(String getDescription) {
 		this.description = getDescription;
 	}
 
 	public Project getProject() {
 		return project;
 	}
 
 	public void setProject(Project project) {
 		if (project == null) {
 			throw new IllegalArgumentException("null project");
 		}
 		this.project = project;
 	}
 
 	/**
 	 * Returns this version's status.
 	 * 
 	 * @return enum constant
 	 */
 	public Status getStatus() {
 		return status;
 	}
 
 	/**
 	 * Sets this version's status.
 	 * 
 	 * @param status
 	 *            enum constant
 	 * @throws IllegalArgumentException
 	 *             <code>status</code> is <tt>null</tt>
 	 */
 	public void setStatus(Status status) {
 		if (status == null) {
 			throw new IllegalArgumentException("null status");
 		}
 		this.status = status;
 	}
 
 	/**
 	 * Convience method to set the number, major and minor fields with a single
 	 * call. It will first set the number to the provided data, and then attempt
 	 * to parse the info if in the form major.minor into parts to set the other
 	 * information.
 	 * 
 	 * @param versionInfo
 	 *            the version number string to use
 	 */
 	public void setVersionInfo(String versionInfo) {
 		setNumber(versionInfo);
 
 		if (null == versionInfo) {
 			throw new IllegalArgumentException("version info must not be null.");
 		}
 		String versionNumber = this.number.trim();
 		int firstDot = versionNumber.indexOf('.');
 		String major = "0";
 		major = (firstDot > 0 ? versionNumber.substring(0, firstDot).trim()
 				: versionNumber.trim());
 
 		try {
 			setMajor(Integer.parseInt(major));
 		} catch (NumberFormatException ex) {
 			setMajor(0);
 		}
 
 		int secondDot = (firstDot > -1 ? versionNumber.indexOf('.',
 				firstDot + 1) : -1);
 		String minor = (secondDot > -1 ? versionNumber.substring(firstDot + 1,
 				secondDot).trim() : versionNumber.substring(firstDot + 1)
 				.trim());
 		try {
 			setMinor(Integer.parseInt(minor));
 		} catch (NumberFormatException ex) {
 			setMinor(0);
 		}
 	}
 
 	/**
 	 * @return <tt>Version [id=<id>, project=<project>, number=<number>]</tt>
 	 */
 	@Override
 	public String toString() {
 		return new ToStringBuilder(this).append("id", getId()).append("number",
 				getNumber()).append("project", getProject()).append(getMajor()).append(getMinor())
 				.append("status", getStatus()).toString();
 	}
 
 	/**
 	 * Compares 2 Versions by major and minor number.
 	 */
 	public static final class VersionComparator implements Comparator<Version>, Serializable {
 		/**
 		 * 
 		 */
 		private static final long serialVersionUID = 1L;
 
 		private boolean ascending = true;
 
 		public VersionComparator() {
 		}
 
 		public VersionComparator(boolean ascending) {
 			setAscending(ascending);
 		}
 
 		private boolean isAscending() {
 			return ascending;
 		}
 
 		private void setAscending(boolean ascending) {
 			this.ascending = ascending;
 		}
 
 		public int compare(Version a, Version b) {
 			int result = new CompareToBuilder().append(a.getNumber(), b.getNumber())
 					.append(a.getMajor(), b.getMajor()).append(a.getMinor(), b.getMinor()).toComparison();
 
 			return (isAscending() ? result : -result);
 		}
 
 	}
 
 }