"""
Copyright 2020 The Magma Authors.

This source code is licensed under the BSD-style license found in the
LICENSE file in the root directory of this source tree.

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.
"""

# pylint: disable=protected-access
from unittest import TestCase

from data_models.data_model_parameters import ParameterName
from device_config.configuration_init import (
    _get_enb_config,
    _set_bandwidth,
    _set_earfcn_freq_band_mode,
    _set_management_server,
    _set_misc_static_params,
    _set_pci,
    _set_perf_mgmt,
    _set_plmnids_tac,
    _set_s1_connection,
    _set_tdd_subframe_config,
)
from device_config.enodeb_configuration import EnodebConfiguration
from devices.baicells import BaicellsTrDataModel
from exceptions import ConfigurationError
from tests.test_utils.config_builder import EnodebConfigBuilder


class EnodebConfigurationFactoryTest(TestCase):

    def setUp(self):
        self.data_model = BaicellsTrDataModel()
        self.cfg = EnodebConfiguration(BaicellsTrDataModel())
        self.device_cfg = EnodebConfiguration(BaicellsTrDataModel())

    def tearDown(self):
        self.data_model = None
        self.cfg = None
        self.device_cfg = None

    def test_set_pci(self):
        pci = 3
        _set_pci(self.cfg, pci)
        self.assertEqual(
            self.cfg.get_parameter(ParameterName.PCI), pci,
            'PCI value should be same as what was set',
        )
        with self.assertRaises(ConfigurationError):
            _set_pci(self.cfg, 505)

    def test_set_bandwidth(self):
        mhz = 15
        _set_bandwidth(self.cfg, self.data_model, mhz)
        self.assertEqual(
            self.cfg.get_parameter(ParameterName.DL_BANDWIDTH),
            mhz,
            'Should have set %s' % ParameterName.DL_BANDWIDTH,
        )
        self.assertEqual(
            self.cfg.get_parameter(ParameterName.UL_BANDWIDTH),
            mhz,
            'Should have set %s' % ParameterName.UL_BANDWIDTH,
        )

    def test_set_tdd_subframe_config(self):
        # Not TDD mode, should not try to set anything
        self.device_cfg.set_parameter(
            ParameterName.DUPLEX_MODE_CAPABILITY, 'Not TDDMode',
        )
        subframe = 0
        special_subframe = 0
        _set_tdd_subframe_config(
            self.device_cfg, self.cfg, subframe,
            special_subframe,
        )
        self.assertTrue(
            ParameterName.SUBFRAME_ASSIGNMENT not in
            self.cfg.get_parameter_names(),
        )

        # Invalid subframe assignment
        self.device_cfg.set_parameter(
            ParameterName.DUPLEX_MODE_CAPABILITY, 'TDDMode',
        )
        _set_tdd_subframe_config(
            self.device_cfg, self.cfg, subframe,
            special_subframe,
        )
        self.assertIn(
            ParameterName.SUBFRAME_ASSIGNMENT,
            self.cfg.get_parameter_names(),
            'Expected a subframe assignment',
        )

    def test_set_management_server(self):
        _set_management_server(self.cfg)
        self.assertEqual(
            self.cfg.get_parameter(ParameterName.PERIODIC_INFORM_ENABLE),
            True, 'Expected periodic inform enable to be true',
        )
        self.assertTrue(
            isinstance(
                self.cfg.get_parameter(ParameterName.PERIODIC_INFORM_INTERVAL),
                int,
            ),
            'Expected periodic inform interval to ani integer',
        )

    def test_set_s1_connection(self):
        invalid_mme_ip = 1234
        invalid_mme_port = '8080'
        mme_ip = '192.168.0.1'
        mme_port = 8080

        # MME IP should be a string
        with self.assertRaises(ConfigurationError):
            _set_s1_connection(self.cfg, invalid_mme_ip, mme_port)

        # MME Port should be an integer
        with self.assertRaises(ConfigurationError):
            _set_s1_connection(self.cfg, mme_ip, invalid_mme_port)

        # Check the ip and port are sort properly
        _set_s1_connection(self.cfg, mme_ip, mme_port)
        self.assertEqual(
            self.cfg.get_parameter(ParameterName.MME_IP), mme_ip,
            'Expected mme ip to be set',
        )
        self.assertEqual(
            self.cfg.get_parameter(ParameterName.MME_PORT), mme_port,
            'Expected mme port to be set',
        )

    def test_set_perf_mgmt(self):
        mgmt_ip = '192.168.0.1'
        mgmt_upload_interval = 300
        mgmt_port = 8080
        _set_perf_mgmt(self.cfg, mgmt_ip, mgmt_port)
        self.assertTrue(
            self.cfg.get_parameter(ParameterName.PERF_MGMT_ENABLE),
            'Expected perf mgmt to be enabled',
        )
        self.assertEqual(
            self.cfg.get_parameter(ParameterName.PERF_MGMT_UPLOAD_INTERVAL),
            mgmt_upload_interval, 'Expected upload interval to be set',
        )
        expected_url = 'http://192.168.0.1:8080/'
        self.assertEqual(
            self.cfg.get_parameter(ParameterName.PERF_MGMT_UPLOAD_URL),
            expected_url, 'Incorrect Url',
        )

    def test_set_misc_static_params(self):
        # IPSec enable as integer
        self.device_cfg.set_parameter(ParameterName.IP_SEC_ENABLE, 0)
        self.data_model.set_parameter_presence(ParameterName.GPS_ENABLE, True)
        _set_misc_static_params(self.device_cfg, self.cfg, self.data_model)
        self.assertTrue(
            isinstance(
                self.cfg.get_parameter(ParameterName.IP_SEC_ENABLE), int,
            ),
            'Should support an integer IP_SEC_ENABLE parameter',
        )

        # IPSec enable as boolean
        self.device_cfg.set_parameter(ParameterName.IP_SEC_ENABLE, 'False')
        _set_misc_static_params(self.device_cfg, self.cfg, self.data_model)
        self.assertTrue(
            isinstance(
                self.cfg.get_parameter(ParameterName.IP_SEC_ENABLE), bool,
            ),
            'Should support a boolean IP_SEC_ENABLE parameter',
        )
        self.assertEqual(
            self.cfg.get_parameter(ParameterName.LOCAL_GATEWAY_ENABLE), 0,
            'Should be disabled',
        )
        self.assertEqual(
            self.cfg.get_parameter(ParameterName.CELL_RESERVED), False,
            'Should be disabled',
        )
        self.assertEqual(
            self.cfg.get_parameter(ParameterName.MME_POOL_ENABLE), False,
            'Should be disabled',
        )

    def test_set_plmnids_tac(self):
        # We only handle a single PLMNID for now
        plmnids = '1, 2, 3, 4'
        tac = 1
        with self.assertRaises(ConfigurationError):
            _set_plmnids_tac(self.cfg, plmnids, tac)

        # Max PLMNID length is 6 characters
        plmnids = '1234567'
        with self.assertRaises(ConfigurationError):
            _set_plmnids_tac(self.cfg, plmnids, tac)

        # Check that only one PLMN element is enabled
        plmnids = '1'
        _set_plmnids_tac(self.cfg, plmnids, tac)
        self.assertTrue(
            self.cfg.get_parameter_for_object(
                ParameterName.PLMN_N_ENABLE % 1, ParameterName.PLMN_N % 1,
            ),
            'First PLMN should be enabled',
        )
        self.assertFalse(
            self.cfg.has_object(ParameterName.PLMN_N % 2),
            'Second PLMN should be disabled',
        )

    def test_set_earafcn_freq_band_mode(self):
        # Invalid earfcndl
        with self.assertRaises(ConfigurationError):
            invalid_earfcndl = -1
            _set_earfcn_freq_band_mode(
                self.device_cfg, self.cfg,
                self.data_model, invalid_earfcndl,
            )

        # Duplex_mode is TDD but capability is FDD
        with self.assertRaises(ConfigurationError):
            self.device_cfg.set_parameter(
                ParameterName.DUPLEX_MODE_CAPABILITY, 'FDDMode',
            )
            earfcndl = 38650  # Corresponds to TDD
            _set_earfcn_freq_band_mode(
                self.device_cfg, self.cfg,
                self.data_model, earfcndl,
            )

        # Duplex_mode is FDD but capability is TDD
        with self.assertRaises(ConfigurationError):
            self.device_cfg.set_parameter(
                ParameterName.DUPLEX_MODE_CAPABILITY, 'TDDMode',
            )
            earfcndl = 0  # Corresponds to FDD
            _set_earfcn_freq_band_mode(
                self.device_cfg, self.cfg,
                self.data_model, earfcndl,
            )

    def test_get_enb_config(self):
        mconfig = EnodebConfigBuilder.get_mconfig()
        enb_config = _get_enb_config(mconfig, self.device_cfg)
        self.assertTrue(
            enb_config.earfcndl == 39150,
            "Should give earfcndl from default eNB config",
        )

        mconfig = EnodebConfigBuilder.get_multi_enb_mconfig()
        self.device_cfg.set_parameter(
            ParameterName.SERIAL_NUMBER,
            '120200002618AGP0003',
        )
        enb_config = _get_enb_config(mconfig, self.device_cfg)
        self.assertTrue(
            enb_config.earfcndl == 39151,
            "Should give earfcndl from specific eNB config",
        )