/**
    * Copyright (c) 2009-2010, Elias Gomes. All rights reserved.
    * 
    * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
    * following conditions are met:
    * 
    * - Redistributions of source code must retain the above copyright notice, this list of conditions and the following
    * disclaimer.
    * 
   * - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
   * disclaimer in the documentation and/or other materials provided with the distribution.
   * 
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
   * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
   * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   */
  package net.sourceforge.mystique.domain.entity;
  
  import java.util.Date;
  import java.util.LinkedList;
  import java.util.List;
  
  import javax.persistence.CascadeType;
  import javax.persistence.Column;
  import javax.persistence.Entity;
  import javax.persistence.EnumType;
  import javax.persistence.Enumerated;
  import javax.persistence.GeneratedValue;
  import javax.persistence.GenerationType;
  import javax.persistence.Id;
  import javax.persistence.JoinColumn;
  import javax.persistence.JoinTable;
  import javax.persistence.ManyToMany;
  import javax.persistence.ManyToOne;
  import javax.persistence.NamedQueries;
  import javax.persistence.NamedQuery;
  import javax.persistence.OneToMany;
  import javax.persistence.SequenceGenerator;
  import javax.persistence.Table;
  import javax.persistence.Temporal;
  import javax.persistence.TemporalType;
  import javax.persistence.Transient;
  
  import net.sourceforge.mystique.domain.valueobject.Priority;
  import net.sourceforge.mystique.domain.valueobject.Resolution;
  import net.sourceforge.mystique.domain.valueobject.Severity;
  import net.sourceforge.mystique.domain.valueobject.Status;
  import net.sourceforge.mystique.domain.valueobject.Type;
  
  /**
   * @author Elias Gomes [eliasgomes@users.sourceforge.net]
   */
  @Entity
  @Table(name = "TB_TICKET")
  @SequenceGenerator(name = "ticketIdSeq", sequenceName = "TICKET_ID_SEQ", initialValue = 1, allocationSize = 1)
  @NamedQueries(@NamedQuery(name = "Ticket.findAll", query = "SELECT t FROM Ticket t ORDER BY t.reported"))
  /*
   * TODO: Any of the QA users can set the ticket as verified or all of them have to agree? Maybe both. If just one QA
   * user, any or all does not apply, so first add the QA users, then select the verification mode.
   * 
   * TODO: Ticket needs observers
   * 
   * TODO: Update "modified" after each method invocation
   */
  public class Ticket {
  
  	@Id
  	@GeneratedValue(generator = "ticketIdSeq", strategy = GenerationType.SEQUENCE)
  	@Column(name = "ID")
  	private Long id;
  
  	@Column(name = "SUMMARY", nullable = false)
  	private String summary;
  
  	@Column(name = "DESCRIPTION", nullable = false)
  	private String description;
  
  	@ManyToOne
  	@JoinColumn(name = "REPORTER_USER_ID", nullable = false)
  	private User reporter;
  
  	@Temporal(TemporalType.TIMESTAMP)
  	@Column(name = "REPORTED", nullable = false)
  	private Date reported;
  
  	@Temporal(TemporalType.TIMESTAMP)
  	@Column(name = "MODIFIED", nullable = false)
  	private Date modified;
  
  	@ManyToOne
  	@JoinColumn(name = "PROJECT_ID", nullable = false)
  	private Project project;
  
  	@ManyToOne
  	@JoinColumn(name = "COMPONENT_ID")
 	private Component component;
 
 	@ManyToOne
 	@JoinColumn(name = "MILESTONE_ID")
 	private Milestone milestone;
 
 	@ManyToOne
 	@JoinColumn(name = "VERSION_ID")
 	private Version version;
 
 	@Enumerated(EnumType.STRING)
 	@Column(name = "SEVERITY", nullable = false)
 	private Severity severity;
 
 	@Enumerated(EnumType.STRING)
 	@Column(name = "PRIORITY", nullable = false)
 	private Priority priority;
 
 	@ManyToOne
 	@JoinColumn(name = "DUPLICATE_OF_TICKET_ID")
 	private Ticket duplicateOf;
 
 	@OneToMany(mappedBy = "duplicateOf")
 	private List<Ticket> duplicates;
 
 	@Enumerated(EnumType.STRING)
 	@Column(name = "TYPE", nullable = false)
 	private Type type;
 
 	@Enumerated(EnumType.STRING)
 	@Column(name = "STATUS", nullable = false)
 	private Status status;
 
 	@Enumerated(EnumType.STRING)
 	@Column(name = "RESOLUTION")
 	private Resolution resolution;
 
 	@ManyToMany
 	@JoinTable(name = "TB_TICKET_ASSIGNED_TO_USER", joinColumns = @JoinColumn(name = "TICKET_ID"), inverseJoinColumns = @JoinColumn(name = "USER_ID"))
 	private List<User> usersAssignedTo;
 
 	@ManyToMany(mappedBy = "ticketsToApprove")
 	private List<User> qualityAssuranceUsers;
 
 	@ManyToMany
 	@JoinTable(name = "TB_TICKET_DEPENDS_ON_TICKET", joinColumns = @JoinColumn(name = "TICKET_ID"), inverseJoinColumns = @JoinColumn(name = "TICKET_DEPENDENCY_ID"))
 	private List<Ticket> itDependsOn;
 
 	@ManyToMany(mappedBy = "itDependsOn")
 	private List<Ticket> dependsOnIt;
 
 	@OneToMany(mappedBy = "ticket", cascade = CascadeType.ALL)
 	private List<Attachment> attachments;
 
 	@OneToMany(mappedBy = "ticket", cascade = CascadeType.ALL)
 	private List<Comment> comments;
 
 	@OneToMany(mappedBy = "ticket", cascade = CascadeType.ALL)
 	private List<Confirmation> confirmations;
 
 	public Ticket() {
 		setReported(new Date());
 		setModified(new Date());
 		setDuplicates(new LinkedList<Ticket>());
 		setUsersAssignedTo(new LinkedList<User>());
 		setQualityAssuranceUsers(new LinkedList<User>());
 		setAttachments(new LinkedList<Attachment>());
 		setItDependsOn(new LinkedList<Ticket>());
 		setDependsOnIt(new LinkedList<Ticket>());
 		setComments(new LinkedList<Comment>());
 		setConfirmations(new LinkedList<Confirmation>());
 	}
 
 	@Transient
 	public boolean isNew() {
 		return (id == null);
 	}
 
 	public void addAttachment(Attachment attachment) {
 		attachment.setTicket(this);
 		getAttachments().add(attachment);
 	}
 
 	public void addComment(Comment comment) {
 		comment.setTicket(this);
 		getComments().add(comment);
 	}
 
 	public void addConfirmation(Confirmation confirmation) {
 		confirmation.setTicket(this);
 		for (Confirmation c : getConfirmations()) {
 			if (c.getResponsible().equals(confirmation.getResponsible())) {
 				return;
 			}
 		}
 		getConfirmations().add(confirmation);
 	}
 
 	public Long getId() {
 		return id;
 	}
 
 	public void setId(Long id) {
 		this.id = id;
 	}
 
 	public String getSummary() {
 		return summary;
 	}
 
 	public void setSummary(String summary) {
 		if (summary != null) {
 			this.summary = summary.trim();
 		}
 		this.summary = summary;
 	}
 
 	public String getDescription() {
 		return description;
 	}
 
 	public void setDescription(String description) {
 		if (description != null) {
 			this.description = description.trim();
 		}
 		this.description = description;
 	}
 
 	public User getReporter() {
 		return reporter;
 	}
 
 	public void setReporter(User reporter) {
 		this.reporter = reporter;
 	}
 
 	public Date getReported() {
 		return reported;
 	}
 
 	public void setReported(Date reported) {
 		this.reported = reported;
 	}
 
 	public Date getModified() {
 		return modified;
 	}
 
 	public void setModified(Date modified) {
 		this.modified = modified;
 	}
 
 	public Project getProject() {
 		return project;
 	}
 
 	public void setProject(Project project) {
 		this.project = project;
 	}
 
 	public Component getComponent() {
 		return component;
 	}
 
 	public void setComponent(Component component) {
 		this.component = component;
 	}
 
 	public Milestone getMilestone() {
 		return milestone;
 	}
 
 	public void setMilestone(Milestone milestone) {
 		this.milestone = milestone;
 	}
 
 	public Version getVersion() {
 		return version;
 	}
 
 	public void setVersion(Version version) {
 		this.version = version;
 	}
 
 	public Severity getSeverity() {
 		return severity;
 	}
 
 	public void setSeverity(Severity severity) {
 		this.severity = severity;
 	}
 
 	public Priority getPriority() {
 		return priority;
 	}
 
 	public void setPriority(Priority priority) {
 		this.priority = priority;
 	}
 
 	public Ticket getDuplicateOf() {
 		return duplicateOf;
 	}
 
 	public void setDuplicateOf(Ticket duplicateOf) {
 		this.duplicateOf = duplicateOf;
 	}
 
 	public List<Ticket> getDuplicates() {
 		return duplicates;
 	}
 
 	public void setDuplicates(List<Ticket> duplicates) {
 		this.duplicates = duplicates;
 	}
 
 	public Type getType() {
 		return type;
 	}
 
 	public void setType(Type type) {
 		this.type = type;
 	}
 
 	public Status getStatus() {
 		return status;
 	}
 
 	public void setStatus(Status status) {
 		this.status = status;
 	}
 
 	public Resolution getResolution() {
 		return resolution;
 	}
 
 	public void setResolution(Resolution resolution) {
 		this.resolution = resolution;
 	}
 
 	public List<User> getUsersAssignedTo() {
 		return usersAssignedTo;
 	}
 
 	public void setUsersAssignedTo(List<User> usersAssignedTo) {
 		this.usersAssignedTo = usersAssignedTo;
 	}
 
 	public List<User> getQualityAssuranceUsers() {
 		return qualityAssuranceUsers;
 	}
 
 	public void setQualityAssuranceUsers(List<User> qualityAssuranceUsers) {
 		this.qualityAssuranceUsers = qualityAssuranceUsers;
 	}
 
 	public List<Ticket> getItDependsOn() {
 		return itDependsOn;
 	}
 
 	public void setItDependsOn(List<Ticket> itDependsOn) {
 		this.itDependsOn = itDependsOn;
 	}
 
 	public List<Ticket> getDependsOnIt() {
 		return dependsOnIt;
 	}
 
 	public void setDependsOnIt(List<Ticket> dependsOnIt) {
 		this.dependsOnIt = dependsOnIt;
 	}
 
 	public List<Attachment> getAttachments() {
 		return attachments;
 	}
 
 	public void setAttachments(List<Attachment> attachments) {
 		this.attachments = attachments;
 	}
 
 	public List<Comment> getComments() {
 		return comments;
 	}
 
 	public void setComments(List<Comment> comments) {
 		this.comments = comments;
 	}
 
 	public List<Confirmation> getConfirmations() {
 		return confirmations;
 	}
 
 	public void setConfirmations(List<Confirmation> confirmations) {
 		this.confirmations = confirmations;
 	}
 
 	@Override
 	public int hashCode() {
 		final int prime = 31;
 		int result = 1;
 		result = prime * result + ((id == null) ? 0 : id.hashCode());
 		return result;
 	}
 
 	@Override
 	public boolean equals(Object obj) {
 		if (this == obj)
 			return true;
 		if (obj == null)
 			return false;
 		if (getClass() != obj.getClass())
 			return false;
 		Ticket other = (Ticket) obj;
 		if (id == null) {
 			if (other.id != null)
 				return false;
 		} else if (!id.equals(other.id))
 			return false;
 		return true;
 	}
 
 }