public class TiffCreator
{
    public static void CreateTiff(string outputPath, byte[] bytes, int width, int height)
    {
        try
        {
            var image = Image.NewFromMemory(bytes, width, height, 1, Enums.BandFormat.Uchar);
            
            image.Tiffsave(outputPath);

            Console.WriteLine($"OME-TIFF created successfully at: {outputPath}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error creating OME-TIFF: {ex.Message}");
            throw; // Re-throw for debugging
        }
    }
    
    public static void AppendImageToTiff(string tiffPath, byte[] newImageBytes, int width, int height, bool final = false)
    {
        try
        {
            // Load the existing TIFF
            var bytes = File.ReadAllBytes(tiffPath);
            var existingTiff = Image.NewFromBuffer(bytes, access: Enums.Access.Sequential);
            
            // Load the new image from the byte array
            var newImage = Image.NewFromMemory(newImageBytes, width, height, 1, Enums.BandFormat.Uchar);

            // Combine the existing TIFF and the new image
            var combinedTiff = existingTiff.Join(newImage, Enums.Direction.Vertical, expand: true);

            // Update the `page-height` to account for the new image
            if (final)
            {
                combinedTiff = combinedTiff.Mutate(mutable =>
                {
                    mutable.Set(GValue.GIntType, "page-height", height);
                });
            }

            // Save the updated TIFF
            File.Delete(tiffPath);
            combinedTiff.Tiffsave(tiffPath);

            Console.WriteLine($"Appended new image to TIFF: {tiffPath}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error appending image to TIFF: {ex.Message}");
            throw; // Re-throw for debugging
        }
    }

    public static void AddStringToFirstIFD(string tiffPath, string metadata)
    {
        try
        {
            // Load the entire TIFF
            byte[] existingTiffBytes = File.ReadAllBytes(tiffPath);
            var baseImage = Image.NewFromBuffer(existingTiffBytes, access: Enums.Access.Sequential);
        
            // Check how many pages the TIFF has
            int totalPages = (int)baseImage.Get("n-pages");

            // Collect all pages into an array
            var pages = new Image[totalPages];

            // Add metadata to the first page
            pages[0] = Image.NewFromBuffer(existingTiffBytes, "page=0").Mutate(mutable =>
            {
                mutable.Set(GValue.GStrType, "image-description", metadata);
            });

            // Load remaining pages without modifying metadata
            for (int i = 1; i < totalPages; i++)
            {
                pages[i] = Image.NewFromBuffer(existingTiffBytes, $"page={i}").Mutate(mut =>
                {
                    mut.Set(GValue.GStrType, "image-description", "THIS IS A TEST");
                });
            }
            
            // Combine all pages into a single TIFF
            var combinedTiff = Image.Arrayjoin(pages, across: 1);

            // Ensure `page-height` metadata is set
            combinedTiff = combinedTiff.Mutate(mutable =>
            {
                if (!mutable.Contains("page-height"))
                {
                    mutable.Set(GValue.GIntType, "page-height", pages[0].Height);
                }
            });

            // Save the updated TIFF back to the file
            combinedTiff.Tiffsave(tiffPath);

            Console.WriteLine($"Added metadata to the first IFD of TIFF: {tiffPath}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error adding metadata to the first IFD: {ex.Message}");
            throw; // Re-throw for debugging
        }
    }
}