package com.redstoner.loader;

/**
 * This class represents a version, as the name suggests.
 * <p>
 * Based on:
 * https://msdn.microsoft.com/en-us/library/system.version(v=vs.110).aspx Based
 * on:
 * https://github.com/mono/mono/blob/master/mcs/class/referencesource/mscorlib/system/version.cs
 */
public final class Version implements Comparable<Version>, Cloneable
{

	private final int major;
	private final int minor;
	private final int build;
	private final int revision;

	/**
	 * Initializes a new instance of the Version class, with major=0, minor=0,
	 * build=undefined(-1), revision=undefined(-1)
	 */
	public Version()
	{
		this.major = 0;
		this.minor = 0;
		this.build = -1;
		this.revision = -1;
	}

	/**
	 * Initializes a new instance of the Version class using the specified major
	 * and minor values.
	 *
	 * @param major major value
	 * @param minor minor value
	 * @throws IllegalArgumentException if major or minor is less than 0
	 */
	public Version(int major, int minor)
	{
		this.major = validateRange("major", major);
		this.minor = validateRange("minor", minor);
		this.build = -1;
		this.revision = -1;
	}

	/**
	 * Validates the given component
	 *
	 * @param componentName the name of the component, used for exception message
	 * @param component     the component value
	 * @return the component value
	 * @throws IllegalArgumentException if the component value is out of range // less than 0.
	 */
	private static int validateRange(String componentName, int component)
	{
		if (component < 0)
		{
			throw new IllegalArgumentException('\'' + componentName + "' component out of range: " + component);
		}
		return component;
	}

	/**
	 * Initializes a new instance of the Version class using the specified
	 * major, minor, and build values.
	 *
	 * @param major major value
	 * @param minor minor value
	 * @param build build value
	 * @throws NullPointerException if major, minor or build is less than 0
	 */
	public Version(int major, int minor, int build)
	{
		this.major = validateRange("major", major);
		this.minor = validateRange("minor", minor);
		this.build = validateRange("build", build);
		this.revision = -1;
	}

	/**
	 * Initializes a new instance of the Version class based on string
	 *
	 * @param version the string to parse
	 */
	public Version(String version)
	{
		Version v = parseVersion(version);

		this.major = v.major;
		this.minor = v.minor;
		this.build = v.build;
		this.revision = v.revision;
	}

	/**
	 * Gets a Version object from the given String representation
	 * <p>
	 * A string representation of a Version must follow the regex:
	 * ([0-9]+\.){1-3}[0-9]+ without any numbers in it exceeding
	 * {@link Integer#MAX_VALUE}
	 * <p>
	 * For a simpler representation format: major.minor[.build[.revision]]
	 *
	 * @param input The String representation of a Version
	 * @return a Version
	 * @throws IllegalArgumentException if the input does not follow a Version
	 *                                  syntax.
	 * @throws NullPointerException     if input is null
	 */
	public static Version parseVersion(String input)
	{
		int length = input.length();
		int[] result = new int[]{-1, -1, -1, -1};
		int index = 0;
		int currentNumber = -1;
		int resultIndex = 0;

		while (index < length)
		{
			if (resultIndex == 4)
			{

				throw new IllegalArgumentException("Found a version component beyond the fourth at " + input + "[" + index + "]");
			}

			char c = input.charAt(index);

			// the ascii code for the character '0' is 0x30.
			// used in favor of Character.digit(char, int) for performance.
			int digit = c - 0x30;

			if (c == '.')
			{
				if (currentNumber < 0)
				{
					throw new IllegalArgumentException("Expected a digit at " + input + "[" + index + "], but found " + c);
				}

				result[resultIndex] = currentNumber;
				resultIndex++;
				currentNumber = -1;
			} else if (!(0 <= digit && digit <= 9))
			{
				throw new IllegalArgumentException("Version components must be separated by a '.', but found " + c + " at " + input + "[" + index + "]");
			} else if (currentNumber < 0)
			{
				//Got digit
				currentNumber = digit;
			} else
			{
				// any digit subsequent to the first
				if (currentNumber == 0)
				{
					// ensure we don't have a component that started with 0 and has any additional digits.
					// The first 0 would be obsolete to represent its value, meaning that there would be multiple valid string representations for the same Version
					throw new IllegalArgumentException("Unneeded 0 in version component number is illegal at " + input + "[" + index + "]");
				}

				//Got digit
				currentNumber = currentNumber * 10 + digit;
			}

			index++;
		}

		if (currentNumber >= 0)
		{
			result[resultIndex] = currentNumber;
			resultIndex++;
		}

		switch (resultIndex)
		{
			default:
				throw new IllegalArgumentException("Version requires major and minor value: " + input);
			case 2:
				return new Version(result[0], result[1]);
			case 3:
				return new Version(result[0], result[1], result[2]);
			case 4:
				return new Version(result[0], result[1], result[2], result[3]);
		}
	}

	/**
	 * Initializes a new instance of the Version class with the specified major,
	 * minor, build, and revision numbers.
	 *
	 * @param major    major value
	 * @param minor    minor value
	 * @param build    build value
	 * @param revision revision value
	 * @throws IllegalArgumentException if major, minor, build or revision is
	 *                                  less than 0
	 */
	public Version(int major, int minor, int build, int revision)
	{
		this.major = validateRange("major", major);
		this.minor = validateRange("minor", minor);
		this.build = validateRange("build", build);
		this.revision = validateRange("revision", revision);
	}

	/**
	 * Tries to convert the string representation of a version number to an
	 * equivalent Version object, and returns the result value or null if parse
	 * failed.
	 *
	 * @param input The input to parse
	 * @return The parsed version or null if parse failed.
	 */
	public static Version tryParse(String input)
	{
		try
		{
			return parseVersion(input);
		} catch (Exception ex)
		{
			//Simply ignore the error
			return null;
		}
	}

	/**
	 * Gets the value of the major component of the version number for the
	 * current Version object.
	 *
	 * @return major value
	 */
	public int getMajor()
	{
		return major;
	}

	/**
	 * Gets the value of the minor component of the version number for the
	 * current Version object.
	 *
	 * @return minor value
	 */
	public int getMinor()
	{
		return minor;
	}

	/**
	 * Gets the value of the build component of the version number for the
	 * current Version object.
	 *
	 * @return build value, -1 if undefined
	 */
	public int getBuild()
	{
		return build;
	}

	/**
	 * Gets the value of the revision component of the version number for the
	 * current Version object.
	 *
	 * @return revision value, -1 if undefined
	 */
	public int getRevision()
	{
		return revision;
	}

	/**
	 * Gets the high 16 bits of the revision number.
	 *
	 * @return major revision value, or -1 if revision is undefined
	 */
	public int getMajorRevision()
	{
		return revision == -1 ? -1 : revision >>> 16 & 0xFFFF;
	}

	/**
	 * Gets the low 16 bits of the revision number.
	 *
	 * @return minor revision value, or -1 if revision is undefined
	 */
	public int getMinorRevision()
	{
		return revision == -1 ? -1 : revision & 0xFFFF;
	}

	/**
	 * Compares the current Version object to a specified Version object and
	 * returns an indication of their relative values.
	 *
	 * @param other The version object to compare to
	 * @return 1 if this version is later than other, 0 if this version is equal
	 * to other, and -1 otherwise
	 * @throws NullPointerException if other is null
	 */
	@Override
	public int compareTo(Version other)
	{
		if (other == null)
		{
			return 1;
		}

		if (this.major != other.major)
		{
			return this.major > other.major ? 1 : -1;
		}
		if (this.minor != other.minor)
		{
			return this.minor > other.minor ? 1 : -1;
		}
		if (this.build != other.build)
		{
			return this.build > other.build ? 1 : -1;
		}
		if (this.revision != other.revision)
		{
			return this.revision > other.revision ? 1 : -1;
		}
		return 0;
	}

	@Override
	public int hashCode()
	{
		// rotate each component to start from a different byte
		int major = this.major;
		int minor = (this.minor >>> 8 | this.minor << 24);
		int build = (this.build >>> 16 | this.build << 16);
		int revision = (this.revision >>> 24 | this.revision << 8);
		return major ^ minor ^ build ^ revision;
	}

	@Override
	public boolean equals(Object o)
	{
		if (this == o)
		{
			return true;
		}

		if (o == null || !(o instanceof Version))
		{
			return false;
		}

		Version version = (Version) o;

		return major == version.major
				&& minor == version.minor
				&& build == version.build
				&& revision == version.revision;
	}

	/**
	 * @return a new Version object whose value is the same as the current
	 * Version object.
	 */
	@Override
	public Version clone()
	{
		try
		{
			return (Version) super.clone();
		} catch (Exception ex)
		{
			throw new InternalError("This should never happen", ex);
		}
	}

	/**
	 * Gets a String representation of this Version object. The String
	 * representation of two distinct Version objects is equal if and only if
	 * the two Version objects are equal as declared by
	 * {@link Object#equals(Object)} The returned representation includes at
	 * least 1 component of this version, but will include any components that
	 * are in use.
	 *
	 * @return a String representation of this Version object.
	 */
	@Override
	public String toString()
	{
		return toString(getComponentCount());
	}

	/**
	 * Converts the value of the current Version object to its equivalent String
	 * representation. A specified count indicates the number of components to
	 * return.
	 *
	 * @param components the number of components to include in the string
	 *                   representation of this Version object.
	 * @return A string representation of this version object.
	 * @throws IllegalArgumentException if components is not between 0 and 4
	 *                                  inclusive, or components exceeds {@link #getComponentCount()}
	 */
	public String toString(int components)
	{
		if (!(0 <= components && components <= 4))
		{
			throw new IllegalArgumentException();
		}
		StringBuilder result = new StringBuilder();
		if (0 < components)
		{
			result.append(major);
		}
		if (1 < components)
		{
			result.append('.').append(minor);
		}
		if (2 < components)
		{
			result.append('.').append(build);
		}
		if (3 < components)
		{
			result.append('.').append(revision);
		}
		return result.toString();
	}

	/**
	 * Computes the amount of used components. That is, the number of components
	 * counted up to and including the last defined component.
	 *
	 * @return the amount of used components
	 */
	public int getComponentCount()
	{
		if (revision != -1)
		{
			return 4;
		}
		if (build != -1)
		{
			return 3;
		}
		return 2;
	}
	/*
	/ **
	 * Tries to convert the string representation of a version number to an
	 * equivalent Version object, and returns a value that indicates whether the
	 * conversion succeeded.
	 *
	 * @param input   The input to parse
	 * @param version The result version
	 * @return true if the input was parsed successfully and the result of
	 * parsing the input is equal to the given version
	 * @throws NullPointerException if input is null or version is null
	 * /
	public static boolean tryParse(String input, InOutParam<Version> version) {
		try {
			version.setValue(parseVersion(input));
			return true;
		} catch (IllegalArgumentException ex) {
			return false;
		}
	}
	*/
}