/*
 * FindBugs - Find Bugs in Java programs
 * Copyright (C) 2006, University of Maryland
 *
 * 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
 */

package edu.umd.cs.findbugs;

import java.io.IOException;
import java.io.Serializable;

import javax.annotation.CheckForNull;
import javax.annotation.Nonnull;

import edu.umd.cs.findbugs.cloud.Cloud.UserDesignation;
import edu.umd.cs.findbugs.util.Util;
import edu.umd.cs.findbugs.xml.XMLAttributeList;
import edu.umd.cs.findbugs.xml.XMLOutput;
import edu.umd.cs.findbugs.xml.XMLWriteable;

class to hold the user annotation and user designation for a BugInstance
/**
 * class to hold the user annotation and user designation for a BugInstance
 */
public class BugDesignation implements XMLWriteable, Serializable, Comparable<BugDesignation> {

    
The default key for the user designation. Bad things could happen if this
key isn't in getUserDesignations()
/**
     * The default key for the user designation. Bad things could happen if this
     * key isn't in getUserDesignations()
     */
    public static final String UNCLASSIFIED = UserDesignation.UNCLASSIFIED.name();

    
user designation -- value should be one of the keys returned by
I18N.getInstance().getUserDesignations()
/**
     * user designation -- value should be one of the keys returned by
     * I18N.getInstance().getUserDesignations()
     */
    @Nonnull
    private String designation = UNCLASSIFIED;

    @Override
    public String toString() {
        String result = designation;
        if (user != null) {
            result += " by " + user;
        }
        if (annotationText != null && annotationText.length() > 0) {
            result += " : " + annotationText;
        }
        return result;
    }

    private boolean dirty;

    public boolean isDirty() {
        return dirty;
    }

    public void cleanDirty() {
        setDirty(false);
    }
    public void setDirty(boolean dirty) {
        if (this.dirty == dirty) {
            return;
        }
        this.dirty = dirty;
        //        if (dirty) {
        //            System.out.println("Setting dirty bit");
        //            new RuntimeException("Setting dirty bit").printStackTrace(System.out);
        //        } else {
        //            System.out.println("Clearing dirty bit");
        //            new RuntimeException("Clearing dirty bit").printStackTrace(System.out);
        //        }
    }

    private @javax.annotation.CheckForNull
    String user;

    public BugDesignation() {
    }

    
Params:
designation – 
timestamp – 
annotationText – 
user – /**
     * @param designation
     * @param timestamp
     * @param annotationText
     * @param user
     */
    public BugDesignation(String designation, long timestamp, String annotationText, String user) {
        this.designation = designation;
        this.timestamp = timestamp;
        this.annotationText = annotationText;
        this.user = user;
    }

    public BugDesignation(BugDesignation that) {
        this(that.designation, that.timestamp, that.annotationText, that.user);
    }

    private long timestamp = System.currentTimeMillis();

    
free text from the user /** free text from the user */
    // TODO: make this @CheckForNull
    private String annotationText;

    
return the user designation E.g., "MOSTLY_HARMLESS", "CRITICAL",
"NOT_A_BUG", etc.
Note that this is the key, suitable for writing to XML, but not for
showing to the user.
See Also:
getUserDesignation.getUserDesignation(String key)/**
     * return the user designation E.g., "MOSTLY_HARMLESS", "CRITICAL",
     * "NOT_A_BUG", etc.
     *
     * Note that this is the key, suitable for writing to XML, but not for
     * showing to the user.
     *
     * @see I18N#getUserDesignation(String key)
     */
    @Nonnull
    public String getDesignationKey() {
        return designation;
    }

    public boolean hasDesignationKey() {
        return designation.length() > 0 && !designation.equals(UNCLASSIFIED);
    }
    
set the user designation E.g., "MOSTLY_HARMLESS", "CRITICAL",
"NOT_A_BUG", etc.
If the argument is null, it will be treated as UNCLASSIFIED.
Note that this is the key, suitable for writing to XML, but not what the
user sees. Strange things could happen if designationKey is not one of
the keys returned by I18N.instance().getUserDesignations().
See Also:
getUserDesignationKeys.getUserDesignationKeys()/**
     * set the user designation E.g., "MOSTLY_HARMLESS", "CRITICAL",
     * "NOT_A_BUG", etc.
     *
     * If the argument is null, it will be treated as UNCLASSIFIED.
     *
     * Note that this is the key, suitable for writing to XML, but not what the
     * user sees. Strange things could happen if designationKey is not one of
     * the keys returned by I18N.instance().getUserDesignations().
     *
     * @see I18N#getUserDesignationKeys()
     */
    public void setDesignationKey(String designationKey) {
        if ("".equals(designationKey)) {
            assert false;
            designationKey = null;
        }
        if (designation.equals(designationKey)) {
            return;
        }
        setDirty(true);
        timestamp = System.currentTimeMillis();
        designation = (designationKey != null ? designationKey : UNCLASSIFIED);
    }

    @CheckForNull
    public String getUser() {
        return user;
    }

    public void setUser(String u) {
        user = u;
    }

    public long getTimestamp() {
        return timestamp;
    }

    public void setTimestamp(long ts) {
        if (timestamp != ts) {
            timestamp = ts;
            if (false && !hasAnnotationText() && !hasDesignationKey()) {
                new RuntimeException("Setting timestamp on bug designation without annotation or designation").printStackTrace(System.out);
            }
            setDirty(true);
        }
    }

    @CheckForNull
    public String getAnnotationText() {
        return annotationText;
    }

    public boolean hasAnnotationText() {
        return annotationText != null && annotationText.length() > 0;
    }

    @Nonnull
    public String getNonnullAnnotationText() {
        if (annotationText == null) {
            return "";
        }
        return annotationText;
    }

    public void setAnnotationText(String s) {
        if (s.equals(annotationText)) {
            return;
        }
        setDirty(true);
        annotationText = s;
        timestamp = System.currentTimeMillis();
    }

    @Override
    public void writeXML(XMLOutput xmlOutput) throws IOException {
        XMLAttributeList attributeList = new XMLAttributeList();
        // all three of these xml attributes are optional
        if (hasDesignationKey()) {
            attributeList.addAttribute("designation", designation);
        }
        if (user != null && !"".equals(user)) {
            attributeList.addAttribute("user", user);
        }
        if (dirty) {
            attributeList.addAttribute("needsSync", "true");
        }
        if (timestamp > 0) {
            attributeList.addAttribute("timestamp", String.valueOf(timestamp));
        }

        if ((annotationText != null && !"".equals(annotationText))) {
            xmlOutput.openTag("UserAnnotation", attributeList);
            xmlOutput.writeCDATA(annotationText);
            xmlOutput.closeTag("UserAnnotation");
        } else {
            xmlOutput.openCloseTag("UserAnnotation", attributeList);
        }
    }

    
replace unset fields of this user designation with values set in the
other
/**
     * replace unset fields of this user designation with values set in the
     * other
     */
    public void merge(@CheckForNull BugDesignation other) {
        if (other == null) {
            return;
        }
        boolean changed = false;
        if ((annotationText == null || annotationText.length() == 0) && other.annotationText != null
                && other.annotationText.length() > 0) {
            annotationText = other.annotationText;
            setDirty(true);
            changed = true;
        }
        if (!hasDesignationKey() && other.hasDesignationKey()) {
            designation = other.designation;
            setDirty(true);
            changed = true;
        }
        if (!changed)
        {
            return; // if no changes don't even try to copy user or timestamp
        }

        if ((user == null || user.length() == 0) && other.user != null && other.user.length() > 0) {
            user = other.user;
        }
        if (timestamp == 0 && other.timestamp != 0) {
            timestamp = other.timestamp;
        }
    }

    @Override
    public int hashCode() {
        int hash = (int) this.timestamp;
        if (user != null) {
            hash += user.hashCode();
        }
        hash += designation.hashCode();
        if (annotationText != null) {
            hash += annotationText.hashCode();
        }
        return hash;
    }

    @Override
    public boolean equals(Object o) {
        if (!(o instanceof BugDesignation)) {
            return false;
        }
        return this.compareTo((BugDesignation) o) == 0;
    }

    @Override
    public int compareTo(BugDesignation o) {
        if (this == o) {
            return 0;
        }
        int result = Util.compare(o.timestamp, this.timestamp);
        if (result != 0) {
            return result;
        }

        result = Util.nullSafeCompareTo(this.user, o.user);
        if (result != 0) {
            return result;
        }

        result = this.designation.compareTo(o.designation);
        if (result != 0) {
            return result;
        }
        result = Util.nullSafeCompareTo(this.annotationText, o.annotationText);
        if (result != 0) {
            return result;
        }

        return 0;

    }

}