/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package usda.weru.weps.startup;


import de.schlichtherle.io.File;
import java.util.LinkedList;
import java.util.List;
import org.apache.log4j.Logger;

/**
 *
 * @author Joseph Levin <joelevin@weru.ksu.edu>
 */
public class ReleaseVersion implements Comparable<ReleaseVersion> {
    private static final Logger LOGGER = Logger.getLogger(ReleaseVersion.class);
    protected String c_release;
    protected Integer[] c_version;

    public ReleaseVersion(String text) throws IllegalArgumentException{
        try {
            int indexOfBar = text.indexOf("_");
            if(indexOfBar < 0){
                throw new IllegalArgumentException("missing _");
            }
            c_release = text.substring(0, indexOfBar);
            
            List<Integer> versions = new LinkedList<Integer>();
            int indexOfLastDot = indexOfBar;

            for(int indexOfNextDot = text.indexOf(".", indexOfLastDot + 1);indexOfNextDot >0; indexOfNextDot = text.indexOf(".", indexOfLastDot + 1)){
                String version = text.substring(indexOfLastDot + 1, indexOfNextDot);
                versions.add(Integer.valueOf(version));
                indexOfLastDot = indexOfNextDot;
            }
            String version = text.substring(indexOfLastDot + 1);
            versions.add(Integer.valueOf(version));

            if(versions.isEmpty()){
                throw new IllegalStateException("No version numbers.");
            }            

            c_version = versions.toArray(new Integer[versions.size()]);


        } catch (Exception e) {
            throw new IllegalArgumentException("invalid format, must be release_x.y.z[.n]", e);
        }
    }

    public static ReleaseVersion valueOf(String text){
        return valueOf(new File(text));
    }

    public static ReleaseVersion valueOf(File file){
        try{
            return new ReleaseVersion(file.getName());
        }
        catch(Exception e){
            String path = file != null ? file.getAbsolutePath() : "NULL";
            LOGGER.error("Unable to parse ReleaseVersion from file: " + path, e);
            return null;
        }
    }

    public ReleaseVersion(String release, Integer... version){
        c_release = release;
        c_version = version;
    }

    @Override
    public String toString() {
        StringBuilder buffer = new StringBuilder();
        buffer.append(c_release);
        boolean major = true;
        for(int i : c_version){
            if(major){
                buffer.append("_");
                major = false;
            }
            else{
                buffer.append(".");
            }
            buffer.append(String.valueOf(i));
        }
        return buffer.toString();
    }

    public boolean isReleaseEqual(ReleaseVersion other) {
        return c_release.equals(other.c_release);
    }

    @Override
    public int compareTo(ReleaseVersion other) {
        if(other == null){
            return 1;
        }
        if(isReleaseEqual(other)){
            //go through each version
            int compareSize = Math.max(c_version.length, other.c_version.length);

            for(int i = 0; i < compareSize; i++){

                int subCompare = other.c_version[i] - c_version[i];
                if(subCompare == 0){
                    continue;
                }
                else{
                    return subCompare;
                }
            }


        }
        else{
            return c_release.compareTo(other.c_release);
        }

        return 0;
    }
}