/*
 * Copyright 2006, 2023, Haiku.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Stephan Aßmus <superstippi@gmx.de>
 *              Zardshard
 */

#include "GradientControl.h"

#include <stdio.h>

#include <AppDefs.h>
#include <Bitmap.h>
#include <ControlLook.h>
#include <Message.h>
#include <Window.h>

#include "ui_defines.h"
#include "support_ui.h"

#include "GradientTransformable.h"


GradientControl::GradientControl(BMessage* message, BHandler* target)
        : BView(BRect(0, 0, 100, 19), "gradient control", B_FOLLOW_NONE,
                        B_WILL_DRAW | B_FRAME_EVENTS | B_NAVIGABLE),
          fGradient(new ::Gradient()),
          fGradientBitmap(NULL),
          fDraggingStepIndex(-1),
          fCurrentStepIndex(-1),
          fDropOffset(-1.0),
          fDropIndex(-1),
          fEnabled(true),
          fMessage(message),
          fTarget(target)
{
        FrameResized(Bounds().Width(), Bounds().Height());
        SetViewColor(B_TRANSPARENT_32_BIT);
        SetLowColor(ui_color(B_PANEL_BACKGROUND_COLOR));
}


GradientControl::~GradientControl()
{
        delete fGradient;
        delete fGradientBitmap;
        delete fMessage;
}


void
GradientControl::WindowActivated(bool active)
{
        if (IsFocus())
                Invalidate();
}


void
GradientControl::MakeFocus(bool focus)
{
        if (focus != IsFocus()) {
                _UpdateCurrentColor();
                Invalidate();
                if (fTarget) {
                        if (BLooper* looper = fTarget->Looper())
                                looper->PostMessage(MSG_GRADIENT_CONTROL_FOCUS_CHANGED, fTarget);
                }
        }
        BView::MakeFocus(focus);
}


void
GradientControl::MouseDown(BPoint where)
{
        if (!fEnabled)
                return;

        if (!IsFocus()) {
                MakeFocus(true);
        }

        fDraggingStepIndex = _StepIndexFor(where);

        if (fDraggingStepIndex >= 0)
                SetMouseEventMask(B_POINTER_EVENTS, B_LOCK_WINDOW_FOCUS);

        // handle double click
        int32 clicks;
        if (Window()->CurrentMessage()->FindInt32("clicks", &clicks) >= B_OK && clicks >= 2) {
                if (fDraggingStepIndex < 0) {
                        // create a new offset at the click location that uses
                        // the interpolated color
                        float offset = _OffsetFor(where);
                        // create a clean gradient
                        uint32 width = fGradientBitmap->Bounds().IntegerWidth();
                        uint8* temp = new uint8[width * 4];
                        fGradient->MakeGradient((uint32*)temp, width);
                        // get the color at the offset
                        rgb_color color;
                        uint8* bits = temp;
                        bits += 4 * (uint32)((width - 1) * offset);
                        color.red = bits[0];
                        color.green = bits[1];
                        color.blue = bits[2];
                        color.alpha = bits[3];
                        fCurrentStepIndex = fGradient->AddColor(color, offset);
                        fDraggingStepIndex = -1;
                        _UpdateColors();
                        Invalidate();
                        _UpdateCurrentColor();
                        delete[] temp;
                }
        }

        if (fCurrentStepIndex != fDraggingStepIndex && fDraggingStepIndex >= 0) {
                // start dragging this stop
                fCurrentStepIndex = fDraggingStepIndex;
                Invalidate();
                _UpdateCurrentColor();
        }
}


void
GradientControl::MouseUp(BPoint where)
{
        fDraggingStepIndex = -1;
}


void
GradientControl::MouseMoved(BPoint where, uint32 transit, const BMessage* dragMessage)
{
        if (!fEnabled)
                return;

        float offset = _OffsetFor(where);

        if (fDraggingStepIndex >= 0) {
                BGradient::ColorStop* step = fGradient->ColorAt(fDraggingStepIndex);
                if (step) {
                        if (fGradient->SetOffset(fDraggingStepIndex, offset)) {
                                _UpdateColors();
                                Invalidate();
                        }
                }
        }
        int32 dropIndex = -1;
        float dropOffset = -1.0;
        if (dragMessage && (transit == B_INSIDE_VIEW || transit == B_ENTERED_VIEW)) {
                rgb_color dragColor;
                if (restore_color_from_message(dragMessage, dragColor, 0) >= B_OK) {
                        dropIndex = _StepIndexFor(where);
                        // fall back to inserting a color step if no direct hit on an existing step
                        if (dropIndex < 0)
                                dropOffset = offset;
                }
        }
        if (fDropOffset != dropOffset || fDropIndex != dropIndex) {
                fDropOffset = dropOffset;
                fDropIndex = dropIndex;
                Invalidate();
        }
}


void
GradientControl::MessageReceived(BMessage* message)
{
        switch (message->what) {
                case B_PASTE:
                        if (fEnabled) {
                                rgb_color color;
                                if (restore_color_from_message(message, color, 0) >= B_OK) {
                                        bool update = false;
                                        if (fDropIndex >= 0) {
                                                if (BGradient::ColorStop* step
                                                                = fGradient->ColorAt(fDropIndex)) {
                                                        color.alpha = step->color.alpha;
                                                }
                                                fGradient->SetColor(fDropIndex, color);
                                                fCurrentStepIndex = fDropIndex;
                                                fDropIndex = -1;
                                                update = true;
                                        } else if (fDropOffset >= 0.0) {
                                                fCurrentStepIndex = fGradient->AddColor(color,
                                                        fDropOffset);
                                                fDropOffset = -1.0;
                                                update = true;
                                        }
                                        if (update) {
                                                _UpdateColors();
                                                if (!IsFocus())
                                                        MakeFocus(true);
                                                else
                                                        Invalidate();
                                                _UpdateCurrentColor();
                                        }
                                }
                        }
                        break;
                default:
                        BView::MessageReceived(message);
        }
}


void
GradientControl::KeyDown(const char* bytes, int32 numBytes)
{
        bool handled = false;
        bool update = false;
        if (fEnabled) {
                if (numBytes > 0) {
                        handled = true;
                        int32 count = fGradient->CountColors();
                        switch (bytes[0]) {
                                case B_DELETE:
                                        // remove step
                                        update = fGradient->RemoveColor(fCurrentStepIndex);
                                        if (update) {
                                                fCurrentStepIndex = max_c(0, fCurrentStepIndex - 1);
                                                _UpdateCurrentColor();
                                        }
                                        break;

                                case B_HOME:
                                case B_END:
                                case B_LEFT_ARROW:
                                case B_RIGHT_ARROW: {
                                        if (BGradient::ColorStop* step
                                                        = fGradient->ColorAt(fCurrentStepIndex)) {
                                                BRect r = _GradientBitmapRect();
                                                float x = r.left + r.Width() * step->offset;
                                                switch (bytes[0]) {
                                                        case B_LEFT_ARROW:
                                                                // move step to the left
                                                                x = max_c(r.left, x - 1.0);
                                                                break;
                                                        case B_RIGHT_ARROW:
                                                                // move step to the right
                                                                x = min_c(r.right, x + 1.0);
                                                                break;
                                                        case B_HOME:
                                                                // move step to the start
                                                                x = r.left;
                                                                break;
                                                        case B_END:
                                                                // move step to the start
                                                                x = r.right;
                                                                break;
                                                }
                                                update = fGradient->SetOffset(fCurrentStepIndex,
                                                        (x - r.left) / r.Width());
                                        }
                                        break;
                                }

                                case B_UP_ARROW:
                                        // previous step
                                        fCurrentStepIndex--;
                                        if (fCurrentStepIndex < 0) {
                                                fCurrentStepIndex = count - 1;
                                        }
                                        _UpdateCurrentColor();
                                        break;
                                case B_DOWN_ARROW:
                                        // next step
                                        fCurrentStepIndex++;
                                        if (fCurrentStepIndex >= count) {
                                                fCurrentStepIndex = 0;
                                        }
                                        _UpdateCurrentColor();
                                        break;

                                default:
                                        handled = false;
                                        break;
                        }
                }
        }
        if (!handled)
                BView::KeyDown(bytes, numBytes);
        else {
                if (update)
                        _UpdateColors();
                Invalidate();
        }
}


void
GradientControl::Draw(BRect updateRect)
{
        BRect b = _GradientBitmapRect();
        b.InsetBy(-2.0, -2.0);
        // background
        // left of gradient rect
        BRect lb(updateRect.left, updateRect.top, b.left - 1, b.bottom);
        if (lb.IsValid())
                FillRect(lb, B_SOLID_LOW);
        // right of gradient rect
        BRect rb(b.right + 1, updateRect.top, updateRect.right, b.bottom);
        if (rb.IsValid())
                FillRect(rb, B_SOLID_LOW);
        // bottom of gradient rect
        BRect bb(updateRect.left, b.bottom + 1, updateRect.right, updateRect.bottom);
        if (bb.IsValid())
                FillRect(bb, B_SOLID_LOW);

        bool isFocus = IsFocus() && Window()->IsActive();

        rgb_color bg = LowColor();
        rgb_color black;
        rgb_color shadow;
        rgb_color darkShadow;
        rgb_color light;

        if (fEnabled) {
                shadow = tint_color(bg, B_DARKEN_1_TINT);
                darkShadow = tint_color(bg, B_DARKEN_3_TINT);
                light = tint_color(bg, B_LIGHTEN_MAX_TINT);
                black = tint_color(bg, B_DARKEN_MAX_TINT);
        } else {
                shadow = bg;
                darkShadow = tint_color(bg, B_DARKEN_1_TINT);
                light = tint_color(bg, B_LIGHTEN_2_TINT);
                black = tint_color(bg, B_DARKEN_2_TINT);
        }

        rgb_color focus = isFocus ? ui_color(B_KEYBOARD_NAVIGATION_COLOR) : black;

        uint32 flags = 0;

        if (be_control_look != NULL) {
                if (!fEnabled)
                        flags |= BControlLook::B_DISABLED;
                if (isFocus)
                        flags |= BControlLook::B_FOCUSED;
                be_control_look->DrawTextControlBorder(this, b, updateRect, bg, flags);
        } else {        
                stroke_frame(this, b, shadow, shadow, light, light);
                b.InsetBy(1.0, 1.0);
                if (isFocus)
                        stroke_frame(this, b, focus, focus, focus, focus);
                else
                        stroke_frame(this, b, darkShadow, darkShadow, bg, bg);
                b.InsetBy(1.0, 1.0);
        }

//      DrawBitmapAsync(fGradientBitmap, b.LeftTop());
//      Sync();
        DrawBitmap(fGradientBitmap, b.LeftTop());

        // show drop offset
        if (fDropOffset >= 0.0) {
                SetHighColor(255, 0, 0, 255);
                float x = b.left + b.Width() * fDropOffset;
                StrokeLine(BPoint(x, b.top), BPoint(x, b.bottom));
        }

        BPoint markerPos;
        markerPos.y = b.bottom + 4.0;
        BPoint leftBottom(-6.0, 6.0);
        BPoint rightBottom(6.0, 6.0);
        for (int32 i = 0; BGradient::ColorStop* step = fGradient->ColorAt(i);
                        i++) {
                markerPos.x = b.left + (b.Width() * step->offset);

                if (i == fCurrentStepIndex) {
                        SetLowColor(focus);
                        if (isFocus) {
                                StrokeLine(markerPos + leftBottom + BPoint(1.0, 4.0),
                                        markerPos + rightBottom + BPoint(-1.0, 4.0), B_SOLID_LOW);
                        }
                } else {
                        SetLowColor(black);
                }

                // override in case this is the drop index step
                if (i == fDropIndex)
                        SetLowColor(255, 0, 0, 255);

                if (be_control_look != NULL) {
                        // TODO: Drop indication!
                        BRect rect(markerPos.x + leftBottom.x, markerPos.y,
                                markerPos.x + rightBottom.x, markerPos.y + rightBottom.y);
                        be_control_look->DrawSliderTriangle(this, rect, updateRect, bg,
                                step->color, flags, B_HORIZONTAL);
                } else {
                        StrokeTriangle(markerPos, markerPos + leftBottom,
                                markerPos + rightBottom, B_SOLID_LOW);
                        if (fEnabled) {
                                SetHighColor(step->color);
                        } else {
                                rgb_color c = step->color;
                                c.red = (uint8)(((uint32)bg.red + (uint32)c.red) / 2);
                                c.green = (uint8)(((uint32)bg.green + (uint32)c.green) / 2);
                                c.blue = (uint8)(((uint32)bg.blue + (uint32)c.blue) / 2);
                                SetHighColor(c);
                        }
                        FillTriangle(markerPos + BPoint(0.0, 1.0),
                                                 markerPos + leftBottom + BPoint(1.0, 0.0),
                                                 markerPos + rightBottom + BPoint(-1.0, 0.0));
                        StrokeLine(markerPos + leftBottom + BPoint(0.0, 1.0),
                                           markerPos + rightBottom + BPoint(0.0, 1.0), B_SOLID_LOW);
                }
        }
}


void
GradientControl::FrameResized(float width, float height)
{
        BRect r = _GradientBitmapRect();
        _AllocBitmap(r.IntegerWidth() + 1, r.IntegerHeight() + 1);
        _UpdateColors();
        Invalidate();

}


void
GradientControl::GetPreferredSize(float* width, float* height)
{
        if (width != NULL)
                *width = 100;

        if (height != NULL)
                *height = 19;
}


void
GradientControl::SetGradient(const ::Gradient* gradient)
{
        if (!gradient)
                return;

        *fGradient = *gradient;
        _UpdateColors();

        fDropOffset = -1.0;
        fDropIndex = -1;
        fDraggingStepIndex = -1;
        if (fCurrentStepIndex > gradient->CountColors() - 1)
                fCurrentStepIndex = gradient->CountColors() - 1;

        Invalidate();
}


void
GradientControl::SetCurrentStop(const rgb_color& color)
{
        if (fEnabled && fCurrentStepIndex >= 0) {
                fGradient->SetColor(fCurrentStepIndex, color);
                _UpdateColors();
                Invalidate();
        }
}


bool
GradientControl::GetCurrentStop(rgb_color* color) const
{
        BGradient::ColorStop* stop
                = fGradient->ColorAt(fCurrentStepIndex);
        if (stop && color) {
                *color = stop->color;
                return true;
        }
        return false;
}


void
GradientControl::SetEnabled(bool enabled)
{
        if (enabled == fEnabled)
                return;

        fEnabled = enabled;

        if (!fEnabled)
                fDropIndex = -1;

        _UpdateColors();
        Invalidate();
}


inline void
blend_colors(uint8* d, uint8 alpha, uint8 c1, uint8 c2, uint8 c3)
{
        if (alpha > 0) {
                if (alpha == 255) {
                        d[0] = c1;
                        d[1] = c2;
                        d[2] = c3;
                } else {
                        d[0] += (uint8)(((c1 - d[0]) * alpha) >> 8);
                        d[1] += (uint8)(((c2 - d[1]) * alpha) >> 8);
                        d[2] += (uint8)(((c3 - d[2]) * alpha) >> 8);
                }
        }
}


void
GradientControl::_UpdateColors()
{
        if (!fGradientBitmap || !fGradientBitmap->IsValid())
                return;

        // fill in top row by gradient
        uint8* topRow = (uint8*)fGradientBitmap->Bits();
        uint32 width = fGradientBitmap->Bounds().IntegerWidth() + 1;
        fGradient->MakeGradient((uint32*)topRow, width);
        // flip colors, since they are the wrong endianess
        // make colors the disabled look
        // TODO: apply gamma lut
        uint8* p = topRow;
        if (!fEnabled) {
                rgb_color bg = LowColor();
                for (uint32 x = 0; x < width; x++) {
                        uint8 p0 = p[0];
                        p[0] = (uint8)(((uint32)bg.blue + (uint32)p[2]) / 2);
                        p[1] = (uint8)(((uint32)bg.green + (uint32)p[1]) / 2);
                        p[2] = (uint8)(((uint32)bg.red + (uint32)p0) / 2);
                        p += 4;
                }
        } else {
                for (uint32 x = 0; x < width; x++) {
                        uint8 p0 = p[0];
                        p[0] = p[2];
                        p[2] = p0;
                        p += 4;
                }
        }
        // copy top row to rest of bitmap
        uint32 height = fGradientBitmap->Bounds().IntegerHeight() + 1;
        uint32 bpr = fGradientBitmap->BytesPerRow();
        uint8* dstRow = topRow + bpr;
        for (uint32 i = 1; i < height; i++) {
                memcpy(dstRow, topRow, bpr);
                dstRow += bpr;
        }
        // post process bitmap to underlay it with a pattern
        // in order to make gradient steps with alpha more visible!
        uint8* row = topRow;
        for (uint32 i = 0; i < height; i++) {
                uint8* p = row;
                for (uint32 x = 0; x < width; x++) {
                        uint8 alpha = p[3];
                        if (alpha < 255) {
                                p[3] = 255;
                                alpha = 255 - alpha;
                                if (x % 8 >= 4) {
                                        if (i % 8 >= 4) {
                                                blend_colors(p, alpha,
                                                                         kAlphaLow.blue,
                                                                         kAlphaLow.green,
                                                                         kAlphaLow.red);
                                        } else {
                                                blend_colors(p, alpha,
                                                                         kAlphaHigh.blue,
                                                                         kAlphaHigh.green,
                                                                         kAlphaHigh.red);
                                        }
                                } else {
                                        if (i % 8 >= 4) {
                                                blend_colors(p, alpha,
                                                                         kAlphaHigh.blue,
                                                                         kAlphaHigh.green,
                                                                         kAlphaHigh.red);
                                        } else {
                                                blend_colors(p, alpha,
                                                                         kAlphaLow.blue,
                                                                         kAlphaLow.green,
                                                                         kAlphaLow.red);
                                        }
                                }
                        }
                        p += 4;
                }
                row += bpr;
        }
}


void
GradientControl::_AllocBitmap(int32 width, int32 height)
{
        if (width < 2 || height < 2)
                return;

        delete fGradientBitmap;
        fGradientBitmap = new BBitmap(BRect(0, 0, width - 1, height - 1), 0, B_RGB32);
}


BRect
GradientControl::_GradientBitmapRect() const
{
        BRect r = Bounds();
        r.left += 6.0;
        r.top += 2.0;
        r.right -= 6.0;
        r.bottom -= 14.0;
        return r;
}


int32
GradientControl::_StepIndexFor(BPoint where) const
{
        int32 index = -1;
        BRect r = _GradientBitmapRect();
        BRect markerFrame(Bounds());
        for (int32 i = 0; BGradient::ColorStop* step
                        = fGradient->ColorAt(i); i++) {
                markerFrame.left = markerFrame.right = r.left
                        + (r.Width() * step->offset);
                markerFrame.InsetBy(-6.0, 0.0);
                if (markerFrame.Contains(where)) {
                        index = i;
                        break;
                }
        }
        return index;
}


float
GradientControl::_OffsetFor(BPoint where) const
{
        BRect r = _GradientBitmapRect();
        float offset = (where.x - r.left) / r.Width();
        offset = max_c(0.0, offset);
        offset = min_c(1.0, offset);
        return offset;
}


void
GradientControl::_UpdateCurrentColor() const
{
        if (!fMessage || !fTarget || !fTarget->Looper())
                return;
        // set the CanvasView current color
        if (BGradient::ColorStop* step = fGradient->ColorAt(fCurrentStepIndex)) {
                BMessage message(*fMessage);
                store_color_in_message(&message, step->color);
                fTarget->Looper()->PostMessage(&message, fTarget);
        }
}