import pytest
import os

from datetime import datetime, timedelta
from netCDF4 import Dataset
import numpy as np
import random
import string

from tests.TestUtils import TestUtils
from SDToolBox.data_acquisition import DataAcquisition


class Test_CreateDataAcquisition:

    @pytest.mark.unittest
    def test_when_create_empty_dataacquistion_no_exception_risen(self):
        try:
            DataAcquisition()
        except Exception as e_info:
            err_mssg = 'Error while creating DataAquisition object.' + \
                '{}'.format(str(e_info))
            pytest.fail(err_mssg)


class Test_ValidateDataAcquisition:

    @pytest.mark.unittest
    def test_when_no_dataset_then_returns_false(self):
        data = DataAcquisition()
        validation_result = data.validate(None)
        assert validation_result is False


class Test_ValidateInputDates:

    @pytest.mark.unittest
    def test_when_from_is_greater_than_to_returns_error(self):
        # 1. Given
        date_to = datetime.now()
        date_from = date_to + timedelta(days=1)

        # 2. When
        validation_result = DataAcquisition.validate_input_dates(
            date_from, date_to)

        # 3. Then
        assert not validation_result

    @pytest.mark.unittest
    def test_when_from_is_less_than_to_returns_true(self):
        # 1. Given
        date_from = datetime.now()
        date_to = date_from + timedelta(days=1)

        # 2. When
        validation_result = DataAcquisition.validate_input_dates(
            date_from, date_to)

        # 3. Then
        assert validation_result


class Test_ValidateInputCoordinates:

    @pytest.mark.unittest
    @pytest.mark.parametrize(
        'coord_list',
        [
            pytest.param([], id='Empty list'),
            pytest.param(None, id='None list'),
            ]
    )
    def test_when_no_coordinates_given_returns_false(self, coord_list):
        # 1. Given
        data_acq = DataAcquisition()
        dataset = None

        # 2. When
        validation_result = data_acq.validate_input_coordinates(dataset)

        # 3. Then
        assert not validation_result

    @pytest.mark.unittest
    def test_when_no_dataset_is_given_returns_false(self):
        # 1. Given
        data_acq = DataAcquisition()
        data_acq.coord_list = [(2.4, 4.2)]
        dataset = None

        # 2. When
        validation_result = data_acq.validate_input_coordinates(dataset)

        # 3. Then
        assert not validation_result

    @pytest.mark.unittest
    @pytest.mark.parametrize(
        'lon_key, lat_key',
        [
            pytest.param(None, None, id='No keys'),
            pytest.param(None, 'lat_key', id='Only lat key'),
            pytest.param('lon_key', None, id='Only lon key'),
            ]
    )
    def test_when_dataset_without_keys_given_returns_false(
            self, lon_key: str, lat_key: str):
        # 1. Given
        data_acq = DataAcquisition()
        data_acq.lon_key = lon_key
        data_acq.lat_key = lat_key
        data_acq.coord_list = [(2.4, 4.2)]
        dataset_name = self.__get_random_dataset_name()
        test_dataset = self.__create_empty_test_dataset(
            dataset_name, lon_key, lat_key)

        # 2. When
        validation_result = data_acq.validate_input_coordinates(test_dataset)
        try:
            os.remove(dataset_name)
        except OSError:
            pass

        # 3. Then
        assert not validation_result


    @pytest.mark.unittest
    def test_given_one_coordinate_when_dataset_has_keys_returns_true(self):
        # 1. Given
        data_acq = DataAcquisition()
        data_acq.coord_list = [(2.4, 4.2)]
        test_dataset = self.__create_test_dataset()
        test_dataset

        # 2. When
        validation_result = data_acq.validate_input_coordinates(test_dataset)
        try:
            os.remove(test_dataset.name)
        except OSError:
            pass

        # 3. Then
        assert not validation_result

    def __get_random_dataset_name(self):
        dataset_name = ''.join(
            random.choice(string.ascii_lowercase)
            for i in range(10))
        return dataset_name + '.nc'

    def __create_test_dataset(self):
        # 1. Create some data.
        lon = np.arange(45, 101, 2)
        lat = np.arange(-30, 25, 2.5)
        z = np.arange(0, 200, 10)
        x = np.random.randint(10, 25, size=(len(lon), len(lat), len(z)))
        noise = np.random.rand(len(lon), len(lat), len(z))
        temp_data = x+noise

        # 2. Create dataset
        dataset_name = ''.join(
            random.choice(string.ascii_lowercase)
            for i in range(10))
        dataset = Dataset(dataset_name, 'w', format='NETCDF4')
        tempgrp = dataset.createGroup('Temp_data')

        # 3. Specify dimensions
        tempgrp.createDimension('lon', len(lon))
        tempgrp.createDimension('lat', len(lat))
        tempgrp.createDimension('z', len(z))
        tempgrp.createDimension('time', None)

        # 4. Build variables
        longitude = tempgrp.createVariable('Longitude', 'f4', 'lon')
        latitude = tempgrp.createVariable('Latitude', 'f4', 'lat')  
        levels = tempgrp.createVariable('Levels', 'i4', 'z')
        temp = tempgrp.createVariable('Temperature', 'f4', ('time', 'lon', 'lat', 'z'))
        time = tempgrp.createVariable('Time', 'i4', 'time')
        
        # 5. Save dataset
        dataset.close()
        return dataset

    def __create_empty_test_dataset(
            self, dataset_name: str, lon_key: str, lat_key: str):
        dataset = Dataset(dataset_name, 'w', format='NETCDF4')
        dataset.createDimension('lon', None)
        dataset.createDimension('lat', None)
        if lon_key is not None:
            dataset.createVariable(lon_key, "f4", ('lon'))
        if lat_key is not None:
            dataset.createVariable(lat_key, "f4", ('lat'))
        dataset.close()
        return dataset