data/tests/preprocessing_tests/test_tilestitcher.py

"""
 Copyright 2021, Dana-Farber Cancer Institute and Weill Cornell Medicine
 License: GNU GPL 2.0
 """

import glob
import os
import platform
import subprocess
import sys
import tempfile
import urllib
import zipfile
from pathlib import Path
from unittest.mock import MagicMock, patch

import javabridge
import jpype
import pytest

from pathml.preprocessing.tilestitcher import (
    BFConvertExecutionError,
    BFConvertSetupError,
    FileCollectionError,
    ImageStitchingOperationError,
    ImageWritingError,
    JVMInitializationError,
    QuPathClassImportError,
    TIFFParsingError,
    TileStitcher,
)
from pathml.utils import setup_qupath


@pytest.mark.exclude
@pytest.fixture(scope="module")
def tile_stitcher():
    # Attempt to shutdown JavaBridge-based JVM if running
    try:
        javabridge.kill_vm()
        print("Javabridge vm terminated before starting TileStitcher")
    except Exception as e:
        print(f"No running JavaBridge JVM found: {e}")

    # Setup QuPath
    qupath_home = setup_qupath("../../tools/qupath")
    os.environ["QUPATH_HOME"] = qupath_home
    print(os.environ["JAVA_HOME"])
    # Construct path to QuPath jars
    qupath_jars_dir = os.path.join(qupath_home, "lib", "app")
    qupath_jars = glob.glob(os.path.join(qupath_jars_dir, "*.jar"))
    qupath_jars.append(os.path.join(qupath_jars_dir, "libopenslide-jni.so"))

    bfconvert_dir = "./"
    stitcher = TileStitcher(qupath_jarpath=qupath_jars, bfconvert_dir=bfconvert_dir)

    yield stitcher

    # Teardown code
    try:
        javabridge.kill_vm()
        print("Javabridge vm terminated in teardown")
    except Exception as e:
        print(f"Error during JVM teardown: {e}")


@pytest.mark.exclude
@pytest.fixture(scope="module")
def java_home():
    return os.environ.get("JAVA_HOME")


@pytest.mark.exclude
@pytest.fixture
def output_file_path(tmp_path):
    # tmp_path is a pytest fixture that provides a temporary directory unique to the test invocation
    output_path = tmp_path / "output"
    yield str(output_path)
    # Teardown: Remove the file after the test
    if output_path.exists():
        output_path.unlink()


@pytest.mark.exclude
@pytest.fixture
def mock_jpype_startJVM(monkeypatch):
    monkeypatch.setattr(jpype, "startJVM", MagicMock())


@pytest.mark.exclude
@pytest.fixture
def mock_jpype_shutdownJVM(monkeypatch):
    monkeypatch.setattr(jpype, "shutdownJVM", MagicMock())


@pytest.mark.exclude
def test_jvm_startup(tile_stitcher):

    assert jpype.isJVMStarted(), "JVM should start when TileStitcher is initialized"


@pytest.mark.exclude
def test_jvm_start_with_default_options(tile_stitcher):
    assert jpype.isJVMStarted(), "JVM should have started with default options."


@pytest.mark.exclude
def test_parse_region_exception(tile_stitcher):
    filename = "dummy_file.tif"
    with pytest.raises(TIFFParsingError) as exc_info:
        tile_stitcher.parseRegion(filename)
    assert "Error checking TIFF file dummy_file.tif:" in str(exc_info.value)


@pytest.mark.exclude
@pytest.mark.parametrize(
    "memory, expected_memory_option",
    [
        ("512m", "-Xmx512m"),
        ("1g", "-Xmx1g"),
        ("2048m", "-Xmx2048m"),
        # Add more memory options if needed
    ],
)
def test_format_jvm_options_memory(memory, expected_memory_option, tile_stitcher):
    result = tile_stitcher.format_jvm_options([], memory)
    assert result[0] == expected_memory_option


@pytest.mark.exclude
@pytest.mark.parametrize(
    "qupath_jars, expected_classpath_suffix",
    [
        ([], ""),
        (
            ["/path/to/jar1.jar", "/path/to/jar2.jar"],
            "/path/to/jar1.jar:/path/to/jar2.jar",
        ),
        (
            ["C:\\path\\to\\jar1.jar", "C:\\path\\to\\jar2.jar"],
            "C:\\path\\to\\jar1.jar;C:\\path\\to\\jar2.jar",  # Adjusted to use backslashes and semicolon for Windows
        ),
    ],
)
def test_format_jvm_options_classpath(
    qupath_jars, expected_classpath_suffix, tile_stitcher, monkeypatch
):
    os_name = "nt" if any("C:\\" in jar for jar in qupath_jars) else "posix"
    monkeypatch.setattr(
        platform, "system", lambda: "Windows" if os_name == "nt" else "Linux"
    )
    monkeypatch.setattr(os, "pathsep", ";" if os_name == "nt" else ":")
    _, class_path_option = tile_stitcher.format_jvm_options(qupath_jars, "512m")
    expected_classpath = "-Djava.class.path=" + expected_classpath_suffix
    assert class_path_option == expected_classpath


@pytest.mark.exclude
def test_collect_tif_files(tile_stitcher):
    # Assuming a directory with one tif file for testing
    dir_path = "some_directory"
    os.makedirs(dir_path, exist_ok=True)
    with open(os.path.join(dir_path, "test.tif"), "w") as f:
        f.write("test content")

    files = tile_stitcher._collect_tif_files(dir_path)
    assert len(files) == 1
    assert "test.tif" in files[0]

    os.remove(os.path.join(dir_path, "test.tif"))
    os.rmdir(dir_path)


@pytest.mark.exclude
def test_checkTIFF_valid(tile_stitcher, tmp_path):
    # Create a mock TIFF file
    tiff_path = tmp_path / "mock.tiff"
    tiff_path.write_bytes(b"II*\x00")  # Little-endian TIFF signature
    # assert tile_stitcher.checkTIFF(tiff_path) == True
    assert tile_stitcher.checkTIFF(tiff_path)


@pytest.mark.exclude
def test_checkTIFF_invalid(tile_stitcher, tmp_path):
    # Create a mock non-TIFF file
    txt_path = tmp_path / "mock.txt"
    txt_path.write_text("Not a TIFF file")
    # assert tile_stitcher.checkTIFF(txt_path) == False
    assert not tile_stitcher.checkTIFF(txt_path)


@pytest.mark.exclude
def test_checkTIFF_nonexistent(tile_stitcher):
    with pytest.raises(TIFFParsingError):
        tile_stitcher.checkTIFF("nonexistent_file.tiff")


@pytest.mark.exclude
def test_check_tiff(tile_stitcher):
    valid_tif = b"II*"
    invalid_tif = b"abcd"

    with open("valid_test.tif", "wb") as f:
        f.write(valid_tif)

    with open("invalid_test.tif", "wb") as f:
        f.write(invalid_tif)

    assert tile_stitcher.checkTIFF("tests/testdata/smalltif.tif") is True
    assert tile_stitcher.checkTIFF("invalid_test.tif") is False

    os.remove("valid_test.tif")
    os.remove("invalid_test.tif")


@pytest.mark.exclude
def test_get_outfile_ending_with_ome_tif(tile_stitcher):
    result, result_jpype = tile_stitcher._get_outfile("test.ome.tif")
    assert result == "test.ome.tif"
    assert str(result_jpype) == "test.ome.tif"


@pytest.mark.exclude
def test_get_outfile_without_ending(tile_stitcher):
    result, result_jpype = tile_stitcher._get_outfile("test.ome.tif")
    assert result == "test.ome.tif"
    assert str(result_jpype) == "test.ome.tif"


@pytest.mark.exclude
# Dummy function to "fake" the file download
def mocked_urlretrieve(*args, **kwargs):
    pass


@pytest.mark.exclude
# Mock Zip class as provided
class MockZip:
    def __init__(self, zip_path, *args, **kwargs):
        self.zip_path = zip_path

    def __enter__(self):
        with zipfile.ZipFile(self.zip_path, "w") as zipf:
            zipf.writestr("dummy.txt", "This is dummy file content")
        return self

    def __exit__(self, *args):
        os.remove(self.zip_path)

    def extractall(self, path, *args, **kwargs):
        bftools_dir = os.path.join(path, "bftools")
        if not os.path.exists(bftools_dir):
            os.makedirs(bftools_dir)

        with open(os.path.join(bftools_dir, "bfconvert"), "w") as f:
            f.write("#!/bin/sh\necho 'dummy bfconvert'")

        with open(os.path.join(bftools_dir, "bf.sh"), "w") as f:
            f.write("#!/bin/sh\necho 'dummy bf.sh'")


@pytest.mark.exclude
def mock_create_zip(zip_path):
    """
    Creates a mock zip file at the given path.
    """
    # Create mock files to add to the ZIP
    with tempfile.NamedTemporaryFile(delete=False) as tmpfile:
        tmpfile.write(b"Mock file content")

    # Create the mock ZIP file
    with zipfile.ZipFile(zip_path, "w") as zipf:
        zipf.write(tmpfile.name, "mock_file.txt")
    os.unlink(tmpfile.name)  # Clean up the temporary file


@pytest.mark.exclude
@pytest.fixture
def bfconvert_dir(tmp_path):
    return tmp_path / "bfconvert_dir"


@pytest.mark.exclude
@pytest.fixture(scope="module")
def bfconvert_setup(tile_stitcher, tmp_path_factory):

    bfconvert_dir = tmp_path_factory.mktemp("bfconvert_dir")
    tile_stitcher.setup_bfconvert(str(bfconvert_dir))
    return bfconvert_dir


@pytest.mark.exclude
def test_bfconvert_path_setup(tile_stitcher, bfconvert_setup):
    bfconvert_path = tile_stitcher.setup_bfconvert(str(bfconvert_setup))
    assert str(bfconvert_path) == str(
        tile_stitcher.bfconvert_path
    ), "bfconvert path not set correctly"
    assert os.path.exists(
        bfconvert_path
    ), "bfconvert executable does not exist at the expected path"


@pytest.mark.exclude
def test_bfconvert_version_output(tile_stitcher, bfconvert_setup, capsys):
    tile_stitcher.setup_bfconvert(str(bfconvert_setup))
    captured = capsys.readouterr()
    assert (
        "bfconvert version:" in captured.out
    ), "bfconvert version not printed correctly"


# @pytest.mark.exclude
# def test_permission_error_on_directory_creation(tile_stitcher):

#     if sys.platform.startswith("darwin"):
#         pytest.skip("MacOS does not allow write permissions for this test", allow_module_level=True)

#     with pytest.raises(BFConvertSetupError):
#         tile_stitcher.setup_bfconvert("/fake/path")


@pytest.mark.exclude
@pytest.fixture
def mock_subprocess(monkeypatch):
    mock = MagicMock()
    monkeypatch.setattr("subprocess.check_output", mock)
    monkeypatch.setattr("subprocess.run", mock)
    return mock


@pytest.mark.exclude
@pytest.fixture
def mock_urlretrieve(monkeypatch):

    if sys.platform.startswith("darwin"):
        pytest.skip(
            "MacOS does not allow write permissions for this test",
            allow_module_level=True,
        )

    def fake_urlretrieve(url, filename):
        # Simulate downloading by creating a dummy zip file at the specified filename
        with zipfile.ZipFile(filename, "w") as zipf:
            zipf.writestr("dummy.txt", "This is dummy content")
            zipf.writestr("bftools/bfconvert", "dummy content")
            zipf.writestr("bftools/bf.sh", "dummy content")

    monkeypatch.setattr(urllib.request, "urlretrieve", fake_urlretrieve)


@pytest.fixture
@pytest.mark.exclude
def mock_tools_dir(tmp_path):
    tools_dir = tmp_path / "tools"
    tools_dir.mkdir()
    return tools_dir


@pytest.mark.exclude
def test_bfconvert_failure(
    mock_subprocess, mock_urlretrieve, tile_stitcher, mock_tools_dir
):
    with patch(
        "subprocess.check_output", side_effect=subprocess.CalledProcessError(1, "cmd")
    ):
        with pytest.raises(BFConvertSetupError):
            tile_stitcher.setup_bfconvert(str(mock_tools_dir))


@pytest.mark.exclude
def test_is_bfconvert_available_file_not_found(tile_stitcher):
    with patch("subprocess.run", side_effect=FileNotFoundError()):
        assert not tile_stitcher.is_bfconvert_available()


@pytest.mark.exclude
def test_run_bfconvert_error(tile_stitcher):
    tile_stitcher.bfconvert_path = "dummy_path"
    with patch.object(
        tile_stitcher, "is_bfconvert_available", return_value=True
    ), patch("subprocess.run", side_effect=subprocess.CalledProcessError(1, "cmd")):
        with pytest.raises(BFConvertExecutionError):
            tile_stitcher.run_bfconvert("dummy_stitched_image_path.tif")


@pytest.mark.exclude
def test_is_bfconvert_available_true(tile_stitcher):
    with patch(
        "subprocess.run",
        return_value=subprocess.CompletedProcess(args=[], returncode=0),
    ):
        assert tile_stitcher.is_bfconvert_available() is True


@pytest.mark.exclude
def test_is_bfconvert_available_false(tile_stitcher):
    with patch(
        "subprocess.run",
        return_value=subprocess.CompletedProcess(args=[], returncode=1),
    ):
        assert tile_stitcher.is_bfconvert_available() is False


@pytest.mark.exclude
@pytest.mark.parametrize(
    "is_available, expected_exception",
    [
        (False, BFConvertExecutionError),
        (True, None),  # No exception should be raised if bfconvert is available
    ],
)
def test_run_bfconvert_bfconvert_not_available(
    tile_stitcher, is_available, expected_exception
):
    tile_stitcher.bfconvert_path = "dummy_path"
    with patch.object(
        tile_stitcher, "is_bfconvert_available", return_value=is_available
    ), patch("subprocess.run"):
        if expected_exception:
            with pytest.raises(expected_exception):
                tile_stitcher.run_bfconvert("dummy_stitched_image_path")
        else:
            tile_stitcher.run_bfconvert("dummy_stitched_image_path")


@pytest.mark.exclude
def test_run_bfconvert_custom_bfconverted_path(tile_stitcher, tmp_path):
    tile_stitcher.bfconvert_path = str(tmp_path / "bfconvert")
    stitched_image_path = str(tmp_path / "dummy_stitched_image_path.ome.tif")
    # Create a dummy stitched image file
    with open(stitched_image_path, "w") as f:
        f.write("dummy content")

    with patch.object(
        tile_stitcher, "is_bfconvert_available", return_value=True
    ), patch("subprocess.run"):
        tile_stitcher.run_bfconvert(
            stitched_image_path, str(tmp_path / "custom_path.tif")
        )


@pytest.mark.exclude
def test_run_bfconvert_success_delete_original(tile_stitcher, capsys):
    tile_stitcher.bfconvert_path = "dummy_path"
    stitched_image_path = "dummy_stitched_image_path.ome.tif"

    # Create a dummy stitched image file
    with open(stitched_image_path, "w") as f:
        f.write("dummy content")

    with patch.object(tile_stitcher, "is_bfconvert_available", return_value=True):
        with patch("subprocess.run"):
            tile_stitcher.run_bfconvert(stitched_image_path, delete_original=True)
            captured = capsys.readouterr()
            assert "bfconvert completed. Output file: " in captured.out
            assert "Original stitched image deleted: " in captured.out

    # Check if the original file was deleted
    assert not os.path.exists(stitched_image_path)


@pytest.mark.exclude
def test_run_bfconvert_no_delete_original(tile_stitcher, capsys):
    tile_stitcher.bfconvert_path = "dummy_path"
    stitched_image_path = "dummy_stitched_image_path.ome.tif"

    # Create a dummy stitched image file
    with open(stitched_image_path, "w") as f:
        f.write("dummy content")

    with patch.object(tile_stitcher, "is_bfconvert_available", return_value=True):
        with patch("subprocess.run"):
            tile_stitcher.run_bfconvert(stitched_image_path, delete_original=False)
            captured = capsys.readouterr()
            assert "bfconvert completed. Output file: " in captured.out
            assert "Original stitched image deleted: " not in captured.out

    # Check if the original file still exists
    assert os.path.exists(stitched_image_path)
    if os.path.exists(stitched_image_path):
        os.unlink(stitched_image_path)


@pytest.mark.exclude
@pytest.fixture
def sample_files():
    # Paths to your sample TIF files for testing
    return [
        "tests/testdata/tilestitching_testdata/MISI3542i_W21-04143_bi016966_M394_OVX_LM_Scan1_[14384,29683]_component_data.tif"
    ]


# @pytest.fixture
# def sample_files(tmp_path):
#     # Create a dummy TIFF file for testing
#     file_path = tmp_path / "dummy_file.tif"
#     file_path.write_text("TIFF data")
#     return [str(file_path)]


@pytest.mark.exclude
def test_integration_stitching_exceptions(
    tile_stitcher, sample_files, output_file_path
):
    with patch.object(
        tile_stitcher,
        "_write_pyramidal_image_server",
        side_effect=Exception("Pyramid error"),
    ):
        with pytest.raises(ImageStitchingOperationError):
            tile_stitcher.run_image_stitching(
                sample_files, output_file_path, downsamples=[], separate_series=True
            )


@pytest.mark.exclude
def test_integration_stitching(tile_stitcher, sample_files, output_file_path):
    # Mocking the Java object returned by parse_regions

    tile_stitcher.run_image_stitching(
        sample_files,
        output_file_path,
        downsamples=[1],
        separate_series=True,
    )


@pytest.mark.exclude
def test_integration_stitching_nodownsamples(tile_stitcher, sample_files, tmp_path):
    # Generate the output file name
    output_file_path = str(tmp_path / "output_temp.ome.tif")
    bfconverted_file_path = output_file_path.rsplit(".ome.tif", 1)[0] + "_separated.tif"

    # Create a dummy bfconverted file to simulate existing file scenario
    with open(bfconverted_file_path, "w") as f:
        f.write("dummy content")

    # Run the stitching process
    tile_stitcher.run_image_stitching(
        sample_files,
        output_file_path,
        downsamples=None,
        separate_series=True,
    )

    # Check if the bfconvert path is set correctly
    assert str(tile_stitcher.bfconvert_path) == str(Path("tools/bftools/bfconvert"))

    # Clean up the dummy file
    os.remove(bfconverted_file_path)


@pytest.mark.exclude
def test_checkTIFF_big_endian(tile_stitcher, tmp_path):
    # Create a mock TIFF file with big-endian byte order
    big_endian_file = tmp_path / "big_endian.tiff"
    big_endian_file.write_bytes(b"MM\x00*")  # Big-endian TIFF signature
    assert tile_stitcher.checkTIFF(big_endian_file)


@pytest.mark.exclude
def test_setup_bfconvert_bad_zip_file(tile_stitcher, mock_tools_dir):
    with patch("urllib.request.urlretrieve"), patch(
        "zipfile.ZipFile", side_effect=zipfile.BadZipFile("Invalid ZIP file")
    ):
        with pytest.raises(BFConvertSetupError):
            tile_stitcher.setup_bfconvert(str(mock_tools_dir))


@pytest.mark.exclude
@pytest.mark.skipif(os.name == "nt", reason="chmod not used in windows")
def test_setup_bfconvert_permission_error_on_chmod(
    tile_stitcher, mock_tools_dir, tmp_path
):
    dummy_bfconvert = tmp_path / "bfconvert"
    dummy_bfconvert.touch()
    dummy_bf_sh = tmp_path / "bf.sh"
    dummy_bf_sh.touch()

    tile_stitcher.bfconvert_path = str(dummy_bfconvert)
    tile_stitcher.bf_sh_path = str(dummy_bf_sh)

    with patch("os.chmod", side_effect=PermissionError("Permission denied")):
        with pytest.raises(BFConvertSetupError):
            tile_stitcher.setup_bfconvert(str(mock_tools_dir))


@pytest.mark.exclude
def test_check_tiff_io_error(tile_stitcher):
    with patch("builtins.open", side_effect=OSError("IO error occurred")):
        with pytest.raises(TIFFParsingError):
            tile_stitcher.checkTIFF("invalid_file.tif")


@pytest.mark.exclude
def test_start_jvm_exception(tile_stitcher, capsys):
    with patch("jpype.isJVMStarted", return_value=False), patch(
        "jpype.startJVM", side_effect=Exception("JVM start error")
    ):
        with pytest.raises(JVMInitializationError):
            tile_stitcher._start_jvm()


@pytest.mark.exclude
def test_import_qupath_classes_exception(tile_stitcher):
    with patch("jpype.JPackage", side_effect=Exception("Import error")):
        with pytest.raises(QuPathClassImportError):
            tile_stitcher._import_qupath_classes()


@pytest.mark.exclude
def test_parse_region_invalid_tiff(tile_stitcher):
    non_tiff_file = "non_tiff_file.txt"
    with pytest.raises(TIFFParsingError):
        tile_stitcher.parseRegion(non_tiff_file)


@pytest.mark.exclude
def test_run_image_stitching_with_empty_input(tile_stitcher, sample_files):
    with patch.object(tile_stitcher, "_collect_tif_files", return_value=[]):
        with pytest.raises(ImageStitchingOperationError):
            tile_stitcher.run_image_stitching(sample_files, "output.ome.tif")


@pytest.mark.exclude
@patch("jpype.JPackage", side_effect=Exception("Import error"))
def test_import_qupath_classes_failure(mock_jpackage, tile_stitcher):
    with pytest.raises(QuPathClassImportError) as exc_info:
        tile_stitcher._import_qupath_classes()
    assert "Failed to import QuPath classes: Import error" in str(exc_info.value)


@pytest.mark.exclude
def test_collect_tif_files_invalid_input(tile_stitcher):
    with pytest.raises(FileCollectionError) as exc_info:
        tile_stitcher._collect_tif_files(12345)  # Invalid input
    assert "Invalid input for collecting .tif files:" in str(exc_info.value)


# @pytest.mark.exclude
# @patch("os.chmod", side_effect=PermissionError("Permission denied"))
# def test_setup_bfconvert_permission_error(mock_chmod, tile_stitcher, bfconvert_dir):
#     with pytest.raises(BFConvertSetupError) as exc_info:
#         tile_stitcher.setup_bfconvert(bfconvert_dir)
#     assert "Permission error on setting executable flag: Permission denied" in str(
#         exc_info.value
#     )


@pytest.mark.exclude
def test_parse_region_missing_tags(tile_stitcher):

    with pytest.raises(TIFFParsingError) as exc_info:
        tile_stitcher.parseRegion("tests/testdata/smalltif.tif")
    assert "Required TIFF tags missing for" in str(exc_info.value)


@pytest.mark.exclude
@patch("subprocess.run")
@patch(
    "pathml.preprocessing.tilestitcher.TileStitcher.is_bfconvert_available",
    return_value=True,
)
def test_run_bfconvert_success(
    mock_is_bfconvert_available, mock_subprocess_run, tile_stitcher, tmp_path
):
    tile_stitcher.bfconvert_path = "/path/to/bfconvert"
    stitched_image_path = str(tmp_path / "stitched_image.ome.tif")
    bfconverted_path = str(tmp_path / "bfconverted_image.ome.tif")

    # Create a dummy stitched image file to mimic the existence of a file
    Path(stitched_image_path).touch()

    tile_stitcher.run_bfconvert(
        stitched_image_path, bfconverted_path, delete_original=False
    )

    mock_subprocess_run.assert_called()


@pytest.mark.exclude
@patch("subprocess.run")
@patch(
    "pathml.preprocessing.tilestitcher.TileStitcher.is_bfconvert_available",
    return_value=True,
)
def test_run_bfconvert_delete_original(
    mock_is_bfconvert_available, mock_subprocess_run, tile_stitcher, tmp_path
):
    tile_stitcher.bfconvert_path = "/path/to/bfconvert"
    stitched_image_path = str(tmp_path / "stitched_image.ome.tif")

    # Create a dummy stitched image file
    Path(stitched_image_path).touch()

    tile_stitcher.run_bfconvert(stitched_image_path, delete_original=True)

    assert not Path(stitched_image_path).exists(), "Original file should be deleted."


@pytest.mark.exclude
@patch("subprocess.run")
@patch(
    "pathml.preprocessing.tilestitcher.TileStitcher.is_bfconvert_available",
    return_value=True,
)
def test_run_bfconvert_delete_original_print_message(
    mock_is_bfconvert_available, mock_subprocess_run, tile_stitcher, tmp_path, capsys
):
    tile_stitcher.bfconvert_path = "/path/to/bfconvert"
    stitched_image_path = str(tmp_path / "stitched_image.ome.tif")

    # Create a dummy stitched image file
    Path(stitched_image_path).touch()

    tile_stitcher.run_bfconvert(stitched_image_path, delete_original=True)

    captured = capsys.readouterr()
    assert (
        "Original stitched image deleted:" in captured.out
    ), "Expected deletion message not printed."


@pytest.mark.exclude
def test_toShort(tile_stitcher):
    # Example bytes and their expected short value
    test_cases = [
        ((0x01, 0x02), 0x0102),
        ((0xFF, 0xFF), 0xFFFF),
        ((0x00, 0x00), 0x0000),
        ((0xAB, 0xCD), 0xABCD),
    ]

    for (byte1, byte2), expected in test_cases:
        result = tile_stitcher.toShort(byte1, byte2)
        assert (
            result == expected
        ), f"Expected {expected}, got {result} for bytes {byte1}, {byte2}"


@pytest.mark.exclude
def test_collect_tif_files_success(tile_stitcher, tmp_path):
    # Set up a directory with some .tif files
    dir_path = tmp_path / "tif_files"
    dir_path.mkdir()
    (dir_path / "file1.tif").touch()
    (dir_path / "file2.tif").touch()

    expected_files = sorted([str(dir_path / "file1.tif"), str(dir_path / "file2.tif")])
    collected_files = sorted(tile_stitcher._collect_tif_files(str(dir_path)))

    assert (
        collected_files == expected_files
    ), f"Expected {expected_files}, got {collected_files}"


@pytest.mark.exclude
def test_collect_tif_files_no_valid_files(tile_stitcher):
    # A list of file names without .tif extension
    invalid_files = ["file1.jpg", "file2.png", "file3.docx"]

    with pytest.raises(FileCollectionError) as exc_info:
        tile_stitcher._collect_tif_files(invalid_files)

    assert "No valid .tif files found in the provided list." in str(exc_info.value)


@pytest.mark.exclude
@patch(
    "pathml.preprocessing.tilestitcher.TileStitcher._write_pyramidal_image_server",
    side_effect=ImageWritingError("Stitching error"),
)
def test_image_stitching_operation_error(mock_stitching, sample_files, tile_stitcher):

    with pytest.raises(ImageStitchingOperationError) as exc_info:
        # tile_stitcher.run_image_stitching("/path/to/input_dir", "output_filename.tif")
        # Run the stitching process
        tile_stitcher.run_image_stitching(
            sample_files,
            "output_filename.tif",
            downsamples=-1,
            separate_series=True,
        )
    assert "Error running image stitching: Stitching error" in str(exc_info.value)


@pytest.mark.exclude
@patch(
    "pathml.preprocessing.tilestitcher.TileStitcher.is_bfconvert_available",
    return_value=True,
)
@patch(
    "subprocess.run", side_effect=subprocess.CalledProcessError(1, "bfconvert -version")
)
def test_bfconvert_execution_error(mock_is_available, mock_run, tile_stitcher):
    with pytest.raises(BFConvertExecutionError) as exc_info:
        tile_stitcher.run_bfconvert("/path/to/stitched_image.tif")
    assert "Error running bfconvert command:" in str(exc_info.value)


@pytest.mark.exclude
@patch("subprocess.run", side_effect=FileNotFoundError())
def test_bfconvert_not_available(mock_run, tile_stitcher):
    assert (
        not tile_stitcher.is_bfconvert_available()
    ), "bfconvert should not be available."


@pytest.mark.exclude
@patch("jpype.shutdownJVM")
def test_tile_stitcher_shutdown(mocked_shutdown, tile_stitcher):
    tile_stitcher.shutdown()
    mocked_shutdown.assert_called()


@pytest.mark.exclude
def test_initialization_with_java_home_env_var(tile_stitcher, java_home, monkeypatch):
    # valid_java_home = "/path/to/valid/java"  # Example valid path
    monkeypatch.setenv("JAVA_HOME", java_home)

    new_stitcher = TileStitcher()
    assert (
        new_stitcher.java_home == java_home
    ), "JAVA_HOME environment variable not used correctly"


@pytest.mark.exclude
def test_initialization_without_java_path_or_java_home(monkeypatch):
    monkeypatch.delenv("JAVA_HOME", raising=False)  # Remove JAVA_HOME if it exists
    with pytest.raises(JVMInitializationError):
        TileStitcher()


@pytest.mark.exclude
@pytest.fixture
def mock_jpype(monkeypatch):
    # Mock jpype's startJVM and isJVMStarted functions to avoid actual JVM initialization
    monkeypatch.setattr("jpype.startJVM", MagicMock())
    monkeypatch.setattr("jpype.isJVMStarted", MagicMock(return_value=True))
    monkeypatch.setattr(
        "jpype.getDefaultJVMPath", MagicMock(return_value="/mock/path/to/jvm")
    )


@pytest.mark.exclude
def test_initialization_sets_java_home(mock_jpype, monkeypatch):
    mock_java_path = "/mock/path/to/java"
    monkeypatch.setenv("JAVA_HOME", mock_java_path)
    # Ensure jpype.startJVM is not actually called
    with patch("os.path.isdir", return_value=True):
        stitcher = TileStitcher()
        assert stitcher.java_home == mock_java_path, "JAVA_HOME not set correctly"


@pytest.mark.exclude
@patch("jpype.getDefaultJVMPath", side_effect=Exception("JVM path error"))
def test_initialization_with_invalid_java_path(mock_get_jvm_path, tmp_path):
    with pytest.raises(JVMInitializationError):
        TileStitcher(java_path=str(tmp_path))