from pynwb.testing import TestCase


class TestRetinotopy(TestCase):
    def test_retinotopy_deprecated(self):
        with self.assertRaises(ImportError):
            import pynwb.retinotopy  # noqa: F401

# import numpy as np

# from pynwb.retinotopy import ImagingRetinotopy, AxisMap, RetinotopyImage, FocalDepthImage, RetinotopyMap
# from pynwb.testing import TestCase


# class ImageRetinotopyConstructor(TestCase):

#     def setUp(self):
#         data = np.ones((2, 2))
#         field_of_view = [1, 2]
#         dimension = [1, 2]
#         self.sign_map = RetinotopyMap('sign_map', data, field_of_view, dimension)
#         self.axis_1_phase_map = AxisMap('axis_1_phase_map', data, field_of_view, 'unit', dimension)
#         self.axis_1_power_map = AxisMap('axis_1_power_map', data, field_of_view, 'unit', dimension)
#         self.axis_2_phase_map = AxisMap('axis_2_phase_map', data, field_of_view, 'unit', dimension)
#         self.axis_2_power_map = AxisMap('axis_2_power_map', data, field_of_view, 'unit', dimension)
#         self.axis_descriptions = ['altitude', 'azimuth']

#         data = [[1, 1], [1, 1]]
#         bits_per_pixel = 8
#         dimension = [3, 4]
#         format = 'raw'
#         field_of_view = [1, 2]
#         focal_depth = 1.0
#         self.focal_depth_image = FocalDepthImage('focal_depth_image', data, bits_per_pixel, dimension, format,
#                                                  field_of_view, focal_depth)
#         self.vasculature_image = RetinotopyImage('vasculature_image', np.uint16(data), bits_per_pixel, dimension,
#                                                  format, field_of_view)

#     def test_init(self):
#         """Test that ImagingRetinotopy constructor sets properties correctly."""
#         msg = ('The ImagingRetinotopy class currently cannot be written to or read from a file. This is a known bug '
#                'and will be fixed in a future release of PyNWB.')
#         with self.assertWarnsWith(UserWarning, msg):
#             ir = ImagingRetinotopy(self.sign_map, self.axis_1_phase_map, self.axis_1_power_map, self.axis_2_phase_map,
#                                    self.axis_2_power_map, self.axis_descriptions, self.focal_depth_image,
#                                    self.vasculature_image)
#         self.assertEqual(ir.sign_map, self.sign_map)
#         self.assertEqual(ir.axis_1_phase_map, self.axis_1_phase_map)
#         self.assertEqual(ir.axis_1_power_map, self.axis_1_power_map)
#         self.assertEqual(ir.axis_2_phase_map, self.axis_2_phase_map)
#         self.assertEqual(ir.axis_2_power_map, self.axis_2_power_map)
#         self.assertEqual(ir.axis_descriptions, self.axis_descriptions)
#         self.assertEqual(ir.focal_depth_image, self.focal_depth_image)
#         self.assertEqual(ir.vasculature_image, self.vasculature_image)

#     def test_init_axis_descriptions_wrong_shape(self):
#         """Test that creating a ImagingRetinotopy with a axis descriptions argument that is not 2 elements raises an
#         error.
#         """
#         self.axis_descriptions = ['altitude', 'azimuth', 'extra']

#         msg = "ImagingRetinotopy.__init__: incorrect shape for 'axis_descriptions' (got '(3,)', expected '(2,)')"
#         with self.assertRaisesWith(ValueError, msg):
#             ImagingRetinotopy(self.sign_map, self.axis_1_phase_map, self.axis_1_power_map, self.axis_2_phase_map,
#                               self.axis_2_power_map, self.axis_descriptions, self.focal_depth_image,
#                               self.vasculature_image)


# class RetinotopyImageConstructor(TestCase):

#     def test_init(self):
#         """Test that RetinotopyImage constructor sets properties correctly."""
#         data = [[1, 1], [1, 1]]
#         bits_per_pixel = 8
#         dimension = [3, 4]
#         format = 'raw'
#         field_of_view = [1, 2]
#         image = RetinotopyImage('vasculature_image', data, bits_per_pixel, dimension, format, field_of_view)

#         self.assertEqual(image.name, 'vasculature_image')
#         self.assertEqual(image.data, data)
#         self.assertEqual(image.bits_per_pixel, bits_per_pixel)
#         self.assertEqual(image.dimension, dimension)
#         self.assertEqual(image.format, format)
#         self.assertEqual(image.field_of_view, field_of_view)

#     def test_init_dimension_wrong_shape(self):
#         """Test that creating a RetinotopyImage with a dimension argument that is not 2 elements raises an error."""
#         data = [[1, 1], [1, 1]]
#         bits_per_pixel = 8
#         dimension = [3, 4, 5]
#         format = 'raw'
#         field_of_view = [1, 2]

#         msg = "RetinotopyImage.__init__: incorrect shape for 'dimension' (got '(3,)', expected '(2,)')"
#         with self.assertRaisesWith(ValueError, msg):
#             RetinotopyImage('vasculature_image', data, bits_per_pixel, dimension, format, field_of_view)

#     def test_init_fov_wrong_shape(self):
#         """Test that creating a RetinotopyImage with a field of view that is not 2 elements raises an error."""
#         data = [[1, 1], [1, 1]]
#         bits_per_pixel = 8
#         dimension = [3, 4]
#         format = 'raw'
#         field_of_view = [1, 2, 3]

#         msg = "RetinotopyImage.__init__: incorrect shape for 'field_of_view' (got '(3,)', expected '(2,)')"
#         with self.assertRaisesWith(ValueError, msg):
#             RetinotopyImage('vasculature_image', data, bits_per_pixel, dimension, format, field_of_view)


# class RetinotopyMapConstructor(TestCase):

#     def test_init(self):
#         """Test that RetinotopyMap constructor sets properties correctly."""
#         data = np.ones((2, 2))
#         field_of_view = [1, 2]
#         dimension = [1, 2]
#         map = RetinotopyMap('sign_map', data, field_of_view, dimension)

#         self.assertEqual(map.name, 'sign_map')
#         np.testing.assert_array_equal(map.data, data)
#         self.assertEqual(map.field_of_view, field_of_view)
#         self.assertEqual(map.dimension, dimension)


# class AxisMapConstructor(TestCase):

#     def test_init(self):
#         """Test that AxisMap constructor sets properties correctly."""
#         data = np.ones((2, 2))
#         field_of_view = [1, 2]
#         dimension = [1, 2]
#         map = AxisMap('axis_1_phase', data, field_of_view, 'unit', dimension)

#         self.assertEqual(map.name, 'axis_1_phase')
#         np.testing.assert_array_equal(map.data, data)
#         self.assertEqual(map.field_of_view, field_of_view)
#         self.assertEqual(map.dimension, dimension)
#         self.assertEqual(map.unit, 'unit')

#     def test_init_dimension_wrong_shape(self):
#         """Test that creating an AxisMap with a dimension argument that is not 2 elements raises an error."""
#         data = np.ones((2, 2))
#         field_of_view = [1, 2]
#         dimension = [1, 2, 3]

#         msg = "AxisMap.__init__: incorrect shape for 'dimension' (got '(3,)', expected '(2,)')"
#         with self.assertRaisesWith(ValueError, msg):
#             AxisMap('axis_1_phase', data, field_of_view, 'unit', dimension)

#     def test_init_fov_wrong_shape(self):
#         """Test that creating an AxisMap with a dimension argument that is not 2 elements raises an error."""
#         data = np.ones((2, 2))
#         field_of_view = [1, 2, 3]
#         dimension = [1, 2]

#         msg = "AxisMap.__init__: incorrect shape for 'field_of_view' (got '(3,)', expected '(2,)')"
#         with self.assertRaisesWith(ValueError, msg):
#             AxisMap('axis_1_phase', data, field_of_view, 'unit', dimension)


# class FocalDepthImageConstructor(TestCase):

#     def test_init(self):
#         """Test that FocalDepthImage constructor sets properties correctly."""
#         data = [[1, 1], [1, 1]]
#         bits_per_pixel = 8
#         dimension = [3, 4]
#         format = 'raw'
#         field_of_view = [1, 2]
#         focal_depth = 1.0
#         image = FocalDepthImage('focal_depth_image', data, bits_per_pixel, dimension, format, field_of_view,
#                                 focal_depth)

#         self.assertEqual(image.name, 'focal_depth_image')
#         self.assertEqual(image.data, data)
#         self.assertEqual(image.bits_per_pixel, bits_per_pixel)
#         self.assertEqual(image.dimension, dimension)
#         self.assertEqual(image.format, format)
#         self.assertEqual(image.field_of_view, field_of_view)
#         self.assertEqual(image.focal_depth, focal_depth)
