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

#include "PerspectiveBox.h"

#include <stdio.h>

#include <agg_trans_affine.h>
#include <agg_math.h>

#include <View.h>

#include "CanvasView.h"
#include "StateView.h"
#include "support.h"
#include "PerspectiveBoxStates.h"
#include "PerspectiveCommand.h"
#include "PerspectiveTransformer.h"


#define INSET 8.0


using std::nothrow;
using namespace PerspectiveBoxStates;


PerspectiveBox::PerspectiveBox(CanvasView* view,
                PerspectiveTransformer* parent)
        :
        Manipulator(NULL),

        fLeftTop(parent->LeftTop()),
        fRightTop(parent->RightTop()),
        fLeftBottom(parent->LeftBottom()),
        fRightBottom(parent->RightBottom()),

        fCurrentCommand(NULL),
        fCurrentState(NULL),

        fDragging(false),
        fMousePos(-10000.0, -10000.0),
        fModifiers(0),

        fPreviousBox(LONG_MAX, LONG_MAX, LONG_MIN, LONG_MIN),

        fCanvasView(view),
        fPerspective(parent),

        fDragLTState(new DragCornerState(this, &fLeftTop)),
        fDragRTState(new DragCornerState(this, &fRightTop)),
        fDragLBState(new DragCornerState(this, &fLeftBottom)),
        fDragRBState(new DragCornerState(this, &fRightBottom))
{
}


PerspectiveBox::~PerspectiveBox()
{
        _NotifyDeleted();

        delete fCurrentCommand;
        delete fDragLTState;
        delete fDragRTState;
        delete fDragLBState;
        delete fDragRBState;
}


void
PerspectiveBox::Draw(BView* into, BRect updateRect)
{
        // convert to canvas view coordinates
        BPoint lt = fLeftTop;
        BPoint rt = fRightTop;
        BPoint lb = fLeftBottom;
        BPoint rb = fRightBottom;

        fCanvasView->ConvertFromCanvas(&lt);
        fCanvasView->ConvertFromCanvas(&rt);
        fCanvasView->ConvertFromCanvas(&lb);
        fCanvasView->ConvertFromCanvas(&rb);

        into->SetDrawingMode(B_OP_COPY);
        into->SetHighColor(255, 255, 255, 255);
        into->SetLowColor(0, 0, 0, 255);

        _StrokeBWLine(into, lt, rt);
        _StrokeBWLine(into, rt, rb);
        _StrokeBWLine(into, rb, lb);
        _StrokeBWLine(into, lb, lt);

        _StrokeBWPoint(into, lt, 0.0);
        _StrokeBWPoint(into, rt, 90.0);
        _StrokeBWPoint(into, rb, 180.0);
        _StrokeBWPoint(into, lb, 270.0);
}


// #pragma mark -


bool
PerspectiveBox::MouseDown(BPoint where)
{
        fCanvasView->FilterMouse(&where);
        fCanvasView->ConvertToCanvas(&where);

        fDragging = true;
        if (fCurrentState) {
                fCurrentState->SetOrigin(where);

                delete fCurrentCommand;
                fCurrentCommand = new (nothrow) PerspectiveCommand(this, fPerspective,
                        fPerspective->LeftTop(), fPerspective->RightTop(),
                        fPerspective->LeftBottom(), fPerspective->RightBottom());
        }

        return true;
}


void
PerspectiveBox::MouseMoved(BPoint where)
{
        fCanvasView->FilterMouse(&where);
        fCanvasView->ConvertToCanvas(&where);

        if (fMousePos != where) {
                fMousePos = where;
                if (fCurrentState) {
                        fCurrentState->DragTo(fMousePos, fModifiers);
                        fCurrentState->UpdateViewCursor(fCanvasView, fMousePos);
                }
        }
}


Command*
PerspectiveBox::MouseUp()
{
        fDragging = false;
        return FinishTransaction();
}


bool
PerspectiveBox::MouseOver(BPoint where)
{
        fCanvasView->ConvertToCanvas(&where);

        fMousePos = where;
        fCurrentState = _DragStateFor(where, fCanvasView->ZoomLevel());

        if (fCurrentState) {
                fCurrentState->UpdateViewCursor(fCanvasView, fMousePos);
                return true;
        }

        return false;
}


// #pragma mark -


BRect
PerspectiveBox::Bounds()
{
        // convert from canvas view coordinates
        BPoint lt = fLeftTop;
        BPoint rt = fRightTop;
        BPoint lb = fLeftBottom;
        BPoint rb = fRightBottom;

        fCanvasView->ConvertFromCanvas(&lt);
        fCanvasView->ConvertFromCanvas(&rt);
        fCanvasView->ConvertFromCanvas(&lb);
        fCanvasView->ConvertFromCanvas(&rb);

        BRect bounds;
        bounds.left = min4(lt.x, rt.x, lb.x, rb.x);
        bounds.top = min4(lt.y, rt.y, lb.y, rb.y);
        bounds.right = max4(lt.x, rt.x, lb.x, rb.x);
        bounds.bottom = max4(lt.y, rt.y, lb.y, rb.y);
        return bounds;
}


BRect
PerspectiveBox::TrackingBounds(BView* withinView)
{
        return withinView->Bounds();
}


// #pragma mark -


void
PerspectiveBox::ModifiersChanged(uint32 modifiers)
{
        fModifiers = modifiers;
        if (fDragging && fCurrentState) {
                fCurrentState->DragTo(fMousePos, fModifiers);
        }
}


bool
PerspectiveBox::UpdateCursor()
{
        if (fCurrentState) {
                fCurrentState->UpdateViewCursor(fCanvasView, fMousePos);
                return true;
        }
        return false;
}


// #pragma mark -


void
PerspectiveBox::AttachedToView(BView* view)
{
        view->Invalidate(Bounds().InsetByCopy(-INSET, -INSET));
}


void
PerspectiveBox::DetachedFromView(BView* view)
{
        view->Invalidate(Bounds().InsetByCopy(-INSET, -INSET));
}


// pragma mark -


void
PerspectiveBox::ObjectChanged(const Observable* object)
{
}


// pragma mark -


void
PerspectiveBox::TransformTo(
        BPoint leftTop, BPoint rightTop, BPoint leftBottom, BPoint rightBottom)
{
        if (fLeftTop == leftTop
                && fRightTop == rightTop
                && fLeftBottom == leftBottom
                && fRightBottom == rightBottom)
                return;

        fLeftTop = leftTop;
        fRightTop = rightTop;
        fLeftBottom = leftBottom;
        fRightBottom = rightBottom;

        Update();
}


void
PerspectiveBox::Update(bool deep)
{
        BRect r = Bounds();
        BRect dirty(r | fPreviousBox);
        dirty.InsetBy(-INSET, -INSET);
        fCanvasView->Invalidate(dirty);
        fPreviousBox = r;

        if (deep)
                fPerspective->TransformTo(fLeftTop, fRightTop, fLeftBottom, fRightBottom);
}


Command*
PerspectiveBox::FinishTransaction()
{
        Command* command = fCurrentCommand;
        if (fCurrentCommand) {
                fCurrentCommand->SetNewPerspective(
                        fPerspective->LeftTop(), fPerspective->RightTop(),
                        fPerspective->LeftBottom(), fPerspective->RightBottom());
                fCurrentCommand = NULL;
        }
        return command;
}


// #pragma mark -


bool
PerspectiveBox::AddListener(PerspectiveBoxListener* listener)
{
        if (listener && !fListeners.HasItem((void*)listener))
                return fListeners.AddItem((void*)listener);
        return false;
}


bool
PerspectiveBox::RemoveListener(PerspectiveBoxListener* listener)
{
        return fListeners.RemoveItem((void*)listener);
}


// #pragma mark -


void
PerspectiveBox::_NotifyDeleted() const
{
        BList listeners(fListeners);
        int32 count = listeners.CountItems();
        for (int32 i = 0; i < count; i++) {
                PerspectiveBoxListener* listener
                        = (PerspectiveBoxListener*)listeners.ItemAtFast(i);
                listener->PerspectiveBoxDeleted(this);
        }
}


//! where is expected in canvas view coordinates
DragState*
PerspectiveBox::_DragStateFor(BPoint where, float canvasZoom)
{
        DragState* state = NULL;

        // convert to canvas zoom level
        //
        // the conversion is necessary, because the "hot regions"
        // around a point should be the same size no matter what
        // zoom level the canvas is displayed at
        float inset = INSET / canvasZoom;

        // check if the cursor is over the corners
        float dLT = point_point_distance(fLeftTop, where);
        float dRT = point_point_distance(fRightTop, where);
        float dLB = point_point_distance(fLeftBottom, where);
        float dRB = point_point_distance(fRightBottom, where);
        float d = min4(dLT, dRT, dLB, dRB);
        if (d < inset) {
                if (d == dLT)
                        state = fDragLTState;
                else if (d == dRT)
                        state = fDragRTState;
                else if (d == dLB)
                        state = fDragLBState;
                else if (d == dRB)
                        state = fDragRBState;
        }

        return state;
}


void
PerspectiveBox::_StrokeBWLine(BView* into, BPoint from, BPoint to) const
{
        // find out how to offset the second line optimally
        BPoint offset(0.0, 0.0);
        // first, do we have a more horizontal line or a more vertical line?
        float xDiff = to.x - from.x;
        float yDiff = to.y - from.y;
        if (fabs(xDiff) > fabs(yDiff)) {
                // horizontal
                if (xDiff > 0.0) {
                        offset.y = -1.0;
                } else {
                        offset.y = 1.0;
                }
        } else {
                // vertical
                if (yDiff < 0.0) {
                        offset.x = -1.0;
                } else {
                        offset.x = 1.0;
                }
        }
        // stroke two lines in high and low color of the view
        into->StrokeLine(from, to, B_SOLID_LOW);
        from += offset;
        to += offset;
        into->StrokeLine(from, to, B_SOLID_HIGH);
}


void
PerspectiveBox::_StrokeBWPoint(BView* into, BPoint point, double angle) const
{
        double x = point.x;
        double y = point.y;

        double x1 = x;
        double y1 = y - 5.0;

        double x2 = x - 5.0;
        double y2 = y - 5.0;

        double x3 = x - 5.0;
        double y3 = y;

        agg::trans_affine m;

        double xOffset = -x;
        double yOffset = -y;

        agg::trans_affine_rotation r(angle * M_PI / 180.0);

        r.transform(&xOffset, &yOffset);
        xOffset = x + xOffset;
        yOffset = y + yOffset;

        m.multiply(r);
        m.multiply(agg::trans_affine_translation(xOffset, yOffset));

        m.transform(&x, &y);
        m.transform(&x1, &y1);
        m.transform(&x2, &y2);
        m.transform(&x3, &y3);

        BPoint p[4];
        p[0] = BPoint(x, y);
        p[1] = BPoint(x1, y1);
        p[2] = BPoint(x2, y2);
        p[3] = BPoint(x3, y3);

        into->FillPolygon(p, 4, B_SOLID_HIGH);

        into->StrokeLine(p[0], p[1], B_SOLID_LOW);
        into->StrokeLine(p[1], p[2], B_SOLID_LOW);
        into->StrokeLine(p[2], p[3], B_SOLID_LOW);
        into->StrokeLine(p[3], p[0], B_SOLID_LOW);
}