/*******************************************************************************
 * Copyright (c) 2011, 2012 Oracle and/or its affiliates. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
 * which accompanies this distribution.
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Version
 *   class defines OSGi-like behavior to a version object
 *   it has an identifier (Major.Minor.Micro.Qualifier) and can compare itself to others
 *   it can report its identifier, and its identifier can be set
 *
 * Contributors:
 *     egwin - initial conception and implementation
 */

package org.eclipse.persistence.buildtools.helper;

import java.lang.NumberFormatException;

import org.eclipse.persistence.buildtools.helper.VersionException;;

public class Version {
    private String  identifier = "0.0";
    private Integer major = 0;
    private Integer minor = 0;
    private Integer micro = 0;
    private String  qualifier = "";

    private int[] indexList = {0,0,0};               //holds the indexes of the "."s in the identifier string.

    // helper
    private String validateIdentifier(String identifier) throws VersionException{
        String validated=identifier;
        boolean error=false;

        // clear leading whitespace
        while ( validated.startsWith(" ") || validated.startsWith("\t") )
            validated=validated.substring(1);
        // clear trailing whitespace
        while ( validated.endsWith(" ") || validated.endsWith("\t") )
            validated=validated.substring(0,validated.length() - 1);

        if ( validated.startsWith(".") ) {
            throw new VersionException("Initial version tokenizer found (.): Invalid version string '" + validated + "'.");
        }
        else {
            if( validated.endsWith(".") ) {
                throw new VersionException("Terminating version tokenizer found (.): Invalid version string '" + validated + "'.");
            }
            else {
                int index = 0;
                int subindex = 0;
                int count = 0;
                int maxindex = validated.lastIndexOf(".");
                while( !error && ( (subindex = validated.substring(index).indexOf(".")) >0 || index<maxindex )) {
                    if(count>2 && subindex>0)
                        throw new VersionException("Maximum (4) tokens exceeded: Invalid version string '" + validated + "'.");
                    else {
                        index += subindex;
                        indexList[count] = index;
                        index++;                //increment to point to char after found '.'
                        count++;
                    }
                }
            }
        }
        return validated;
    }

    // setter
    private void setMajor(Integer major) {
        this.major = major;
    }
    private void setMinor(Integer minor) {
        this.minor = minor;
    }
    private void setMicro(Integer micro) {
        this.micro = micro;
    }
    private void setQualifier(String qualifier) {
        this.qualifier = qualifier;
    }

    private void setAll(String identifier) throws VersionException{
        // assumes basic validation completed
        try {
            if( identifier != "" ){
                if( indexList[0] > 0 ) {
                    setMajor(Integer.valueOf( identifier.substring(0, indexList[0])));
                    if( indexList[1] > 0 ) {
                        setMinor(Integer.valueOf( identifier.substring(indexList[0]+1, indexList[1])));
                        if( indexList[2] > 0 ) {
                            setMicro(Integer.valueOf( identifier.substring(indexList[1]+1, indexList[2])));
                            setQualifier(identifier.substring(indexList[2]+1));
                        }
                        else
                            setMicro(Integer.valueOf( identifier.substring(indexList[1]+1)));
                    }
                    else
                        setMinor(Integer.valueOf( identifier.substring(indexList[0]+1) ));
                }
                else
                    setMajor(Integer.valueOf(identifier));
            }
        } catch ( NumberFormatException e){
            throw new VersionException("Major.Minor.Micro tokens expected to be numeric. One or more is invalid. " + e.getMessage() + " in \"" + identifier + "\".", e);
        }
        String validIdentifier = get3PartStr();
        if(getQualifier() != null && getQualifier() != "" ) {
            validIdentifier+= "." + getQualifier();
        }
        this.identifier = validIdentifier;
    }

    // Public methods
    //     constructors
    public Version() {
    }
    public Version(String identifier) {
        setIdentifier(identifier);
    }

    // getters
    public Integer getMajorInt() {
        return this.major;
    }
    public Integer getMinorInt() {
        return this.minor;
    }
    // Micro also referred to as "bugfix" token of version
    public Integer getMicroInt() {
        return this.micro;
    }
    public String getMajorStr() {
        return this.major.toString();
    }
    public String getMinorStr() {
        return this.minor.toString();
    }
    public String getMicroStr() {
        return this.micro.toString();
    }
    public String get3PartStr() {
        return getMajorStr() + "." + getMinorStr() + "." + getMicroStr();
    }
    public String getQualifier() {
        return this.qualifier;
    }
    public String getIdentifier() {
        return this.identifier;
    }

    // setters
    public void setIdentifier(String identifier) {
        setAll(validateIdentifier(identifier));
    }

    // Compare Versions
    public boolean gt( Version comp ) {
        boolean result=false;

        if(this.major > comp.getMajorInt()) result = true;
        else if ( (this.major == comp.getMajorInt()) && (this.minor > comp.getMinorInt()) ) result = true;
             else if ( (this.major == comp.getMajorInt()) && (this.minor == comp.getMinorInt()) && (this.micro > comp.getMicroInt()) ) result=true;
                  else if ( (this.major == comp.getMajorInt()) && (this.minor == comp.getMinorInt()) && (this.micro == comp.getMicroInt()) && (this.qualifier.compareTo(comp.getQualifier()) > 0) ) result=true;

        return result;
    }
    public boolean lt( Version comp ) {
        boolean result=false;

        if(this.major < comp.getMajorInt()) result = true;
        else if ( (this.major == comp.getMajorInt()) && (this.minor < comp.getMinorInt()) ) result = true;
             else if ( (this.major == comp.getMajorInt()) && (this.minor == comp.getMinorInt()) && (this.micro < comp.getMicroInt()) ) result=true;
                  else if ( (this.major == comp.getMajorInt()) && (this.minor == comp.getMinorInt()) && (this.micro == comp.getMicroInt()) && (this.qualifier.compareTo(comp.getQualifier()) < 0) ) result=true;

        return result;
    }
    public boolean eq( Version comp ) {
        boolean result=false;

        if( (this.major == comp.getMajorInt()) && (this.minor == comp.getMinorInt()) && (this.micro == comp.getMicroInt()) && (this.qualifier.compareTo(comp.getQualifier()) == 0) ) {
            result = true;
        }
        return result;
    }
    public boolean ge( Version comp ) {
        boolean result=false;

        if( (this.gt(comp) || this.eq(comp) ) ) result = true;
        return result;
    }
    public boolean le( Version comp ) {
        boolean result=false;

        if( (this.lt(comp) || this.eq(comp) ) ) result = true;
        return result;
    }

    public boolean empty() {
        boolean result=false;

        if( (this.major == 0) && (this.minor == 0) && (this.micro == 0) && (this.qualifier.compareTo("") == 0) ) {
            result = true;
        }
        return result;
    }

    // Compare version strings
    //public boolean gt( String comp ) {
    //    boolean result=false;
    //
    //    if(this.identifier.compareTo(comp) > 0) {
    //        result = true;
    //    }
    //    return result;
    //}
    //public boolean lt( String comp ) {
    //    boolean result=false;
    //
    //    if(this.identifier.compareTo(comp) < 0) {
    //        result = true;
    //    }
    //    return result;
    //}
    //public boolean ge( String comp ) {
    //    boolean result=false;
    //
    //    if(this.identifier.compareTo(comp) >= 0) {
    //        result = true;
    //    }
    //    return result;
    //}
    //public boolean le( String comp ) {
    //    boolean result=false;
    //
    //    if(this.identifier.compareTo(comp) <= 0) {
    //        result = true;
    //    }
    //    return result;
    //}
    //public boolean eq( String comp ) {
    //    boolean result=false;
    //
    //    if(this.identifier.equals(comp)) {
    //        result = true;
    //    }
    //    return result;
    //}
}