# Copyright (c) 2021-2025  The University of Texas Southwestern Medical Center.
# All rights reserved.

# Redistribution and use in source and binary forms, with or without
# modification, are permitted for academic and research use only
# (subject to the limitations in the disclaimer below)
# provided that the following conditions are met:

#      * Redistributions of source code must retain the above copyright notice,
#      this list of conditions and the following disclaimer.

#      * Redistributions in binary form must reproduce the above copyright
#      notice, this list of conditions and the following disclaimer in the
#      documentation and/or other materials provided with the distribution.

#      * Neither the name of the copyright holders nor the names of its
#      contributors may be used to endorse or promote products derived from this
#      software without specific prior written permission.

# NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY
# THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
# CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
# BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
# IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#

# Standard Imports

# Third Party Imports
import pytest
import random

# Local Imports
from navigate.controller.sub_controllers.camera_settings import (
    CameraSettingController,
)


class TestCameraSettingController:
    @pytest.fixture(autouse=True)
    def setup_class(self, dummy_controller):
        c = dummy_controller
        v = dummy_controller.view
        self.camera_settings = CameraSettingController(
            v.settings.camera_settings_tab, c
        )

    def test_init(self):

        assert isinstance(self.camera_settings, CameraSettingController)

        # Setup, going to check what the default values widgets are set too
        microscope_name = self.camera_settings.parent_controller.configuration[
            "experiment"
        ]["MicroscopeState"]["microscope_name"]
        camera_config_dict = self.camera_settings.parent_controller.configuration[
            "configuration"
        ]["microscopes"][microscope_name]["camera"]

        # Default Values
        assert (
            self.camera_settings.default_pixel_size
            == camera_config_dict["pixel_size_in_microns"]
        )
        assert self.camera_settings.default_height == camera_config_dict["y_pixels"]
        assert self.camera_settings.default_width == camera_config_dict["x_pixels"]

        # Camera Mode
        assert list(self.camera_settings.mode_widgets["Sensor"].widget["values"]) == [
            "Normal",
            "Light-Sheet",
        ]
        assert (
            str(self.camera_settings.mode_widgets["Sensor"].widget["state"])
            == "readonly"
        )

        # Readout Mode
        assert list(self.camera_settings.mode_widgets["Readout"].widget["values"]) == [
            "Top-to-Bottom",
            "Bottom-to-Top",
            "Bidirectional",
            "Rev. Bidirectional",
        ]
        assert (
            str(self.camera_settings.mode_widgets["Readout"].widget["state"])
            == "disabled"
        )

        # Pixels
        assert (
            str(self.camera_settings.mode_widgets["Pixels"].widget["state"])
            == "disabled"
        )
        assert self.camera_settings.mode_widgets["Pixels"].widget.get() == ""
        assert self.camera_settings.mode_widgets["Pixels"].widget.cget("from") == 1
        assert (
            self.camera_settings.mode_widgets["Pixels"].widget.cget("to")
            == self.camera_settings.default_height / 2
        )
        assert self.camera_settings.mode_widgets["Pixels"].widget.cget("increment") == 1

        # Framerate
        assert (
            str(self.camera_settings.framerate_widgets["exposure_time"].widget["state"])
            == "disabled"
        )
        assert (
            str(self.camera_settings.framerate_widgets["readout_time"].widget["state"])
            == "disabled"
        )
        assert (
            str(self.camera_settings.framerate_widgets["max_framerate"].widget["state"])
            == "disabled"
        )

        # Set range value
        assert (
            self.camera_settings.roi_widgets["Width"].widget.cget("to")
            == self.camera_settings.default_width
        )
        assert self.camera_settings.roi_widgets["Width"].widget.cget("from") == 2
        assert self.camera_settings.roi_widgets["Width"].widget.cget("increment") == 2
        assert (
            self.camera_settings.roi_widgets["Height"].widget.cget("to")
            == self.camera_settings.default_height
        )
        assert self.camera_settings.roi_widgets["Height"].widget.cget("from") == 2
        assert self.camera_settings.roi_widgets["Height"].widget.cget("increment") == 2

        # Set binning options
        assert list(self.camera_settings.roi_widgets["Binning"].widget["values"]) == [
            "{}x{}".format(i, i) for i in [1, 2, 4]
        ]
        assert (
            str(self.camera_settings.roi_widgets["Binning"].widget["state"])
            == "readonly"
        )

        # FOV
        assert (
            str(self.camera_settings.roi_widgets["FOV_X"].widget["state"]) == "disabled"
        )
        assert (
            str(self.camera_settings.roi_widgets["FOV_Y"].widget["state"]) == "disabled"
        )

    def test_attr(self):

        attrs = [
            "in_initialization",
            "resolution_value",
            "mode",
            "solvent",
            "mode_widgets",
            "framerate_widgets",
            "roi_widgets",
            "roi_btns",
            "default_pixel_size",
            "default_width",
            "default_height",
            "pixel_event_id",
        ]

        for attr in attrs:
            assert hasattr(self.camera_settings, attr)

    def test_populate_experiment_values(self):
        microscope_name = self.camera_settings.parent_controller.configuration[
            "experiment"
        ]["MicroscopeState"]["microscope_name"]
        self.camera_settings.parent_controller.configuration["experiment"][
            "CameraParameters"
        ][microscope_name]["readout_time"] = 0.1
        # Populate widgets with values from experiment file and check
        self.camera_settings.populate_experiment_values()
        camera_setting_dict = self.camera_settings.parent_controller.configuration[
            "experiment"
        ]["CameraParameters"][microscope_name]

        # Checking values altered are correct
        assert dict(self.camera_settings.camera_setting_dict) == dict(
            self.camera_settings.parent_controller.configuration["experiment"][
                "CameraParameters"
            ][microscope_name]
        )
        assert (
            str(self.camera_settings.mode_widgets["Sensor"].get())
            == camera_setting_dict["sensor_mode"]
        )
        if camera_setting_dict["sensor_mode"] == "Normal":
            pass
            # assert str(self.camera_settings.mode_widgets[
            #                "Readout"].get()) == ""
            # assert str(self.camera_settings.mode_widgets[
            #                "Pixels"].get()) == ""
        elif camera_setting_dict["sensor_mode"] == "Light-Sheet":
            assert (
                str(self.camera_settings.mode_widgets["Readout"].get())
                == self.camera_settings.camera_setting_dict["readout_direction"]
            )
            assert (
                str(self.camera_settings.mode_widgets["Pixels"].get())
                == self.camera_settings.camera_setting_dict["number_of_pixels"]
            )

        # ROI
        assert (
            self.camera_settings.roi_widgets["Width"].get()
            == camera_setting_dict["x_pixels"]
        )
        assert (
            self.camera_settings.roi_widgets["Height"].get()
            == camera_setting_dict["y_pixels"]
        )

        assert self.camera_settings.roi_widgets[
            "Top_X"
        ].get() == camera_setting_dict.get("top_x", 0)
        assert self.camera_settings.roi_widgets[
            "Top_Y"
        ].get() == camera_setting_dict.get("top_y", 0)
        if camera_setting_dict.get("is_centered", True):
            assert (
                str(self.camera_settings.roi_widgets["Top_X"].widget["state"])
                == "disabled"
            )
            assert (
                str(self.camera_settings.roi_widgets["Top_Y"].widget["state"])
                == "disabled"
            )

        # Binning
        assert (
            str(self.camera_settings.roi_widgets["Binning"].get())
            == camera_setting_dict["binning"]
        )

        # Exposure Time
        channels = self.camera_settings.parent_controller.configuration["experiment"][
            "MicroscopeState"
        ]["channels"]
        exposure_time = channels[list(channels.keys())[0]]["camera_exposure_time"]
        assert (
            self.camera_settings.framerate_widgets["exposure_time"].get()
            == exposure_time
        )
        assert (
            self.camera_settings.framerate_widgets["frames_to_average"].get()
            == camera_setting_dict["frames_to_average"]
        )
        assert self.camera_settings.in_initialization is False

    @pytest.mark.parametrize("mode", ["Normal", "Light-Sheet"])
    def test_update_experiment_values(self, mode):

        microscope_name = self.camera_settings.parent_controller.configuration[
            "experiment"
        ]["MicroscopeState"]["microscope_name"]
        # Setup basic default experiment
        self.camera_settings.camera_setting_dict = (
            self.camera_settings.parent_controller.configuration["experiment"][
                "CameraParameters"
            ][microscope_name]
        )

        # Setting up new values in widgets
        self.camera_settings.mode_widgets["Sensor"].set(mode)
        self.camera_settings.roi_widgets["Binning"].set("4x4")
        if mode == "Light-Sheet":
            self.camera_settings.mode_widgets["Readout"].set("Bottom-to-Top")
            self.camera_settings.mode_widgets["Pixels"].set(15)
            self.camera_settings.roi_widgets["Binning"].set("1x1")
        width, height = random.randint(1, 2000), random.randint(1, 2000)
        self.camera_settings.roi_widgets["Width"].set(width)
        self.camera_settings.roi_widgets["Height"].set(height)
        self.camera_settings.framerate_widgets["frames_to_average"].set(5)

        # Update experiment dict and assert
        self.camera_settings.update_experiment_values()
        assert self.camera_settings.camera_setting_dict["sensor_mode"] == mode
        if mode == "Light-Sheet":
            assert (
                self.camera_settings.camera_setting_dict["readout_direction"]
                == "Bottom-to-Top"
            )
            assert (
                int(self.camera_settings.camera_setting_dict["number_of_pixels"]) == 15
            )
        step_width = self.camera_settings.step_width
        step_height = self.camera_settings.step_height
        set_width = int(width // step_width) * step_width
        set_height = int(height // step_height) * step_height
        if mode == "Light-Sheet":
            assert self.camera_settings.camera_setting_dict["binning"] == "1x1"
            assert self.camera_settings.camera_setting_dict["img_x_pixels"] == set_width
            assert (
                self.camera_settings.camera_setting_dict["img_y_pixels"] == set_height
            )
            binning = 1
        else:
            assert self.camera_settings.camera_setting_dict["binning"] == "4x4"
            # make sure image size is divisible by step_width and step_height
            assert self.camera_settings.camera_setting_dict["img_x_pixels"] == (
                set_width // 4
            ) - (set_width // 4 % step_width)
            assert self.camera_settings.camera_setting_dict["img_y_pixels"] == (
                set_height // 4
            ) - (set_height // 4 % step_height)
            binning = 4

        # make sure x, y pixels are img_x, img_y pixels * binning
        assert (
            self.camera_settings.camera_setting_dict["x_pixels"]
            == self.camera_settings.camera_setting_dict["img_x_pixels"] * binning
        )
        assert (
            self.camera_settings.camera_setting_dict["y_pixels"]
            == self.camera_settings.camera_setting_dict["img_y_pixels"] * binning
        )
        assert (
            self.camera_settings.camera_setting_dict["pixel_size"]
            == self.camera_settings.default_pixel_size
        )
        assert self.camera_settings.camera_setting_dict["frames_to_average"] == 5

    @pytest.mark.parametrize("mode", ["Normal", "Light-Sheet"])
    def test_update_sensor_mode(self, mode):
        self.camera_settings.populate_experiment_values()
        microscope_name = self.camera_settings.parent_controller.configuration[
            "experiment"
        ]["MicroscopeState"]["microscope_name"]
        camera_setting_dict = self.camera_settings.parent_controller.configuration[
            "experiment"
        ]["CameraParameters"][microscope_name]

        # Set mode
        self.camera_settings.mode_widgets["Sensor"].widget.set(mode)
        self.camera_settings.mode_widgets["Sensor"].widget.event_generate(
            "<<ComboboxSelected>>"
        )

        # Call update
        # self.camera_settings.update_sensor_mode()

        # Check values
        if mode == "Normal":
            assert str(self.camera_settings.mode_widgets["Readout"].get()) == " "
            assert (
                str(self.camera_settings.mode_widgets["Readout"].widget["state"])
                == "disabled"
            )
            assert (
                str(self.camera_settings.mode_widgets["Pixels"].widget["state"])
                == "disabled"
            )
            assert str(self.camera_settings.mode_widgets["Pixels"].widget.get()) == ""

        if mode == "Light-Sheet":
            assert (
                str(self.camera_settings.mode_widgets["Readout"].get())
                == camera_setting_dict["readout_direction"]
            )
            assert (
                str(self.camera_settings.mode_widgets["Readout"].widget["state"])
                == "readonly"
            )
            assert (
                str(self.camera_settings.mode_widgets["Pixels"].widget["state"])
                == "normal"
            )
            assert int(self.camera_settings.mode_widgets["Pixels"].widget.get()) == int(
                self.camera_settings.camera_setting_dict["number_of_pixels"]
            )

    def test_update_exposure_time(self):

        # Call funciton
        self.camera_settings.update_exposure_time(35)

        # Check
        assert self.camera_settings.framerate_widgets["exposure_time"].get() == 35

    @pytest.mark.parametrize("name", ["All", "1600", "1024", "512"])
    def test_update_roi(self, name):

        # Call button to check if handler setup correctly
        self.camera_settings.roi_btns[name].invoke()

        # Check
        if name == "All":
            name = "2048"
        assert str(self.camera_settings.roi_widgets["Width"].get()) == name
        assert str(self.camera_settings.roi_widgets["Height"].get()) == name

    def test_update_fov(self):
        self.camera_settings.populate_experiment_values()

        # Change invoke
        self.camera_settings.in_initialization = False
        self.camera_settings.roi_widgets["Width"].widget.set(2048)
        self.camera_settings.roi_widgets["Height"].widget.set(2048)
        xFov = int(self.camera_settings.roi_widgets["FOV_X"].get())
        yFov = int(self.camera_settings.roi_widgets["FOV_Y"].get())
        self.camera_settings.roi_widgets["Width"].widget.set(1600)
        self.camera_settings.roi_widgets["Height"].widget.set(1600)

        # need these since we switched to read events
        self.camera_settings.roi_widgets["Width"].get_variable().get()
        self.camera_settings.roi_widgets["Height"].get_variable().get()

        # Check
        assert xFov != int(self.camera_settings.roi_widgets["FOV_X"].get())
        assert yFov != int(self.camera_settings.roi_widgets["FOV_Y"].get())

        # Reset
        self.camera_settings.roi_widgets["Width"].widget.set(2048)
        self.camera_settings.roi_widgets["Height"].widget.set(2048)

        # need these since we switched to read events
        self.camera_settings.roi_widgets["Width"].get_variable().get()
        self.camera_settings.roi_widgets["Height"].get_variable().get()

        assert int(self.camera_settings.roi_widgets["FOV_X"].get()) == 13066
        assert int(self.camera_settings.roi_widgets["FOV_Y"].get()) == 13066

    @pytest.mark.parametrize("mode", ["live", "z-stack", "stop", "single"])
    @pytest.mark.parametrize("readout", ["Normal", "Light-Sheet"])
    def test_set_mode(self, mode, readout):

        # Populate widgets with values from experiment file
        self.camera_settings.populate_experiment_values()

        # Set mode
        self.camera_settings.mode_widgets["Sensor"].widget.set(readout)
        self.camera_settings.update_sensor_mode()
        self.camera_settings.set_mode(mode)

        # Check
        assert self.camera_settings.mode == mode
        if mode != "stop":
            state = "disabled"
        else:
            state = "normal"
        if mode != "stop":
            state_readonly = "disabled"
        else:
            state_readonly = "readonly"

        assert (
            str(self.camera_settings.mode_widgets["Sensor"].widget["state"])
            == state_readonly
        )
        if str(self.camera_settings.mode_widgets["Sensor"].get()) == "Light-Sheet":
            assert (
                str(self.camera_settings.mode_widgets["Readout"].widget["state"])
                == state_readonly
            )
            if mode == "live":
                assert (
                    str(self.camera_settings.mode_widgets["Pixels"].widget["state"])
                    == "normal"
                )
            else:
                assert (
                    str(self.camera_settings.mode_widgets["Pixels"].widget["state"])
                    == state
                )
        else:
            assert (
                str(self.camera_settings.mode_widgets["Readout"].widget["state"])
                == "disabled"
            )
            assert (
                str(self.camera_settings.mode_widgets["Pixels"].widget["state"])
                == "disabled"
            )
        assert (
            str(
                self.camera_settings.framerate_widgets["frames_to_average"].widget[
                    "state"
                ]
            )
            == state
        )
        assert str(self.camera_settings.roi_widgets["Width"].widget["state"]) == state
        assert str(self.camera_settings.roi_widgets["Height"].widget["state"]) == state
        assert (
            str(self.camera_settings.roi_widgets["Binning"].widget["state"])
            == state_readonly
        )
        for btn_name in self.camera_settings.roi_btns:
            assert str(self.camera_settings.roi_btns[btn_name]["state"]) == state

    @pytest.mark.parametrize("zoom", ["0.63x", "1x", "2x", "3x", "4x", "5x", "6x"])
    def test_calculate_physical_dimensions(self, zoom):
        self.camera_settings.parent_controller.configuration["experiment"][
            "MicroscopeState"
        ]["zoom"] = zoom

        self.camera_settings.populate_experiment_values()

        # Calling
        self.camera_settings.calculate_physical_dimensions()

        pixel_size = self.camera_settings.default_pixel_size
        x_pixel = float(self.camera_settings.roi_widgets["Width"].get())
        y_pixel = float(self.camera_settings.roi_widgets["Height"].get())

        microscope_state_dict = self.camera_settings.parent_controller.configuration[
            "experiment"
        ]["MicroscopeState"]
        zoom = microscope_state_dict["zoom"]
        microscope_name = microscope_state_dict["microscope_name"]
        pixel_size = self.camera_settings.parent_controller.configuration[
            "configuration"
        ]["microscopes"][microscope_name]["zoom"]["pixel_size"][zoom]

        dim_x = x_pixel * pixel_size
        dim_y = y_pixel * pixel_size

        assert float(self.camera_settings.roi_widgets["FOV_X"].get()) == float(
            int(dim_x)
        )
        assert float(self.camera_settings.roi_widgets["FOV_Y"].get()) == float(
            int(dim_y)
        )

        # Reset to zoom of 1
        self.camera_settings.parent_controller.configuration["experiment"][
            "MicroscopeState"
        ]["zoom"] = "1x"
        assert (
            self.camera_settings.parent_controller.configuration["experiment"][
                "MicroscopeState"
            ]["zoom"]
            == "1x"
        )

    def test_calculate_readout_time(self):
        """
        TODO need more info about camera before testing
        """
        pass

    @pytest.mark.parametrize(
        "mode", ["single", "live", "customized", "z-stack", "stop"]
    )
    def test_update_number_of_pixels(self, mode):
        import random

        self.camera_settings.populate_experiment_values()

        self.camera_settings.mode = mode

        self.camera_settings.mode_widgets["Pixels"].set("")
        assert self.camera_settings.camera_setting_dict["number_of_pixels"] != ""

        n_pixels = random.randint(1, 100)
        self.camera_settings.mode_widgets["Pixels"].set(n_pixels)

        # Check
        assert self.camera_settings.camera_setting_dict["number_of_pixels"] == int(
            n_pixels
        )
        if mode != "live" and mode != "stop":
            assert (
                self.camera_settings.camera_setting_dict["number_of_pixels"] == n_pixels
            )

    @pytest.mark.parametrize(
        "x_pixels, y_pixels", [(512, 512), (4096, 4096), (2304, 1024), (1024, 2048)]
    )
    def test_update_camera_device_related_setting(self, x_pixels, y_pixels):
        self.camera_settings.populate_experiment_values()

        microscope_name = self.camera_settings.parent_controller.configuration[
            "experiment"
        ]["MicroscopeState"]["microscope_name"]
        camera_config = self.camera_settings.parent_controller.configuration[
            "configuration"
        ]["microscopes"][microscope_name]["camera"]
        default_x_pixels = camera_config["x_pixels"]
        default_y_pixels = camera_config["y_pixels"]

        camera_config["x_pixels"] = x_pixels
        camera_config["y_pixels"] = y_pixels
        self.camera_settings.update_camera_device_related_setting()

        assert self.camera_settings.roi_widgets["Width"].get() == min(
            self.camera_settings.camera_setting_dict["x_pixels"], x_pixels
        )
        assert self.camera_settings.roi_widgets["Height"].get() == min(
            self.camera_settings.camera_setting_dict["y_pixels"], y_pixels
        )
        assert self.camera_settings.roi_widgets["Width"].widget["to"] == x_pixels
        assert self.camera_settings.roi_widgets["Height"].widget["to"] == y_pixels

        camera_config["x_pixels"] = default_x_pixels
        camera_config["y_pixels"] = default_y_pixels