/*-----------------------------------------------------------------------+
 | com.teamscale.index
 |                                                                       |
   $Id$            
 |                                                                       |
 | Copyright (c)  2009-2012 CQSE GmbH                                 |
 +-----------------------------------------------------------------------*/
package org.conqat.engine.index.shared;

import java.io.Serializable;
import java.util.Comparator;

import javax.annotation.Nullable;

import org.conqat.engine.commons.findings.DetachedFinding;
import org.conqat.engine.commons.findings.location.ElementLocation;
import org.conqat.engine.commons.findings.location.TextRegionLocation;
import org.conqat.lib.commons.js_export.ExportToJavaScript;

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.thoughtworks.xstream.annotations.XStreamOmitField;

/**
 * A tracked finding extends the {@link DetachedFinding} by additional
 * attributes that are calculated via tracking.
 *
 * <strong>This class is used for communication with IDE clients (via the
 * {@link org.conqat.engine.service.shared.client.IdeServiceClient}), so special
 * care has to be taken when changing its signature!</strong>
 */
@ExportToJavaScript
public class TrackedFinding extends IndexFinding implements Serializable, Comparable<TrackedFinding> {

        private static final String EQUALS_HASHCODE_NOT_SUPPORTED_MESSAGE = "Tracked findings should never be used in HashSets, "
                        + "as equality should rely on the id, but the id must be mutable (which can cause havok when the object is part of a HashSet). "
                        + "Please use a map with id as key instead!";

        /** Version used for serialization. */
        private static final long serialVersionUID = 1;

        /** The name of the JSON property name for {@link #id}. */
        private static final String ID_PROPERTY = "id";

        /** The name of the JSON property name for {@link #birth}. */
        private static final String BIRTH_PROPERTY = "birth";

        /** The name of the JSON property name for {@link #death}. */
        private static final String DEATH_PROPERTY = "death";

        /**
         * The partition in the finding index of this finding. We have to store it in
         * the index (hence it is not transient, to include it in Java serialization),
         * but we do not want our clients to see it (hence the JsonIgnore annotation).
         */
        @XStreamOmitField
        @JsonIgnore
        private final String findingIndexPartition;

        /**
         * The id of this finding. This is a hexadecimal representation of a MD5 hash
         * code.
         */
        @JsonProperty(ID_PROPERTY)
        private String id;

        /** Commit of the birth of this finding. */
        @JsonProperty(BIRTH_PROPERTY)
        private final CommitDescriptor birth;

        /**
         * Commit of the death of this finding, i.e. the first commit where this did not
         * exist anymore. While this is <code>null</code> the finding is still alive.
         */
        @JsonProperty(DEATH_PROPERTY)
        @Nullable
        private CommitDescriptor death = null;

        public TrackedFinding(IndexFinding finding, String id, CommitDescriptor birthCommit, String findingIndexPartition) {
                super(finding);
                this.id = id;
                this.birth = birthCommit;
                this.findingIndexPartition = findingIndexPartition;
        }

        public TrackedFinding(IndexFinding finding, String id, CommitDescriptor birth, String findingIndexPartition,
                        CommitDescriptor death) {
                this(finding, id, birth, findingIndexPartition);
                this.death = death;
        }

        /** Copy constructor. */
        protected TrackedFinding(TrackedFinding other) {
                super(other);
                this.id = other.id;
                this.birth = other.birth;
                this.death = other.death;
                this.findingIndexPartition = other.findingIndexPartition;
        }

        @JsonCreator
        public TrackedFinding(@JsonProperty(GROUP_NAME_PROPERTY) String groupName,
                        @JsonProperty(CATEGORY_NAME_PROPERTY) String categoryName, @JsonProperty(MESSAGE_PROPERTY) String message,
                        @JsonProperty(LOCATION_PROPERTY) ElementLocation location, @JsonProperty(ID_PROPERTY) String id,
                        @JsonProperty(BIRTH_PROPERTY) CommitDescriptor birthCommit,
                        @JsonProperty(DEATH_PROPERTY) CommitDescriptor deathCommit) {
                super(groupName, categoryName, message, location);
                this.id = id;
                this.birth = birthCommit;
                this.death = deathCommit;
                this.findingIndexPartition = null;
        }

        /** Returns the id of this finding. */
        public String getId() {
                return id;
        }

        public void setId(String id) {
                this.id = id;
        }

        /** Returns the birth commit. */
        public CommitDescriptor getBirthCommit() {
                return birth;
        }

        /** Returns the partition in the findings index of this finding. */
        public String getFindingIndexPartition() {
                return findingIndexPartition;
        }

        /**
         * Returns the death commit (or null for findings that are still alive).
         */
        public CommitDescriptor getDeathCommit() {
                return death;
        }

        /**
         * Sets the death commit. Use <code>null</code> to indicate that it is still
         * alive.
         */
        public void setDeathCommit(CommitDescriptor death) {
                this.death = death;
        }

        /** Returns whether this finding is still alive. */
        public boolean isAlive() {
                return death == null;
        }

        /**
         * {@inheritDoc}
         * <p>
         * Sorts by ID.
         */
        @Override
        public int compareTo(TrackedFinding other) {
                return id.compareTo(other.id);
        }

        /**
         * Returns the qualified group name, i.e. the concatenation of the category and
         * group separated by /
         */
        public String getQualifiedGroupName() {
                return getCategoryName() + "/" + getGroupName();
        }

        /** A basic comparator used for TrackedFindings. */
        public static class TrackedFindingComparator implements Comparator<TrackedFinding> {

                @Override
                public int compare(TrackedFinding f1, TrackedFinding f2) {
                        String p1 = f1.getLocation().getUniformPath();
                        String p2 = f2.getLocation().getUniformPath();
                        int pathComparison = p1.compareTo(p2);
                        if (pathComparison != 0) {
                                return pathComparison;
                        }

                        if (f1.getLocation() instanceof TextRegionLocation && f2.getLocation() instanceof TextRegionLocation) {
                                TextRegionLocation l1 = (TextRegionLocation) f1.getLocation();
                                TextRegionLocation l2 = (TextRegionLocation) f2.getLocation();
                                int startDiff = l1.getRawStartLine() - l2.getRawStartLine();
                                if (startDiff == 0) {
                                        return l1.getRawEndLine() - l2.getRawEndLine();
                                }
                                return startDiff;
                        }
                        if (f1.getLocation() instanceof TextRegionLocation) {
                                return -1;
                        }
                        if (f2.getLocation() instanceof TextRegionLocation) {
                                return 1;
                        }
                        return 0;
                }
        }

        @Override
        public boolean equals(Object obj) {
                throw new UnsupportedOperationException(EQUALS_HASHCODE_NOT_SUPPORTED_MESSAGE);
        }

        @Override
        public int hashCode() {
                throw new UnsupportedOperationException(EQUALS_HASHCODE_NOT_SUPPORTED_MESSAGE);
        }
}