# SPDX-License-Identifier: Apache-2.0

import unittest

from mesonbuild.mesonlib import (
    Range, Version, version_compare,
    version_compare_many, version_compare_condition_with_min,
    search_version,
)


class VersionComparisonTests(unittest.TestCase):

    def test_version_ordering(self):
        LT = -1
        EQ = 0
        #GT = 1

        # mostly from RPM tests
        tests = [
            ("1.0", "1.0", EQ),
            ("1_0", "1_0", EQ),
            ("1_0", "1.0", EQ),
            ("1.0", "2.0", LT),
            ("2.0", "2.0.0", LT),
            ("2.0", "2.0.1", LT),
            ("2.0.1", "2.0.1", EQ),
            ("2.0.1", "2.0.1a", LT),
            ("2.0.1a", "2.0.1a", EQ),
            ("2.10", "3.111", LT),
            ("2.456", "2.1000", LT),
            ("1.2rc1", "1.2.0", LT),
            ("5.5p1", "5.5p1", EQ),
            ("5.5p1", "5.5p2", LT),
            ("5.5p1", "5.5p10", LT),
            ("10xyz", "10.1xyz", LT),
            ("xyz10", "xyz10", EQ),
            ("xyz10", "xyz10.1", LT),
            ("xyz.4", "8", LT),
            ("xyz.4", "2", LT),
            ("5.5p2", "5.6p1", LT),
            ("5.6p1", "6.5p1", LT),
            ("6.0", "6.0.rc1", LT),
            ("10a2", "10b2", LT),
            ("1.0aa", "1.0aa", EQ),
            ("1.0a", "1.0aa", LT),
            ("10.0001", "10.1", EQ),
            ("10.0001", "10.0039", LT),
            ("1.05", "1.5", EQ),
            ("2a", "2.0", LT),
        ]

        for (a, b, result) in tests:
            with self.subTest(f'({a!r}, {b!r})'):
                ver_a = Version(a)
                ver_b = Version(b)

                self.assertEqual(ver_a <= ver_b, result <= 0, f'{ver_a} <= {ver_b}')
                self.assertEqual(ver_a < ver_b, result < 0, f'{ver_a} <= {ver_b}')
                self.assertEqual(ver_a > ver_b, result > 0, f'{ver_a} <= {ver_b}')
                self.assertEqual(ver_a >= ver_b, result >= 0, f'{ver_a} <= {ver_b}')

                self.assertEqual(ver_a == ver_b, result == 0, f'{ver_a} <= {ver_b}')
                self.assertEqual(ver_b == ver_a, result == 0, f'{ver_a} <= {ver_b}')
                self.assertEqual(ver_a != ver_b, result != 0, f'{ver_a} <= {ver_b}')
                self.assertEqual(ver_b != ver_a, result != 0, f'{ver_a} <= {ver_b}')

                self.assertEqual(ver_b <= ver_a, -result <= 0, f'{ver_a} <= {ver_b}')
                self.assertEqual(ver_b < ver_a, -result < 0, f'{ver_a} <= {ver_b}')
                self.assertEqual(ver_b > ver_a, -result > 0, f'{ver_a} <= {ver_b}')
                self.assertEqual(ver_b >= ver_a, -result >= 0, f'{ver_a} <= {ver_b}')

    def test_version_compare(self):
        """Test version_compare with operator prefixes."""
        self.assertTrue(version_compare('1.0', '>=1.0'))
        self.assertTrue(version_compare('1.1', '>=1.0'))
        self.assertFalse(version_compare('0.9', '>=1.0'))

        self.assertTrue(version_compare('1.0', '<=1.0'))
        self.assertTrue(version_compare('0.9', '<=1.0'))
        self.assertFalse(version_compare('1.1', '<=1.0'))

        self.assertTrue(version_compare('1.0', '>0.9'))
        self.assertFalse(version_compare('1.0', '>1.0'))

        self.assertTrue(version_compare('1.0', '<1.1'))
        self.assertFalse(version_compare('1.0', '<1.0'))

        self.assertTrue(version_compare('1.0', '==1.0'))
        self.assertFalse(version_compare('1.0', '==1.1'))

        self.assertTrue(version_compare('1.0', '!=1.1'))
        self.assertFalse(version_compare('1.0', '!=1.0'))

        # bare version and = means ==
        self.assertTrue(version_compare('1.0', '1.0'))
        self.assertFalse(version_compare('1.0', '1.1'))
        self.assertTrue(version_compare('1.0', '=1.0'))
        self.assertFalse(version_compare('1.0', '=1.1'))

    def test_version_compare_many(self):
        result, not_found, found = version_compare_many('1.5', ['>=1.0', '<2.0'])
        self.assertTrue(result)
        self.assertEqual(not_found, [])
        self.assertEqual(found, ['>=1.0', '<2.0'])

        result, not_found, found = version_compare_many('0.5', ['>=1.0', '<2.0'])
        self.assertFalse(result)
        self.assertEqual(not_found, ['>=1.0'])
        self.assertEqual(found, ['<2.0'])

        result, not_found, found = version_compare_many('2.5', ['>=1.0', '<2.0'])
        self.assertFalse(result)
        self.assertEqual(not_found, ['<2.0'])
        self.assertEqual(found, ['>=1.0'])

        # string condition is treated as single-element list
        result, not_found, found = version_compare_many('1.0', '>=1.0')
        self.assertTrue(result)
        self.assertEqual(not_found, [])
        self.assertEqual(found, ['>=1.0'])

    def test_version_compare_condition_with_min(self):
        # >= condition: minimum must be <= condition version
        self.assertTrue(version_compare_condition_with_min('>=0.46.0', '0.46.0'))
        self.assertTrue(version_compare_condition_with_min('>=0.50.0', '0.46.0'))
        self.assertFalse(version_compare_condition_with_min('>=0.40.0', '0.46.0'))

        # > condition: minimum must be <= condition version
        self.assertTrue(version_compare_condition_with_min('>0.46.0', '0.46.0'))
        self.assertTrue(version_compare_condition_with_min('>0.50.0', '0.46.0'))
        self.assertFalse(version_compare_condition_with_min('>0.45.0', '0.46.0'))

        # == condition: minimum must be <= condition version
        self.assertTrue(version_compare_condition_with_min('==0.46.0', '0.46.0'))
        self.assertTrue(version_compare_condition_with_min('==0.50.0', '0.46.0'))
        self.assertFalse(version_compare_condition_with_min('==0.40.0', '0.46.0'))

        # = or bare condition is the same as ==
        self.assertTrue(version_compare_condition_with_min('=0.46.0', '0.46.0'))
        self.assertTrue(version_compare_condition_with_min('0.46.0', '0.46.0'))
        self.assertFalse(version_compare_condition_with_min('0.40.0', '0.46.0'))

        # < and <= conditions always return False (includes versions older than minimum)
        self.assertFalse(version_compare_condition_with_min('<1.0.0', '0.46.0'))
        self.assertFalse(version_compare_condition_with_min('<=1.0.0', '0.46.0'))
        self.assertFalse(version_compare_condition_with_min('<0.30.0', '0.46.0'))
        self.assertFalse(version_compare_condition_with_min('<=0.30.0', '0.46.0'))

        # != condition always returns False
        self.assertFalse(version_compare_condition_with_min('!=0.40.0', '0.46.0'))

        # test behavior of two-component versions
        # '0.46.0' is mangled to '0.46' so that '>=0.46.0' works, but this is
        # not done by version_compare_condition_with_min
        self.assertFalse(version_compare_condition_with_min('>=0.46', '0.46.0'))
        self.assertFalse(version_compare_condition_with_min('>=0.46', '0.46.1'))
        self.assertTrue(version_compare_condition_with_min('>=0.46.0', '0.46'))
        self.assertTrue(version_compare_condition_with_min('>=0.46.1', '0.46'))

    def test_range_contains(self):
        """Test Range.__contains__."""
        # unbounded range contains everything
        r = Range()
        self.assertIn(5, r)
        self.assertIn(0, r)

        # min only, inclusive
        r = Range(min=3, min_eq=True)
        self.assertIn(3, r)
        self.assertIn(5, r)
        self.assertNotIn(2, r)

        # min only, exclusive
        r = Range(min=3, min_eq=False)
        self.assertNotIn(3, r)
        self.assertIn(4, r)
        self.assertNotIn(2, r)

        # max only, inclusive
        r = Range(max=7, max_eq=True)
        self.assertIn(7, r)
        self.assertIn(5, r)
        self.assertNotIn(8, r)

        # max only, exclusive
        r = Range(max=7, max_eq=False)
        self.assertNotIn(7, r)
        self.assertIn(6, r)
        self.assertNotIn(8, r)

        # both bounds, inclusive
        r = Range(min=3, min_eq=True, max=7, max_eq=True)
        self.assertIn(3, r)
        self.assertIn(5, r)
        self.assertIn(7, r)
        self.assertNotIn(2, r)
        self.assertNotIn(8, r)

        # both bounds, exclusive
        r = Range(min=3, min_eq=False, max=7, max_eq=False)
        self.assertNotIn(3, r)
        self.assertIn(5, r)
        self.assertNotIn(7, r)

        # empty range contains nothing
        r = Range(min=5, min_eq=False, max=5, max_eq=False)
        self.assertNotIn(5, r)

        # min == max, both inclusive -> single point, not empty
        r = Range(min=5, max=5, min_eq=True, max_eq=True)
        self.assertIn(5, r)

    def test_range_init_trivial(self):
        """Test that __post_init__ detects trivial ranges."""
        r = Range()
        self.assertFalse(r.is_empty)

        # min > max
        r = Range(min=7, max=3, min_eq=True, max_eq=True)
        self.assertTrue(r.is_empty)

        # min == max, not both inclusive -> empty
        r = Range(min=5, max=5, min_eq=True, max_eq=False)
        self.assertTrue(r.is_empty)

        r = Range(min=5, max=5, min_eq=False, max_eq=True)
        self.assertTrue(r.is_empty)

        r = Range(min=5, max=5, min_eq=False, max_eq=False)
        self.assertTrue(r.is_empty)

        # min == max, both inclusive -> single point, not empty
        r = Range(min=5, max=5, min_eq=True, max_eq=True)
        self.assertFalse(r.is_empty)

    def test_range_intersect(self):
        """Test Range.intersect."""
        # intersect two overlapping ranges
        a = Range(min=1, min_eq=True, max=10, max_eq=True)
        b = Range(min=5, min_eq=True, max=15, max_eq=True)
        r = a.intersect(b)
        self.assertIn(5, r)
        self.assertIn(10, r)
        self.assertNotIn(4, r)
        self.assertNotIn(11, r)

        # intersect does not mutate original
        self.assertIn(4, a)

        # intersect narrows unbounded range
        a = Range()
        b = Range(min=3, min_eq=True, max=7, max_eq=False)
        r = a.intersect(b)
        self.assertIn(3, r)
        self.assertIn(6, r)
        self.assertNotIn(2, r)
        self.assertNotIn(7, r)

        # intersect non-overlapping ranges produces empty
        a = Range(min=1, min_eq=True, max=3, max_eq=True)
        b = Range(min=5, min_eq=True, max=7, max_eq=True)
        r = a.intersect(b)
        self.assertTrue(r.is_empty)

        # intersect with matching boundary tightens eq
        a = Range(min=5, min_eq=True)
        b = Range(min=5, min_eq=False)
        r = a.intersect(b)
        self.assertEqual(5, r.min)
        self.assertNotIn(5, r)

        a = Range(max=5, max_eq=True)
        b = Range(max=5, max_eq=False)
        r = a.intersect(b)
        self.assertEqual(5, r.max)
        self.assertIn(4, r)

        # intersecting empty range stays empty
        a = Range(min=7, max=3, min_eq=True, max_eq=True)
        self.assertTrue(a.is_empty)
        b = Range(min=1, min_eq=True, max=10, max_eq=True)
        r = a.intersect(b)
        self.assertTrue(r.is_empty)

        b = Range()
        r = a.intersect(b)
        self.assertTrue(r.is_empty)

        a = Range()
        b = Range(min=7, max=3, min_eq=True, max_eq=True)
        r = a.intersect(b)
        self.assertTrue(r.is_empty)

    def test_range_always(self):
        """Range.always checks if inner is always true/false given outer."""
        outer = Range(min=5, min_eq=True, max=10, max_eq=True)
        unbounded = Range()
        empty = Range(min=7, max=3, min_eq=True, max_eq=True)

        # inner fully contains outer => true
        self.assertTrue(outer.always(Range(min=3, min_eq=True)))
        self.assertTrue(outer.always(Range(max=12, max_eq=True)))
        self.assertTrue(outer.always(unbounded))

        # inner same as outer => true
        self.assertTrue(outer.always(Range(min=5, min_eq=True, max=10, max_eq=True)))

        # inner doesn't overlap outer => false
        self.assertFalse(outer.always(Range(min=11, min_eq=True)))
        self.assertFalse(outer.always(Range(max=4, max_eq=True)))

        # inner partially overlaps => indeterminate
        self.assertIsNone(outer.always(Range(min=7, min_eq=True)))
        self.assertIsNone(outer.always(Range(max=8, max_eq=True)))

        # exclusive boundaries count as a partial overlap
        self.assertIsNone(outer.always(Range(min=5, min_eq=False)))
        self.assertIsNone(outer.always(Range(max=10, max_eq=False)))

        # outer is unbounded
        self.assertIsNone(unbounded.always(Range(min=5, min_eq=True)))
        self.assertTrue(unbounded.always(unbounded))
        self.assertFalse(unbounded.always(empty))

        # outer is empty => always false (intersection is empty)
        self.assertFalse(empty.always(Range(min=5, min_eq=True)))
        self.assertFalse(empty.always(unbounded))
        self.assertFalse(empty.always(empty))

    def test_range_str(self):
        """Test Range.__str__."""
        self.assertEqual(str(Range()), '(any)')
        self.assertEqual(str(Range(min=3, min_eq=True)), '>= 3')
        self.assertEqual(str(Range(min=3, min_eq=False)), '> 3')
        self.assertEqual(str(Range(max=7, max_eq=True)), '<= 7')
        self.assertEqual(str(Range(max=7, max_eq=False)), '< 7')
        self.assertEqual(str(Range(min=3, min_eq=True, max=7, max_eq=False)), '>= 3, < 7')
        self.assertEqual(str(Range(min=5, max=5, min_eq=True, max_eq=True)), '== 5')
        # empty range
        r = Range(min=7, max=3, min_eq=True, max_eq=True)
        self.assertEqual(str(r), '(empty)')

    def test_range_str_version(self):
        """Test Range.__str__ with Version objects."""
        r = Range(min=Version('0.46.0'), min_eq=True)
        self.assertEqual(str(r), '>= 0.46.0')
        r = Range(min=Version('1.0'), min_eq=True, max=Version('2.0'), max_eq=False)
        self.assertEqual(str(r), '>= 1.0, < 2.0')

    def test_search_version(self):
        self.assertEqual(search_version('foo 1.2.3'), '1.2.3')
        self.assertEqual(search_version('1.2.3'), '1.2.3')
        self.assertEqual(search_version('foo 2026.03.20 1.2.3'), '1.2.3')
        self.assertEqual(search_version('2026.03.20 1.2.3'), '1.2.3')
        self.assertEqual(search_version('foo 2026.03.20'), '2026.03.20')
        self.assertEqual(search_version('2026.03.20'), '2026.03.20')
        self.assertEqual(search_version('2026.03'), '2026.03')
        self.assertEqual(search_version('2026.03 1.2.3'), '1.2.3')
        self.assertEqual(search_version('foo v1.2.3'), '1.2.3')
        self.assertEqual(search_version('2026'), 'unknown version')