#   This Python module is part of the PyRate software package.
#
#   Copyright 2020 Geoscience Australia
#
#   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
#
#       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.
"""
This Python module contains tests for the APS PyRate module.
"""
import os
import shutil
import pytest
import numpy as np
from os.path import join
from scipy.ndimage import gaussian_filter1d, gaussian_filter
from numpy.testing import assert_array_almost_equal

import pyrate.constants as C
from pyrate import conv2tif, prepifg, correct
from pyrate.configuration import Configuration, MultiplePaths
from pyrate.core import shared
from pyrate.core.aps import wrap_spatio_temporal_filter, _interpolate_nans_2d, _kernel
from pyrate.core.aps import gaussian_temporal_filter as tlpfilter, gaussian_spatial_filter as slpfilter
from pyrate.core.shared import Ifg
from pyrate.core.ifgconstants import DAYS_PER_YEAR
from tests import common
from tests.common import BASE_TEST, PY37GDAL304


@pytest.fixture(params=["linear", "nearest", "cubic"])
def slpnanfill_method(request):
    return request.param


@pytest.fixture(params=[0.1, 0.5, 1, 5])
def slpfcutoff_method(request):
    return request.param


@pytest.fixture(params=[0.001, 0.01])
def slpfcutoff(request):
    return request.param


def test_interpolate_nans_2d(slpnanfill_method):
    arr = np.random.rand(200, 100)
    arr[arr < 0.1] = np.nan  # insert some nans
    assert np.sum(np.isnan(arr)) != 0  # some nans present
    _interpolate_nans_2d(arr, method=slpnanfill_method)
    assert np.sum(np.isnan(arr)) == 0  # should not be any nans


class TestSpatialFilter:
    """
    Test the implementation of Gaussian spatial filter
    """

    def setup_method(self):
        ifg_path = join(str(BASE_TEST), 'cropB', '20180106-20180130_ifg.tif')
        ifg = Ifg(ifg_path)
        ifg.open()
        p = ifg.phase_data
        self.x_size = ifg.x_size
        self.y_size = ifg.y_size
        # convert zeros to NaNs
        p[p == 0] = np.nan
        self.phase = p

    def test_gaussian_filter(self, slpfcutoff_method):
        """
        Compare against scipy.ndimage.gaussian_filter,
        that operates in the spatial domain on data with equal resolution in x and y
        """
        e = gaussian_filter(self.phase, sigma=slpfcutoff_method)
        r = slpfilter(self.phase, cutoff=slpfcutoff_method,
                      x_size=self.x_size, y_size=self.y_size)
        # pull data from middle of images; away from potential edge effects
        exp = e[50:150, 50:150]
        res = r[50:150, 50:150]
        assert_array_almost_equal(res, exp, 0)


def test_gaussian_kernel():
    """
    Test the Gaussian smoothing kernel
    """
    x = np.arange(1, 10, 2)
    res = _kernel(x, 3)
    exp = np.array([0.94595947, 0.60653066, 0.24935221, 0.06572853, 0.011109])
    np.testing.assert_array_almost_equal(res, exp, decimal=6)

    res = _kernel(x, 4)
    exp = np.array([0.96923323, 0.7548396, 0.45783336, 0.21626517, 0.07955951])
    np.testing.assert_array_almost_equal(res, exp, decimal=6)

    res = _kernel(x, 0.001)
    exp = np.array([0, 0, 0, 0, 0])
    np.testing.assert_array_equal(res, exp)


class TestTemporalFilter:
    """
    Tests for the temporal filter with synthetic data for a single pixel
    """

    def setup_method(self):
        self.thr = 1  # no nans in these test cases, threshold = 1
        # instance of normally distributed noise
        n = np.array([-0.36427456, 0.69539061, 0.42181139, -2.56306134,
                      0.55844095, -0.65562626, 0.65607911, 1.19431637,
                      -1.43837395, -0.91656358])
        # synthetic incremental displacement
        d = np.array([1., 1., 0.7, 0.3, 0., 0.1, 0.2, 0.6, 1., 1.])
        # incremental displacement + noise
        self.tsincr = d * 2 + n
        # regular time series, every 12 days
        self.interval = 12 / DAYS_PER_YEAR  # 0.03285 years
        intv = np.ones(d.shape, dtype=np.float32) * self.interval
        self.span = np.cumsum(intv)

    def test_tlpfilter_repeatability(self):
        """
        TEST 1: check for repeatability against expected result from
        tlpfilter. Cutoff equal to sampling interval (sigma=1)
        """
        res = tlpfilter(self.tsincr, self.interval, self.span, self.thr)
        exp = np.array([1.9936507, 1.9208364, 1.0252733, -0.07402889,
                        -0.1842336, 0.24325351, 0.94737214, 1.3890865,
                        1.1903466, 1.0036403])
        np.testing.assert_array_almost_equal(res, exp, decimal=6)

    def test_tlpfilter_scipy_sig1(self):
        """
        TEST 2: compare tlpfilter to scipy.ndimage.gaussian_filter1d. Works for
        regularly sampled data. Cutoff equal to sampling interval (sigma=1)
        """
        res = tlpfilter(self.tsincr, self.interval, self.span, self.thr)
        exp = gaussian_filter1d(self.tsincr, sigma=1)
        np.testing.assert_array_almost_equal(res, exp, decimal=1)

    def test_tlpfilter_scipy_sig2(self):
        """
        TEST 3: compare tlpfilter to scipy.ndimage.gaussian_filter1d. Works for
        regularly sampled data. Cutoff equal to twice the sampling interval (sigma=2)
        """
        res = tlpfilter(self.tsincr, self.interval * 2, self.span, self.thr)
        exp = gaussian_filter1d(self.tsincr, sigma=2)
        np.testing.assert_array_almost_equal(res, exp, decimal=1)

    def test_tlpfilter_scipy_sig05(self):
        """
        TEST 4: compare tlpfilter to scipy.ndimage.gaussian_filter1d. Works for
        regularly sampled data. Cutoff equal to half the sampling interval (sigma=0.5)
        """
        res = tlpfilter(self.tsincr, self.interval * 0.5, self.span, self.thr)
        exp = gaussian_filter1d(self.tsincr, sigma=0.5)
        np.testing.assert_array_almost_equal(res, exp, decimal=2)


@pytest.mark.slow
@pytest.mark.skipif(not PY37GDAL304, reason="Only run in one CI env")
class TestAPSErrorCorrectionsOnDiscReused:

    @classmethod
    def setup_method(cls):
        cls.conf = common.TEST_CONF_GAMMA
        params = Configuration(cls.conf).__dict__
        conv2tif.main(params)
        params = Configuration(cls.conf).__dict__
        prepifg.main(params)
        cls.params = Configuration(cls.conf).__dict__
        correct._copy_mlooked(cls.params)
        correct._update_params_with_tiles(cls.params)
        correct._create_ifg_dict(cls.params)
        multi_paths = cls.params[C.INTERFEROGRAM_FILES]
        cls.ifg_paths = [p.tmp_sampled_path for p in multi_paths]
        cls.ifgs = [shared.Ifg(i) for i in cls.ifg_paths]
        for i in cls.ifgs:
            i.open()
        shared.save_numpy_phase(cls.ifg_paths, cls.params)
        correct.mst_calc_wrapper(cls.params)

    @classmethod
    def teardown_method(cls):
        shutil.rmtree(cls.params[C.OUT_DIR])

    def test_aps_error_files_on_disc(self, slpnanfill_method, slpfcutoff):
        self.params[C.SLPF_NANFILL_METHOD] = slpnanfill_method
        self.params[C.SLPF_CUTOFF] = slpfcutoff
        wrap_spatio_temporal_filter(self.params)

        # test_orb_errors_written
        aps_error_files = [MultiplePaths.aps_error_path(i, self.params) for i in self.ifg_paths]
        assert all(p.exists() for p in aps_error_files)
        last_mod_times = [os.stat(o).st_mtime for o in aps_error_files]
        phase_prev = [i.phase_data for i in self.ifgs]

        # run aps error removal again
        wrap_spatio_temporal_filter(self.params)
        aps_error_files2 = [MultiplePaths.aps_error_path(i, self.params) for i in self.ifg_paths]
        # if files are written again - times will change
        last_mod_times_2 = [os.stat(o).st_mtime for o in aps_error_files2]
        # test_aps_error_reused_if_params_unchanged
        assert all(a == b for a, b in zip(last_mod_times, last_mod_times_2))
        phase_now = [i.phase_data for i in self.ifgs]

        # run aps error correction once mroe
        wrap_spatio_temporal_filter(self.params)
        aps_error_files3 = [MultiplePaths.aps_error_path(i, self.params) for i in self.ifg_paths]
        last_mod_times_3 = [os.stat(o).st_mtime for o in aps_error_files3]
        assert all(a == b for a, b in zip(last_mod_times, last_mod_times_3))
        phase_again = [i.phase_data for i in self.ifgs]
        np.testing.assert_array_equal(phase_prev, phase_now)
        np.testing.assert_array_equal(phase_prev, phase_again)