#!/usr/bin/env python
# Copyright 2017 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import re
import sys

import deb_version


class PackageVersionIntervalEndpoint:
    def __init__(self, is_open, is_inclusive, version):
        self._is_open = is_open
        self._is_inclusive = is_inclusive
        self._version = version

    def _intersect(self, other, is_start):
        if self._is_open and other._is_open:
            return self
        if self._is_open:
            return other
        if other._is_open:
            return self
        cmp_code = self._version.__cmp__(other._version)
        if not is_start:
            cmp_code *= -1
        if cmp_code > 0:
            return self
        if cmp_code < 0:
            return other
        if not self._is_inclusive:
            return self
        return other

    def __str__(self):
        return 'PackageVersionIntervalEndpoint(%s, %s, %s)' % (
            self._is_open,
            self._is_inclusive,
            self._version,
        )

    def __eq__(self, other):
        if self._is_open and other._is_open:
            return True
        return (
            self._is_open == other._is_open
            and self._is_inclusive == other._is_inclusive
            and self._version == other._version
        )


class PackageVersionInterval:
    def __init__(self, string_rep, package, start, end):
        self.string_rep = string_rep
        self.package = package
        self.start = start
        self.end = end

    def contains(self, version):
        if not self.start._is_open:
            if self.start._is_inclusive:
                if version < self.start._version:
                    return False
            elif version <= self.start._version:
                return False
        if not self.end._is_open:
            if self.end._is_inclusive:
                if version > self.end._version:
                    return False
            elif version >= self.end._version:
                return False
        return True

    def intersect(self, other):
        return PackageVersionInterval(
            '',
            '',
            self.start._intersect(other.start, True),
            self.end._intersect(other.end, False),
        )

    def implies(self, other):
        if self.package != other.package:
            return False
        return self.intersect(other) == self

    def __str__(self):
        return 'PackageVersionInterval(%s)' % self.string_rep

    def __eq__(self, other):
        return self.start == other.start and self.end == other.end


class PackageVersionIntervalSet:
    def __init__(self, intervals):
        self.intervals = intervals

    def formatted(self):
        return ' | '.join([interval.string_rep for interval in self.intervals])

    def _interval_implies_other_intervals(self, interval, other_intervals):
        for other_interval in other_intervals:
            if interval.implies(other_interval):
                return True
        return False

    def implies(self, other):
        # This disjunction implies |other| if every term in this
        # disjunction implies some term in |other|.
        for interval in self.intervals:
            if not self._interval_implies_other_intervals(
                interval, other.intervals
            ):
                return False
        return True


def version_interval_endpoints_from_exp(op, version):
    open_endpoint = PackageVersionIntervalEndpoint(True, None, None)
    inclusive_endpoint = PackageVersionIntervalEndpoint(False, True, version)
    exclusive_endpoint = PackageVersionIntervalEndpoint(False, False, version)
    if op == '>=':
        return (inclusive_endpoint, open_endpoint)
    if op == '<=':
        return (open_endpoint, inclusive_endpoint)
    if op == '>>' or op == '>':
        return (exclusive_endpoint, open_endpoint)
    if op == '<<' or op == '<':
        return (open_endpoing, exclusive_endpoint)
    assert op == '='
    return (inclusive_endpoint, inclusive_endpoint)


def parse_dep(dep):
    """Parses a package and version requirement formatted by dpkg-shlibdeps.

    Args:
        dep: A string of the format "package (op version)"

    Returns:
        A PackageVersionInterval.
    """
    package_name_regex = r'[a-z][a-z0-9\+\-\.]+'
    match = re.match('^(%s)$' % package_name_regex, dep)
    if match:
        return PackageVersionInterval(
            dep,
            match.group(1),
            PackageVersionIntervalEndpoint(True, None, None),
            PackageVersionIntervalEndpoint(True, None, None),
        )
    match = re.match(
        r'^(%s) \(([\>\=\<]+) ([\~0-9A-Za-z\+\-\.\:]+)\)$' % package_name_regex,
        dep,
    )
    if match:
        (start, end) = version_interval_endpoints_from_exp(
            match.group(2), deb_version.DebVersion(match.group(3))
        )
        return PackageVersionInterval(dep, match.group(1), start, end)
    print >> sys.stderr, 'Failed to parse ' + dep
    sys.exit(1)


def parse_interval_set(deps):
    r"""Parses a disjunction of package version requirements.

    Args:
        deps: A string of the format
            "package \(op version\) (| package \(op version\))*"

    Returns:
        A list of PackageVersionIntervals
    """
    return PackageVersionIntervalSet(
        [parse_dep(dep.strip()) for dep in deps.split('|')]
    )