/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.cassandra.sidecar.common;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

import com.google.common.base.Objects;

/**
 * Implements versioning used in Cassandra and CQL.
 * <p>
 * Note: The following code uses a slight variation from the semver document (http://semver.org).
 * </p>
 *
 * The rules here are a bit different than normal semver comparison.  For simplicity,
 * an alpha version of 4.0 or a snapshot is equal to 4.0.  This allows us to test sidecar
 * against alpha versions of a release.
 *
 * While it's possible to implement full version comparison, it's likely not very useful
 * This is because the main testing we are going to do will be against release versions - something like 4.0.
 * We want to list an adapter as being compatible with 4.0 - and that should include 4.0 alpha, etc.
 */
public class SimpleCassandraVersion implements Comparable<SimpleCassandraVersion>
{
    /**
     * note: 3rd group matches to words but only allows number and checked after regexp test.
     * this is because 3rd and the last can be identical.
     **/
    private static final String VERSION_REGEXP = "(\\d+)\\.(\\d+)(?:\\.(\\w+))?(\\-[.\\w]+)?([.+][.\\w]+)?";

    private static final Pattern pattern = Pattern.compile(VERSION_REGEXP);
    private static final Pattern SNAPSHOT = Pattern.compile("-SNAPSHOT");

    public final int major;
    public final int minor;
    public final int patch;

    /**
     * Parse a version from a string.
     *
     * @param version the string to parse
     * @throws IllegalArgumentException if the provided string does not
     *                                  represent a version
     */
    public static SimpleCassandraVersion create(String version)
    {
        String stripped = SNAPSHOT.matcher(version).replaceFirst("");
        Matcher matcher = pattern.matcher(stripped);
        if (!matcher.matches())
            throw new IllegalArgumentException("Invalid version value: " + version);

        try
        {
            int major = Integer.parseInt(matcher.group(1));
            int minor = Integer.parseInt(matcher.group(2));
            int patch = matcher.group(3) != null ? Integer.parseInt(matcher.group(3)) : 0;

            return SimpleCassandraVersion.create(major, minor, patch);
        }
        catch (NumberFormatException e)
        {
            throw new IllegalArgumentException("Invalid version value: " + version, e);
        }
    }

    public static SimpleCassandraVersion create(int major, int minor, int patch)
    {
        if (major < 0 || minor < 0 || patch < 0)
        {
            throw new IllegalArgumentException();
        }
        return new SimpleCassandraVersion(major, minor, patch);
    }

    public static SimpleCassandraVersion create(ICassandraFactory factory)
    {
        return SimpleCassandraVersion.create(factory.getClass().getAnnotation(MinimumVersion.class).value());
    }

    private SimpleCassandraVersion(int major, int minor, int patch)
    {
        this.major = major;
        this.minor = minor;
        this.patch = patch;
    }


    public int compareTo(SimpleCassandraVersion other)
    {
        if (major < other.major)
            return -1;
        if (major > other.major)
            return 1;

        if (minor < other.minor)
            return -1;
        if (minor > other.minor)
            return 1;

        if (patch < other.patch)
            return -1;
        if (patch > other.patch)
            return 1;
        return 0;
    }

    @Override
    public boolean equals(Object o)
    {
        if (!(o instanceof SimpleCassandraVersion))
            return false;
        SimpleCassandraVersion that = (SimpleCassandraVersion) o;
        return major == that.major
                && minor == that.minor
                && patch == that.patch;
    }

    /**
     * Returns true if this > v2
     * @param v2
     * @return
     */
    public boolean isGreaterThan(SimpleCassandraVersion v2)
    {
        return compareTo(v2) > 0;
    }

    @Override
    public int hashCode()
    {
        return Objects.hashCode(major, minor, patch);
    }

    @Override
    public String toString()
    {
        StringBuilder sb = new StringBuilder();
        sb.append(major).append('.').append(minor).append('.').append(patch);

        return sb.toString();
    }
}