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

from mock import patch
import unittest

import configuration_parsing as parser
import ocw.metrics as metrics

import yaml


class TestIsConfigValid(unittest.TestCase):
    @classmethod
    def setUpClass(self):
        not_minimal_config = """
            datasets:
        """
        self.not_minimal = yaml.load(not_minimal_config)

        not_well_formed_config = """
        datasets:
            reference:
                data_source: local
                file_count: 1
                path: /a/fake/path/file.py
                variable: pr

            targets:
                - data_source: local
                  file_count: 5
                  file_glob_pattern: something for globbing files here
                  variable: pr
                  optional_args:
                      name: Target1

                - data_source: esgf
                  dataset_id: fake dataset id
                  variable: pr
                  esgf_username: my esgf username
                  esgf_password: my esgf password

        metrics:
            - Bias
            - TemporalStdDev
        """
        self.not_well_formed = yaml.load(not_well_formed_config)

    @patch('configuration_parsing.logger')
    def test_not_minimal_config(self, mock_logger):
        ret = parser.is_config_valid(self.not_minimal)
        self.assertFalse(ret)

        mock_logger.error.assert_called_with(
            'Insufficient configuration file data for an evaluation'
        )

    @patch('configuration_parsing.logger')
    def test_not_valid_config(self, mock_logger):
        ret = parser.is_config_valid(self.not_well_formed)
        self.assertFalse(ret)

        mock_logger.error.assert_called_with(
            'Configuration data is not well formed'
        )


class TestValidMinimalConfig(unittest.TestCase):
    @classmethod
    def setUpClass(self):
        no_datasets_config = """
        metrics:
            - Bias
        """
        self.no_datasets = yaml.load(no_datasets_config)

        no_metrics_config = """
        datasets:
            reference:
                data_source: dap
                url: afakeurl.com
                variable: pr
        """
        self.no_metrics = yaml.load(no_metrics_config)

        unary_with_reference_config = """
        datasets:
            reference:
                data_source: dap
                url: afakeurl.com
                variable: pr

        metrics:
            - TemporalStdDev
        """
        self.unary_with_reference = yaml.load(unary_with_reference_config)

        unary_with_target_config = """
        datasets:
            targets:
                - data_source: dap
                  url: afakeurl.com
                  variable: pr

        metrics:
            - TemporalStdDev
        """
        self.unary_with_target = yaml.load(unary_with_target_config)

        unary_no_reference_or_target = """
        datasets:
            not_ref_or_target:
                - data_source: dap
                  url: afakeurl.com
                  variable: pr

        metrics:
            - TemporalStdDev
        """
        self.unary_no_ref_or_target = yaml.load(unary_no_reference_or_target)

        binary_valid_config = """
        datasets:
            reference:
                data_source: dap
                url: afakeurl.com
                variable: pr

            targets:
                - data_source: dap
                  url: afakeurl.com
                  variable: pr
        metrics:
            - Bias
        """
        self.binary_valid = yaml.load(binary_valid_config)

        binary_no_reference_config = """
        datasets:
            targets:
                - data_source: dap
                  url: afakeurl.com
                  variable: pr
        metrics:
            - Bias
        """
        self.binary_no_reference = yaml.load(binary_no_reference_config)

        binary_no_target_config = """
        datasets:
            reference:
                data_source: dap
                url: afakeurl.com
                variable: pr

        metrics:
            - Bias
        """
        self.binary_no_target = yaml.load(binary_no_target_config)

    @patch('configuration_parsing.logger')
    def test_no_datasets(self, mock_logger):
        ret = parser._valid_minimal_config(self.no_datasets)
        self.assertFalse(ret)

        mock_logger.error.assert_called_with(
            'No datasets specified in configuration data.'
        )

    @patch('configuration_parsing.logger')
    def test_no_metrics(self, mock_logger):
        ret = parser._valid_minimal_config(self.no_metrics)
        self.assertFalse(ret)

        mock_logger.error.assert_called_with(
            'No metrics specified in configuration data.'
        )

    def test_unary_with_reference(self):
        ret = parser._valid_minimal_config(self.unary_with_reference)
        self.assertTrue(ret)

    def test_unary_with_target(self):
        ret = parser._valid_minimal_config(self.unary_with_target)
        self.assertTrue(ret)

    @patch('configuration_parsing.logger')
    def test_unary_no_datasets(self, mock_logger):
        ret = parser._valid_minimal_config(self.unary_no_ref_or_target)
        self.assertFalse(ret)

        mock_logger.error.assert_called_with(
            'Unary metric in configuration data requires either a reference '
            'or target dataset to be present for evaluation. Please ensure '
            'that your config is well formed.'
        )

    def test_valid_binary(self):
        ret = parser._valid_minimal_config(self.binary_valid)
        self.assertTrue(ret)

    @patch('configuration_parsing.logger')
    def test_binary_no_reference(self, mock_logger):
        ret = parser._valid_minimal_config(self.binary_no_reference)
        self.assertFalse(ret)

        mock_logger.error.assert_called_with(
            'Binary metric in configuration requires both a reference '
            'and target dataset to be present for evaluation. Please ensure '
            'that your config is well formed.'
        )
        
    @patch('configuration_parsing.logger')
    def test_binary_no_target(self, mock_logger):
        ret = parser._valid_minimal_config(self.binary_no_target)
        self.assertFalse(ret)

        mock_logger.error.assert_called_with(
            'Binary metric in configuration requires both a reference '
            'and target dataset to be present for evaluation. Please ensure '
            'that your config is well formed.'
        )


class TestConfigIsWellFormed(unittest.TestCase):
    @classmethod
    def setUpClass(self):
        malformed_reference_config = """
            datasets:
                reference:
                    data_source: notavalidlocation

            metrics:
                - Bias
        """
        self.malformed_reference_conf = yaml.load(malformed_reference_config)

        malformed_target_list_config = """
            datasets:
                targets:
                    notalist: 
                        a_key: a_value

                    alsonotalist:
                        a_key: a_value

            metrics:
                - Bias
        """
        self.malformed_target_list = yaml.load(malformed_target_list_config)

        missing_metric_name_config = """
            datasets:
                reference:
                    data_source: dap
                    url: afakeurl.com
                    variable: pr

            metrics:
                - NotABuiltInMetric
        """
        self.missing_metric_name = yaml.load(missing_metric_name_config)

        bad_plot_config = """
            datasets:
                reference:
                    data_source: dap
                    url: afakeurl.com
                    variable: pr

            metrics:
                - Bias

            plots:
                - type: NotARealPlotName
        """
        bad_plot = yaml.load(bad_plot_config)

        bad_subregion_config_type = """
            datasets:
                reference:
                    data_source: dap
                    url: afakeurl.com
                    variable: pr

            metrics:
                - Bias

            subregions:
                - this is a string instead of a list
        """
        self.bad_subregion_type = yaml.load(bad_subregion_config_type)

        bad_subregion_config_length = """
            datasets:
                reference:
                    data_source: dap
                    url: afakeurl.com
                    variable: pr

            metrics:
                - Bias

            subregions:
                - [1, 2, 3, 4, 5]
        """
        self.bad_subregion_length = yaml.load(bad_subregion_config_length)

    def test_malformed_reference_config(self):
        ret = parser._config_is_well_formed(self.malformed_reference_conf)
        self.assertFalse(ret)

    @patch('configuration_parsing.logger')
    def test_malformed_target_dataset_list(self, mock_logger):
        ret = parser._config_is_well_formed(self.malformed_target_list)
        self.assertFalse(ret)

        mock_logger.error.assert_called_with(
            "Expected to find list of target datasets but instead found "
            "object of type <type 'dict'>"
        )

    def test_not_builtin_metric(self):
        ret = parser._config_is_well_formed(self.missing_metric_name)
        self.assertFalse(ret)

    @patch('configuration_parsing.logger')
    def test_warns_regarding_not_builtin_metric(self, mock_logger):
        ret = parser._config_is_well_formed(self.missing_metric_name)
        mock_logger.warn.assert_called_with(
            'Unable to locate metric name NotABuiltInMetric in built-in '
            'metrics. If this is not a user defined metric then please check '
            'for potential misspellings.'
        )

    def test_bad_plot_config(self):
        ret = parser._config_is_well_formed(self.missing_metric_name)
        self.assertFalse(ret)
    
    def test_bad_subregion_type(self):
        ret = parser._config_is_well_formed(self.bad_subregion_type)
        self.assertFalse(ret)

    def test_bad_subregion_length(self):
        ret = parser._config_is_well_formed(self.bad_subregion_length)
        self.assertFalse(ret)


class MetricFetchTest(unittest.TestCase):
    @classmethod
    def setUpClass(self):
        binary_config = """
            metrics:
                - Bias
                - StdDevRatio
        """
        unary_config = """
            metrics:
                - TemporalStdDev
        """
        self.unary_conf = yaml.load(unary_config)
        self.binary_conf = yaml.load(binary_config)

    def test_contains_binary_metric(self):
        ret = parser._contains_binary_metrics(self.binary_conf['metrics'])
        self.assertTrue(ret)

    def test_does_not_contain_binary_metric(self):
        ret = parser._contains_binary_metrics(self.unary_conf['metrics'])
        self.assertFalse(ret)

    def test_contains_unary_metric(self):
        ret = parser._contains_unary_metrics(self.unary_conf['metrics'])
        self.assertTrue(ret)
        
    def test_does_not_contain_unary_metric(self):
        ret = parser._contains_unary_metrics(self.binary_conf['metrics'])
        self.assertFalse(ret)


class InvalidDatasetConfig(unittest.TestCase):
    @classmethod
    def setUpClass(self):
        example_config_yaml = """
            - file_count: 1
              path: /a/fake/path
              variable: pr

            - data_source: invalid_location_identifier
        """
        conf = yaml.load(example_config_yaml)
        self.missing_data_source = conf[0]
        self.invalid_data_source = conf[1]

    @patch('configuration_parsing.logger')
    def test_missing_data_source_config(self, mock_logger):
        parser._valid_dataset_config_data(self.missing_data_source)
        mock_logger.error.assert_called_with(
            'Dataset does not contain a data_source attribute.'
        )

    @patch('configuration_parsing.logger')
    def test_invalid_data_source(self, mock_logger):
        parser._valid_dataset_config_data(self.invalid_data_source)
        mock_logger.error.assert_called_with(
            'Dataset does not contain a valid data_source location.'
        )


class TestLocalDatasetConfig(unittest.TestCase):
    @classmethod
    def setUpClass(self):
        self.required_local_keys = set(['data_source', 'file_count', 'path', 'variable'])
        example_config_yaml = """
            - data_source: local
              file_count: 1
              path: /a/fake/path
              variable: pr
              optional_args:
                  name: Target1

            - data_source: local

            - data_source: local
              file_count: 5
              file_glob_pattern: something for globbing files here
              variable: pr
              path: /a/fake/path
              optional_args:
                  name: Target1

            - data_source: local
              file_count: 5
              variable: pr
              path: /a/fake/path
        """

        conf = yaml.load(example_config_yaml)
        self.valid_local_single = conf[0]
        self.invalid_local_single = conf[1]
        self.valid_local_multi = conf[2]
        self.invalid_local_multi = conf[1]
        self.invalid_local_multi_file_glob = conf[3]

    def test_valid_local_config_single_file(self):
        ret = parser._valid_dataset_config_data(self.valid_local_single)
        self.assertTrue(ret)

    def test_valid_local_config_multi_file(self):
        ret = parser._valid_dataset_config_data(self.valid_local_multi)
        self.assertTrue(ret)

    @patch('configuration_parsing.logger')
    def test_invalid_local_config(self, mock_logger):
        parser._valid_dataset_config_data(self.invalid_local_single)

        present_keys = set(self.invalid_local_single.keys())
        missing_keys = self.required_local_keys - present_keys
        missing = sorted(list(missing_keys))

        error = (
            'Dataset does not contain required keys. '
            'The following keys are missing: {}'.format(', '.join(missing))
        )
        mock_logger.error.assert_called_with(error)

    @patch('configuration_parsing.logger')
    def test_invalid_local_config_multi_file(self, mock_logger):
        # mutlifile config is handled slightly differently. We should see the
        # same missing keys in this situation as we would on the single file
        # local config. We will test for a missing file_glob_pattern in a
        # different test.
        parser._valid_dataset_config_data(self.invalid_local_multi)

        present_keys = set(self.invalid_local_multi.keys())
        missing_keys = self.required_local_keys - present_keys
        missing = sorted(list(missing_keys))

        error = (
            'Dataset does not contain required keys. '
            'The following keys are missing: {}'.format(', '.join(missing))
        )
        mock_logger.error.assert_called_with(error)

    @patch('configuration_parsing.logger')
    def test_invalid_local_config_multi_file_missing_file_glob(self, mock_logger):
        # We can't check for the file_glob_pattern pattern until after we have
        # verified that the single local file config has been met.
        parser._valid_dataset_config_data(self.invalid_local_multi_file_glob)

        mock_logger.error.assert_called_with(
            'Multi-file local dataset is missing key: file_glob_pattern'
        )


class TestRCMEDDatasetConfig(unittest.TestCase):
    @classmethod
    def setUpClass(self):
        self.required_rcmed_keys = set([
            'dataset_id',
            'parameter_id',
            'min_lat',
            'max_lat',
            'min_lon',
            'max_lon',
            'start_time',
            'end_time'
        ])
        example_config_yaml = """
            - data_source: rcmed
              dataset_id: 4
              parameter_id: 4
              min_lat: -40
              max_lat: 40
              min_lon: -50
              max_lon: 50
              start_time: YYYY-MM-DDThh:mm:ss
              end_time: YYYY-MM-DDThh:mm:ss

            - data_source: rcmed
        """
        conf = yaml.load(example_config_yaml)
        self.valid_rcmed = conf[0]
        self.invalid_rcmed = conf[1]

    def test_valid_rcmed_config(self):
        ret = parser._valid_dataset_config_data(self.valid_rcmed)
        self.assertTrue(ret)

    @patch('configuration_parsing.logger')
    def test_invalid_rcmed_config(self, mock_logger):
        parser._valid_dataset_config_data(self.invalid_rcmed)

        present_keys = set(self.invalid_rcmed.keys())
        missing_keys = self.required_rcmed_keys - present_keys
        missing = sorted(list(missing_keys))

        error = (
            'Dataset does not contain required keys. '
            'The following keys are missing: {}'.format(', '.join(missing))
        )
        mock_logger.error.assert_called_with(error)


class TestESGFDatasetConfig(unittest.TestCase):
    @classmethod
    def setUpClass(self):
        self.required_esgf_keys = set([
            'data_source',
            'dataset_id',
            'variable',
            'esgf_username',
            'esgf_password'
        ])
        example_config_yaml = """
           - data_source: esgf
             dataset_id: fake dataset id
             variable: pr
             esgf_username: my esgf username
             esgf_password: my esgf password

           - data_source: esgf
        """
        conf = yaml.load(example_config_yaml)
        self.valid_esgf = conf[0]
        self.invalid_esgf = conf[1]

    def test_valid_esgf_conf(self):
        ret = parser._valid_dataset_config_data(self.valid_esgf)
        self.assertTrue(ret)

    @patch('configuration_parsing.logger')
    def test_invalid_esgf_conf(self, mock_logger):
        parser._valid_dataset_config_data(self.invalid_esgf)

        present_keys = set(self.invalid_esgf.keys())
        missing_keys = self.required_esgf_keys - present_keys
        missing = sorted(list(missing_keys))

        error = (
            'Dataset does not contain required keys. '
            'The following keys are missing: {}'.format(', '.join(missing))
        )
        mock_logger.error.assert_called_with(error)


class TestDAPDatasetConfig(unittest.TestCase):
    @classmethod
    def setUpClass(self):
        self.required_dap_keys = set(['url', 'variable'])
        example_config_yaml = """
           - data_source: dap
             url: afakeurl.com
             variable: pr

           - data_source: dap
        """
        conf = yaml.load(example_config_yaml)
        self.valid_dap = conf[0]
        self.invalid_dap = conf[1]

    def test_valid_dap_config(self):
        ret = parser._valid_dataset_config_data(self.valid_dap)
        self.assertTrue(ret)

    @patch('configuration_parsing.logger')
    def test_invalid_dap_config(self, mock_logger):
        parser._valid_dataset_config_data(self.invalid_dap)

        present_keys = set(self.invalid_dap.keys())
        missing_keys = self.required_dap_keys - present_keys
        missing = sorted(list(missing_keys))

        error = (
            'Dataset does not contain required keys. '
            'The following keys are missing: {}'.format(', '.join(missing))
        )
        mock_logger.error.assert_called_with(error)


class ContourMapConfig(unittest.TestCase):
    @classmethod
    def setUpClass(self):
        valid_contour_config = """
            type: contour
            results_indices:
                - !!python/tuple [0, 0]
            lats:
                range_min: -20
                range_max: 20
                range_step: 1
            lons:
                range_min: -20
                range_max: 20
                range_step: 1
            output_name: wrf_bias_compared_to_knmi
        """
        self.valid_contour = yaml.load(valid_contour_config)

        missing_keys_contour_config = """
            type: contour
        """
        self.missing_keys_contour = yaml.load(missing_keys_contour_config)

        self.required_contour_keys = set([
            'results_indices',
            'lats',
            'lons',
            'output_name'
        ])

    def test_valid_contour(self):
        ret = parser._valid_plot_config_data(self.valid_contour)
        self.assertTrue(ret)

    @patch('configuration_parsing.logger')
    def test_missing_keys_contour(self, mock_logger):
        ret = parser._valid_plot_config_data(self.missing_keys_contour)

        present_keys = set(self.missing_keys_contour.keys())
        missing_keys = self.required_contour_keys - present_keys
        missing = sorted(list(missing_keys))

        err = (
            'Plot config does not contain required keys. '
            'The following keys are missing: {}'
        ).format(', '.join(missing))
        mock_logger.error.assert_called_with(err)


class TestSubregionPlotConfig(unittest.TestCase):
    @classmethod
    def setUpClass(self):
        valid_subregion_config = """
            type: subregion
            lats:
                range_min: -20
                range_max: 20
                range_step: 1
            lons:
                range_min: -20
                range_max: 20
                range_step: 1
            output_name: fake_plot_name
        """
        self.valid_subregion = yaml.load(valid_subregion_config)

        missing_keys_subregion_config = """
            type: subregion
        """
        self.missing_keys_subregion = yaml.load(missing_keys_subregion_config)

        self.required_subregion_keys = set([
            'lats',
            'lons',
            'output_name'
        ])

    def test_valid_subregion(self):
        ret = parser._valid_plot_config_data(self.valid_subregion)
        self.assertTrue(ret)

    @patch('configuration_parsing.logger')
    def test_missing_keys_subregion(self, mock_logger):
        ret = parser._valid_plot_config_data(self.missing_keys_subregion)

        present_keys = set(self.missing_keys_subregion.keys())
        missing_keys = self.required_subregion_keys - present_keys
        missing = sorted(list(missing_keys))

        err = (
            'Plot config does not contain required keys. '
            'The following keys are missing: {}'
        ).format(', '.join(missing))
        mock_logger.error.assert_called_with(err)


class TestInvalidPlotConfig(unittest.TestCase):
    @classmethod
    def setUpClass(self):
        bad_plot_type_config = """
            type: NotAPlotType
        """
        self.bad_plot_type = yaml.load(bad_plot_type_config)

        missing_plot_type_config = """
            results_indices:
                - !!python/tuple [0, 0]
            lats:
                range_min: -20
                range_max: 20
                range_step: 1
            lons:
                range_min: -20
                range_max: 20
                range_step: 1
            output_name: wrf_bias_compared_to_knmi
        """
        self.missing_plot_type = yaml.load(missing_plot_type_config)

        missing_subregions_for_plot_type = """
            datasets:
                - blah

            metrics:
                - blah
            
            plots:
                - type: subregion
                  results_indices:
                      - !!python/tuple [0, 0]
                  lats:
                      range_min: -20
                      range_max: 20
                      range_step: 1
                  lons:
                      range_min: -20
                      range_max: 20
                      range_step: 1
                  output_name: wrf_bias_compared_to_knmi
        """
        self.missing_subregions = yaml.load(missing_subregions_for_plot_type)

    @patch('configuration_parsing.logger')
    def test_invalid_plot_type(self, mock_logger):
        ret = parser._valid_plot_config_data(self.bad_plot_type)
        self.assertFalse(ret)

        mock_logger.error.assert_called_with(
            'Invalid plot type specified.'
        )

    @patch('configuration_parsing.logger')
    def test_missing_plot_type(self, mock_logger):
        ret = parser._valid_plot_config_data(self.missing_plot_type)
        self.assertFalse(ret)

        mock_logger.error.assert_called_with(
            'Plot config does not include a type attribute.'
        )
        
    @patch('configuration_parsing.logger')
    def test_missing_subregion(self, mock_logger):
        ret = parser._config_is_well_formed(self.missing_subregions)
        self.assertFalse(ret)

        mock_logger.error.assert_called_with(
            'Plot config that requires subregion information is present '
            'in a config file without adequate subregion information '
            'provided. Please ensure that you have properly supplied 1 or '
            'more subregion config values.'
        )