/* UnitTerm

 Copyright (c) 2003-2014 The Regents of the University of California.
 All rights reserved.
 Permission is hereby granted, without written agreement and without
 license or royalty fees, to use, copy, modify, and distribute this
 software and its documentation for any purpose, provided that the above
 copyright notice and the following two paragraphs appear in all copies
 of this software.

 IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY
 FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
 ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
 THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF
 SUCH DAMAGE.

 THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
 INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE
 PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF
 CALIFORNIA HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
 ENHANCEMENTS, OR MODIFICATIONS.

 PT_COPYRIGHT_VERSION_3
 COPYRIGHTENDKEY
 */
package ptolemy.moml.unit;

import ptolemy.kernel.util.IllegalActionException;

///////////////////////////////////////////////////////////////////
//// UnitTerm

/** UnitTerm represents a term in a Unit Expression.
 A UnitTerm has 1) an exponent and 2) an element.
 The element
 can be either 1) a Unit, 2) a variable, or 3) a
 Unit Expression. These choices for element are mutually exclusive.
 UnitTerms are usually constructed as a result of parsing a Unit Expression.

 @author Rowland R Johnson
 @version $Id$
 @since Ptolemy II 8.0
 @Pt.ProposedRating Red (rowland)
 @Pt.AcceptedRating Red (rowland)
 */
public class UnitTerm implements UnitPresentation {
    /**
     * Construct a UnitTerm with no element.
     *
     */
    public UnitTerm() {
    }

    /** Construct an instance where the contained element is a Unit.
     * @param unit The Unit that will be the element of this instance.
     */
    public UnitTerm(Unit unit) {
        _type = _UNIT;
        _unit = unit;
    }

    ///////////////////////////////////////////////////////////////////
    ///////////////////////// public methods //////////////////////////

    /** Make a shallow copy of this UnitTerm. That is, the underlying Unit or
     *  UnitExpr is not copied.
     * @return The copy of this UnitTerm
     */
    public UnitTerm copy() {
        UnitTerm retv = new UnitTerm();
        retv.setVariable(_variable);
        retv.setExponent(getExponent());
        retv.setUnit(_unit);
        retv.setUnitExpr(_unitExpr);
        retv._setType(_type);
        return retv;
    }

    /**
     * Create a String that is understandable by a human.
     * @see ptolemy.moml.unit.UnitPresentation#descriptiveForm()
     */
    @Override
    public String descriptiveForm() {
        String retv = null;

        switch (_type) {
        case _VARIABLE: {
            retv = "$" + _variable;
            break;
        }

        case _UNIT: {
            retv = _unit.descriptiveForm();
            break;
        }

        case _UNITEXPR: {
            retv = "(" + _unitExpr.descriptiveForm() + ")";
            break;
        }
        }

        if (getExponent() != 1) {
            retv += "^" + getExponent();
        }

        return retv;
    }

    /**
     * @return The exponent.
     */
    public int getExponent() {
        return _exponent;
    }

    /** Get the element if it is a Unit.
     * @return The Unit if the element is a Unit, otherwise null.
     */
    public Unit getUnit() {
        if (_type == _UNIT) {
            return _unit;
        }

        return null;
    }

    /** Get the element if it is a UnitExpr.
     * @return The UnitExpr if the element is a UnitExpr, otherwise null.
     */
    public UnitExpr getUnitExpr() {
        if (_type == _UNITEXPR) {
            return _unitExpr;
        }

        return null;
    }

    /** Get the element if it is a variable.
     * @return The variable if the element is a variable, null otherwise.
     */
    public String getVariable() {
        if (_type == _VARIABLE) {
            return _variable;
        }

        return null;
    }

    /** Invert this UnitTerm.
     * @return The inverse of this UnitTerm.
     */
    public UnitTerm invert() {
        UnitTerm retv = copy();

        switch (_type) {
        case _VARIABLE:
        case _UNIT: {
            retv.setExponent(-getExponent());
            break;
        }

        case _UNITEXPR: {
            retv.setUnitExpr(_unitExpr.invert());
            break;
        }
        }

        return retv;
    }

    /** True if this is a Unit.
     * @return True if this is a Unit.
     */
    public boolean isUnit() {
        return _type == _UNIT;
    }

    /** True is this is a UnitExpr.
     * @return True is this is a UnitExpr.
     */
    public boolean isUnitExpr() {
        return _type == _UNITEXPR;
    }

    /** True if this a variable.
     * @return True if this a variable.
     */
    public boolean isVariable() {
        return _type == _VARIABLE;
    }

    /** Set the exponent.
     * @param exponent The exponent.
     */
    public void setExponent(int exponent) {
        _exponent = exponent;
    }

    /** Set the element to be a Unit.
     * @param unit The Unit.
     */
    public void setUnit(Unit unit) {
        _type = _UNIT;
        _unit = unit;
    }

    /** Set the element to be a UnitExpr.
     * @param expr The Unit Expression.
     */
    public void setUnitExpr(UnitExpr expr) {
        _type = _UNITEXPR;
        _unitExpr = expr;
    }

    /** Set the element to be a variable
     * @param v The variable.
     */
    public void setVariable(String v) {
        _type = _VARIABLE;
        _variable = v;
    }

    /*
     * (non-Javadoc)
     *
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        String retv = null;

        switch (_type) {
        case _VARIABLE: {
            retv = _variable;
            break;
        }

        case _UNIT: {
            retv = _unit.toString();
            break;
        }

        case _UNITEXPR: {
            retv = "(" + _unitExpr.toString() + ")";
            break;
        }
        }

        if (getExponent() != 1) {
            retv += "^" + getExponent();
        }

        return retv;
    }

    /** Visit an instance of UnitTerm.
     * @param visitor The visitor.
     * @return The result of visiting the UnitTerm.
     */
    public Object visit(EquationVisitor visitor) throws IllegalActionException {
        return visitor._visitUnitTerm(this);
    }

    ///////////////////////////////////////////////////////////////////
    ///////////////////////// protected methods //////////////////////////

    /**
     * @param type The Unit type.
     */
    protected void _setType(int type) {
        _type = type;
    } ///////////////////////////////////////////////////////////////////

    ////                         private variables                 ////
    private static final int _UNIT = 1;

    private static final int _UNITEXPR = 2;

    private static final int _VARIABLE = 3;

    private int _exponent = 1;

    private int _type = -1;

    private Unit _unit = null;

    private UnitExpr _unitExpr = null;

    private String _variable = null;
}