# Copyright 2023 The Pigweed Authors
#
# Licensed 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
#
#     https://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.
"""Tests for the pw_build.gn_config module."""

import unittest

from typing import Iterable

from pw_build.gn_config import (
    consolidate_configs,
    GnConfig,
    GN_CONFIG_FLAGS,
)
from pw_build.gn_utils import GnLabel, MalformedGnError


class TestGnConfig(unittest.TestCase):
    """Tests for gn_config.GnConfig.

    Attributes:
        config: A common config for testing.
    """

    def compare(self, actual: Iterable[str], *expected: str):
        """Sorts lists and compares them."""
        self.assertEqual(sorted(expected), sorted(list(actual)))

    def setUp(self):
        self.config = GnConfig()

    def test_bool_empty(self):
        """Identifies an empty config correctly."""
        self.assertFalse(self.config)

    def test_bool_nonempty(self):
        """Identifies a non-empty config correctly."""
        self.config.add('defines', 'KEY=VAL')
        self.assertTrue(self.config)

    def test_has_none(self):
        """Indicates a config does not have a flag when it has no values."""
        self.assertFalse(self.config.has('cflags'))

    def test_has_single(self):
        """Indicates a config has a flag when it has one value."""
        self.config.add('cflags', '-frobinator')
        self.assertTrue(self.config.has('cflags'))

    def test_has_multiple(self):
        """Indicates a config has a flag when it has multiple values."""
        self.config.add('cflags', '-frobinator')
        self.config.add('cflags', '-fizzbuzzer')
        self.assertTrue(self.config.has('cflags'))

    def test_has_two_flags(self):
        """Indicates a config has a flag when it has multiple flags."""
        self.config.add('cflags', '-frobinator')
        self.config.add('cflags_c', '-foobarbaz')
        self.assertTrue(self.config.has('cflags'))

    def test_add_and_get(self):
        """Tests ability to add valid flags to a config."""
        for flag in GN_CONFIG_FLAGS:
            self.config.add(flag, f'{flag}_value1')
            self.config.add(flag, f'{flag}_value2', f'{flag}_value3')
        for flag in GN_CONFIG_FLAGS:
            self.compare(
                self.config.get(flag),
                f'{flag}_value1',
                f'{flag}_value2',
                f'{flag}_value3',
            )

    def test_add_and_get_invalid(self):
        """Tests ability to add only valid flags to a config."""
        with self.assertRaises(MalformedGnError):
            self.config.add('invalid', 'value')

    def test_take_missing(self):
        """Tests ability to return an empty list when taking a missing flag."""
        self.compare(self.config.take('cflags'))
        self.assertFalse(self.config.has('defines'))
        self.assertFalse(self.config.has('cflags'))

    def test_take(self):
        """Tests ability to remove and return values from a config."""
        self.config.add('defines', 'KEY1=VAL1', 'KEY2=VAL2')
        self.config.add('cflags', '-frobinator', '-fizzbuzzer')
        self.assertTrue(self.config.has('defines'))
        self.assertTrue(self.config.has('cflags'))

        self.compare(self.config.take('cflags'), '-frobinator', '-fizzbuzzer')
        self.assertTrue(self.config.has('defines'))
        self.assertFalse(self.config.has('cflags'))

    def test_deduplicate_no_label(self):
        """Tests raising an error from deduplicating a labelless config."""
        cfg1 = GnConfig()
        cfg1.add('defines', 'KEY1=VAL1')
        with self.assertRaises(ValueError):
            list(self.config.deduplicate(cfg1))

    def test_deduplicate_empty(self):
        """Tests deduplicating an empty config."""
        cfg2 = GnConfig()
        cfg2.label = ':cfg2'
        self.assertFalse(list(self.config.deduplicate(cfg2)))

    def test_deduplicate_not_subset(self):
        """Tests deduplicating a config whose values are not a subset."""
        self.config.add('defines', 'KEY1=VAL1', 'KEY2=VAL2')
        self.config.add('cflags', '-frobinator', '-fizzbuzzer', '-foobarbaz')

        cfg3 = GnConfig()
        cfg3.label = ':cfg3'
        cfg3.add('defines', 'KEY1=VAL1', 'KEY3=VAL3')
        self.assertFalse(list(self.config.deduplicate(cfg3)))

    def test_deduplicate(self):
        """Tests deduplicating multiple overlapping configs."""
        self.config.add('defines', 'KEY1=VAL1', 'KEY2=VAL2')
        self.config.add('cflags', '-frobinator', '-fizzbuzzer', '-foobarbaz')

        cfg4 = GnConfig()
        cfg4.label = ':cfg4'
        cfg4.add('defines', 'KEY1=VAL1')
        cfg4.add('cflags', '-frobinator')

        cfg5 = GnConfig()
        cfg5.label = ':cfg5'
        cfg5.add('defines', 'KEY1=VAL1')
        cfg5.add('cflags', '-foobarbaz')

        cfg6 = GnConfig()
        cfg6.label = ':skipped'
        cfg6.add('cflags', '-foobarbaz')

        cfgs = [
            str(cfg.label) for cfg in self.config.deduplicate(cfg4, cfg5, cfg6)
        ]
        self.assertEqual(cfgs, [':cfg4', ':cfg5'])
        self.compare(self.config.get('defines'), 'KEY2=VAL2')
        self.compare(self.config.get('cflags'), '-fizzbuzzer')

    def test_extract_public(self):
        """Tests ability to removes and return `public_config` values."""
        self.config.add('public_defines', 'KEY1=VAL1', 'KEY2=VAL2')
        self.config.add('defines', 'KEY3=VAL3', 'KEY4=VAL4')
        self.config.add('include_dirs', 'foo', 'bar', 'baz')
        self.config.add('cflags', '-frobinator', '-fizzbuzzer')

        config = self.config.extract_public()

        self.assertFalse(self.config.has('public_defines'))
        self.assertFalse(self.config.has('include_dirs'), 'KEY2=VAL2')
        self.compare(self.config.get('defines'), 'KEY3=VAL3', 'KEY4=VAL4')
        self.compare(self.config.get('cflags'), '-frobinator', '-fizzbuzzer')

        self.assertFalse(config.has('public_defines'))
        self.compare(config.get('defines'), 'KEY1=VAL1', 'KEY2=VAL2')
        self.compare(config.get('include_dirs'), 'foo', 'bar', 'baz')
        self.assertFalse(config.has('cflags'))

    def test_consolidate_configs(self):
        """Tests ability to merges configs into the smallest exact cover."""
        cfg1 = GnConfig()
        cfg1.add('cflags', 'one', 'a', 'b')
        cfg1.add('defines', 'k=1')
        cfg1.add('include_dirs', 'foo', 'bar')

        cfg2 = GnConfig()
        cfg2.add('cflags', 'one', 'a', 'b', 'c')
        cfg2.add('defines', 'k=1')
        cfg2.add('include_dirs', 'foo', 'baz')

        cfg3 = GnConfig()
        cfg3.add('cflags', 'one', 'two', 'a', 'b')
        cfg3.add('defines', 'k=1')
        cfg3.add('include_dirs', 'foo', 'bar')

        cfg4 = GnConfig()
        cfg4.add('cflags', 'one', 'b', 'c')
        cfg4.add('defines', 'k=0')
        cfg4.add('include_dirs', 'foo', 'baz')

        label = GnLabel('//foo/bar')
        common = list(consolidate_configs(label, cfg1, cfg2, cfg3, cfg4))
        self.assertEqual(len(common), 3)
        self.assertEqual(str(common[0].label), '//foo/bar:bar_public_config1')
        self.assertEqual(str(common[1].label), '//foo/bar:bar_config1')
        self.assertEqual(str(common[2].label), '//foo/bar:bar_config2')
        self.compare(common[0].get('include_dirs'), 'foo')
        self.compare(common[1].get('cflags'), 'one', 'b')
        self.compare(common[2].get('cflags'), 'a')
        self.compare(common[2].get('defines'), 'k=1')


if __name__ == '__main__':
    unittest.main()