/*

 * Copyright (c) 2024, Nico Weber <thakis@chromium.org>

 *

 * SPDX-License-Identifier: BSD-2-Clause

 */

#include <LibGfx/Bitmap.h>

#include <LibGfx/ImageFormats/AnimationWriter.h>

#include <LibGfx/Rect.h>

namespace Gfx {

AnimationWriter::~AnimationWriter() = default;

static bool are_scanlines_equal(Bitmap const& a, Bitmap const& b, int y)

{

    for (int x = 0; x < a.width(); ++x) {

        if (a.get_pixel(x, y) != b.get_pixel(x, y))

            return false;

    }

    return true;

}

static bool are_columns_equal(Bitmap const& a, Bitmap const& b, int x, int y1, int y2)

{

    for (int y = y1; y < y2; ++y) {

        if (a.get_pixel(x, y) != b.get_pixel(x, y))

            return false;

    }

    return true;

}

static Gfx::IntRect rect_where_pixels_are_different(Bitmap const& a, Bitmap const& b)

{

    VERIFY(a.size() == b.size());

    // FIXME: This works on physical pixels.

    VERIFY(a.scale() == 1);

    VERIFY(b.scale() == 1);

    int number_of_equal_pixels_at_top = 0;

    while (number_of_equal_pixels_at_top < a.height() && are_scanlines_equal(a, b, number_of_equal_pixels_at_top))

        ++number_of_equal_pixels_at_top;

    int number_of_equal_pixels_at_bottom = 0;

    while (number_of_equal_pixels_at_bottom < a.height() - number_of_equal_pixels_at_top && are_scanlines_equal(a, b, a.height() - number_of_equal_pixels_at_bottom - 1))

        ++number_of_equal_pixels_at_bottom;

    int const y1 = number_of_equal_pixels_at_top;

    int const y2 = a.height() - number_of_equal_pixels_at_bottom;

    int number_of_equal_pixels_at_left = 0;

    while (number_of_equal_pixels_at_left < a.width() && are_columns_equal(a, b, number_of_equal_pixels_at_left, y1, y2))

        ++number_of_equal_pixels_at_left;

    int number_of_equal_pixels_at_right = 0;

    while (number_of_equal_pixels_at_right < a.width() - number_of_equal_pixels_at_left && are_columns_equal(a, b, a.width() - number_of_equal_pixels_at_right - 1, y1, y2))

        ++number_of_equal_pixels_at_right;

    // WebP can only encode even-sized animation frame positions.

    // FIXME: Change API shape in some way so that the AnimationWriter base class doesn't have to know about this detail of a subclass.

    if (number_of_equal_pixels_at_left % 2 != 0)

        --number_of_equal_pixels_at_left;

    if (number_of_equal_pixels_at_top % 2 != 0)

        --number_of_equal_pixels_at_top;

    Gfx::IntRect rect;

    rect.set_x(number_of_equal_pixels_at_left);

    rect.set_y(number_of_equal_pixels_at_top);

    rect.set_width(a.width() - number_of_equal_pixels_at_left - number_of_equal_pixels_at_right);

    rect.set_height(a.height() - number_of_equal_pixels_at_top - number_of_equal_pixels_at_bottom);

    return rect;

}

bool AnimationWriter::can_zero_out_unchanging_pixels(Bitmap& new_frame, Gfx::IntRect new_frame_rect, Bitmap& last_frame, AllowInterFrameCompression allow_inter_frame_compression) const

{

    if (!can_blend_frames() || allow_inter_frame_compression == AllowInterFrameCompression::No)

        return false;

    VERIFY(new_frame.width() == new_frame_rect.width());

    VERIFY(new_frame.height() == new_frame_rect.height());

    for (int y = 0; y < new_frame.height(); ++y) {

        for (int x = 0; x < new_frame.width(); ++x) {

            if (new_frame.get_pixel(x, y).alpha() != 255 && new_frame.get_pixel(x, y) != last_frame.get_pixel(x + new_frame_rect.x(), y + new_frame_rect.y()))

                return false;

        }

    }

    return true;

}

ErrorOr<void> AnimationWriter::add_frame_relative_to_last_frame(Bitmap& frame, int duration_ms, RefPtr<Bitmap> last_frame, AllowInterFrameCompression allow_inter_frame_compression)

{

    if (!last_frame)

        return add_frame(frame, duration_ms);

    auto rect = rect_where_pixels_are_different(*last_frame, frame);

    if (rect.is_empty()) {

        // The frame is identical to the last frame. Don't store an empty bitmap.

        // FIXME: We could delay writing the last frame until we know that the next frame is different,

        //        and just keep increasing that frame's duration instead.

        rect = { 0, 0, 1, 1 };

    }

    // FIXME: It would be nice to have a way to crop a bitmap without copying the data.

    auto differences = TRY(frame.cropped(rect));

    BlendMode blend_mode = BlendMode::Replace;

    // If all frames of the animation have no alpha, set color values of pixels that are in the changed rect that are

    // equal to the last frame to transparent black and set the frame to be blended. This is almost smaller after compression.

    if (can_zero_out_unchanging_pixels(*differences, rect, *last_frame, allow_inter_frame_compression)) {

        for (int y = 0; y < differences->height(); ++y) {

            for (int x = 0; x < differences->width(); ++x) {

                if (differences->get_pixel(x, y) == last_frame->get_pixel(x + rect.x(), y + rect.y()) || differences->get_pixel(x, y).alpha() == 0)

                    differences->set_pixel(x, y, Color(0, 0, 0, 0));

            }

        }

        blend_mode = BlendMode::Blend;

    }

    // This assumes a replacement disposal method.

    return add_frame(differences, duration_ms, rect.location(), blend_mode);

}

}