// main.cpp

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <Application.h>
#include <Bitmap.h>
#include <Button.h>
#include <Message.h>
#include <MessageRunner.h>
#include <Messenger.h>
#include <View.h>
#include <Window.h>

#include "bitmap.h"

enum {
        MSG_RESET       = 'rset',       
        MSG_TICK        = 'tick',
};

#define SPEED 2.0

// random_number_between
float
random_number_between(float v1, float v2)
{
        if (v1 < v2)
                return v1 + fmod(rand() / 1000.0, (v2 - v1));
        else if (v2 < v1)
                return v2 + fmod(rand() / 1000.0, (v1 - v2));
        return v1;
}

// TestView
class TestView : public BView {

 public:
                                        TestView(BRect frame, const char* name,
                                                         uint32 resizeFlags, uint32 flags);

        virtual void    AttachedToWindow();
        virtual void    MessageReceived(BMessage* message);

        virtual void    Draw(BRect updateRect);

        virtual void    MouseDown(BPoint where);
        virtual void    MouseUp(BPoint where);
        virtual void    MouseMoved(BPoint where, uint32 transit,
                                                           const BMessage* dragMessage);

 private:
                        void    _ResetRect();
                        void    _InvalidateBitmapRect(BRect r);
                        void    _DrawCross(BPoint where, rgb_color c);

        struct point {
                double x;
                double y;
                double direction_x;
                double direction_y;
                double velocity_x;
                double velocity_y;
        };
        struct color_cycle {
                uint8 value;
                double direction;
        };

                        void    _FillBitmap(point* polygon);
                        void    _InitPolygon(const BRect& b, point* polygon) const;
                        void    _InitColor(color_cycle* color) const;
                        void    _MorphPolygon(const BRect& b, point* polygon);
                        void    _MorphColor(color_cycle* color);

        BBitmap*                fBitmap;
        BView*                  fOffscreenView;
        BMessageRunner* fTicker;
        BRect                   fBitmapRect;

        enum {
                TRACKING_NONE = 0,

                TRACKING_LEFT,
                TRACKING_RIGHT,
                TRACKING_TOP,
                TRACKING_BOTTOM,

                TRACKING_LEFT_TOP,
                TRACKING_RIGHT_TOP,
                TRACKING_LEFT_BOTTOM,
                TRACKING_RIGHT_BOTTOM,

                TRACKING_ALL
        };

        uint32                  fTracking;
        BPoint                  fLastMousePos;

        point                   fPolygon[4];
        color_cycle             fColor[3];
};

// constructor
TestView::TestView(BRect frame, const char* name,
                                   uint32 resizeFlags, uint32 flags)
        : BView(frame, name, resizeFlags, flags),
//        fBitmap(new BBitmap(BRect(0, 0, kBitmapWidth - 1, kBitmapHeight -1), 0, kBitmapFormat)),
//        fBitmap(new BBitmap(BRect(0, 0, 32 - 1, 8 - 1), 0, B_CMAP8)),
//        fBitmap(new BBitmap(BRect(0, 0, 32 - 1, 8 - 1), 0, B_GRAY8)),
          fBitmap(new BBitmap(BRect(0, 0, 199, 99), B_RGB32, true)),
//        fBitmap(new BBitmap(BRect(0, 0, 639, 479), B_RGB32, true)),
//        fBitmap(new BBitmap(BRect(0, 0, 639, 479), B_CMAP8, true)),
//        fBitmap(new BBitmap(BRect(0, 0, 199, 99), B_CMAP8, true)),
//        fBitmap(new BBitmap(BRect(0, 0, 199, 99), B_GRAY8, true)),
          fOffscreenView(new BView(fBitmap->Bounds(), "Offscreen view",
                                                           B_FOLLOW_ALL, B_WILL_DRAW | B_SUBPIXEL_PRECISE)),
          fTicker(NULL),
          fBitmapRect(),
          fTracking(TRACKING_NONE),
          fLastMousePos(-1.0, -1.0)
{
        SetViewColor(B_TRANSPARENT_COLOR);
        SetLowColor(ui_color(B_PANEL_BACKGROUND_COLOR));
//      uint32 size = min_c((uint32)fBitmap->BitsLength(), sizeof(kBitmapBits));
//      memcpy(fBitmap->Bits(), kBitmapBits, size);
/*      uint8* bits = (uint8*)fBitmap->Bits();
        uint32 width = fBitmap->Bounds().IntegerWidth() + 1;
        uint32 height = fBitmap->Bounds().IntegerHeight() + 1;
        uint32 bpr = fBitmap->BytesPerRow();
printf("width: %ld, height: %ld, bpr: %ld\n", width, height, bpr);
        int32 index = 0;
        for (uint32 y = 0; y < height; y++) {
                uint8* h = bits;
                for (uint32 x = 0; x < width; x++) {
                        *h = index++;
                        h++;
                }
                bits += bpr;
        }
BRect a(0.0, 10.0, 20.0, 10.0);
BRect b(0.0, 10.0, 10.0, 30.0);
printf("Intersects: %d\n", a.Intersects(b));*/
        if (fBitmap->Lock()) {
                fBitmap->AddChild(fOffscreenView);
                fOffscreenView->SetBlendingMode(B_CONSTANT_ALPHA, B_ALPHA_COMPOSITE);
                fBitmap->Unlock();
        }

        srand((long int)system_time());
        _InitPolygon(fBitmap->Bounds(), fPolygon);
        _InitColor(fColor);

        _ResetRect();
}

// AttachedToWindow
void
TestView::AttachedToWindow()
{
        BMessenger mess(this, Window());
        BMessage msg(MSG_TICK);
        fTicker = new BMessageRunner(mess, &msg, 40000LL);
}

// MessageReceived
void
TestView::MessageReceived(BMessage* message)
{
        switch (message->what) {
                case MSG_RESET: {
                        BRect old = fBitmapRect;
                        _ResetRect();
                        _InvalidateBitmapRect(old | fBitmapRect);
                        break;
                }
                case MSG_TICK:
                        _MorphPolygon(fBitmap->Bounds(), fPolygon);
                        _MorphColor(fColor);
                        _FillBitmap(fPolygon);
                        Invalidate(fBitmapRect);
                        break;
                default:
                        BView::MessageReceived(message);
                        break;
        }
}

// Draw
void
TestView::Draw(BRect updateRect)
{
        SetDrawingMode(B_OP_ALPHA);
        DrawBitmap(fBitmap, fBitmap->Bounds(), fBitmapRect);

        SetDrawingMode(B_OP_COPY);
        // background arround bitmap
        BRect topOfBitmap(updateRect.left, updateRect.top, updateRect.right, fBitmapRect.top - 1);
        if (topOfBitmap.IsValid())
                FillRect(topOfBitmap, B_SOLID_LOW);

        BRect leftOfBitmap(updateRect.left, fBitmapRect.top, fBitmapRect.left - 1, fBitmapRect.bottom);
        if (leftOfBitmap.IsValid())
                FillRect(leftOfBitmap, B_SOLID_LOW);

        BRect rightOfBitmap(fBitmapRect.right + 1, fBitmapRect.top, updateRect.right, fBitmapRect.bottom);
        if (rightOfBitmap.IsValid())
                FillRect(rightOfBitmap, B_SOLID_LOW);

        BRect bottomOfBitmap(updateRect.left, fBitmapRect.bottom + 1, updateRect.right, updateRect.bottom);
        if (bottomOfBitmap.IsValid())
                FillRect(bottomOfBitmap, B_SOLID_LOW);

        // indicate the frame to see any errors in the drawing code
        rgb_color red = (rgb_color){ 255, 0, 0, 255 };
        _DrawCross(fBitmapRect.LeftTop() + BPoint(-1.0, -1.0), red);
        _DrawCross(fBitmapRect.RightTop() + BPoint(1.0, -1.0), red);
        _DrawCross(fBitmapRect.LeftBottom() + BPoint(-1.0, 1.0), red);
        _DrawCross(fBitmapRect.RightBottom() + BPoint(1.0, 1.0), red);

        // text
        SetDrawingMode(B_OP_ALPHA);
        const char* message = "Click and drag to move and resize the bitmap!";
        BPoint textPos(20.0, 30.0);
        SetHighColor(255, 255, 255, 180);
        DrawString(message, textPos);
        SetHighColor(0, 0, 0, 180);
        DrawString(message, textPos + BPoint(-1.0, -1.0));
}

// hit_test
bool
hit_test(BPoint where, BPoint p)
{
        BRect r(p, p);
        r.InsetBy(-5.0, -5.0);
        return r.Contains(where);
}

// hit_test
bool
hit_test(BPoint where, BPoint a, BPoint b)
{
        BRect r(a, b);
        if (a.x == b.x)
                r.InsetBy(-3.0, 0.0);
        else
                r.InsetBy(0.0, -3.0);
        return r.Contains(where);
}

// MouseDown
void
TestView::MouseDown(BPoint where)
{
        fTracking = TRACKING_NONE;

        // check if we hit a corner
        if (hit_test(where, fBitmapRect.LeftTop()))
                fTracking = TRACKING_LEFT_TOP;
        else if (hit_test(where, fBitmapRect.RightTop()))
                fTracking = TRACKING_RIGHT_TOP;
        else if (hit_test(where, fBitmapRect.LeftBottom()))
                fTracking = TRACKING_LEFT_BOTTOM;
        else if (hit_test(where, fBitmapRect.RightBottom()))
                fTracking = TRACKING_RIGHT_BOTTOM;
        // check if we hit a side
        else if (hit_test(where, fBitmapRect.LeftTop(), fBitmapRect.RightTop()))
                fTracking = TRACKING_TOP;
        else if (hit_test(where, fBitmapRect.LeftTop(), fBitmapRect.LeftBottom()))
                fTracking = TRACKING_LEFT;
        else if (hit_test(where, fBitmapRect.RightTop(), fBitmapRect.RightBottom()))
                fTracking = TRACKING_RIGHT;
        else if (hit_test(where, fBitmapRect.LeftBottom(), fBitmapRect.RightBottom()))
                fTracking = TRACKING_BOTTOM;
        // check if we hit inside the rect
        else if (fBitmapRect.Contains(where))
                fTracking = TRACKING_ALL;

        fLastMousePos = where;
}

// MouseUp
void
TestView::MouseUp(BPoint where)
{
        fTracking = TRACKING_NONE;
}

// MouseMoved
void
TestView::MouseMoved(BPoint where, uint32 transit,
                                         const BMessage* dragMessage)
{
        if (fTracking > TRACKING_NONE) {
                BRect old = fBitmapRect;
                BPoint offset = where - fLastMousePos;
                switch (fTracking) {
                        case TRACKING_LEFT_TOP:
                                fBitmapRect.Set(fBitmapRect.left + offset.x,
                                                                fBitmapRect.top + offset.y,
                                                                fBitmapRect.right,
                                                                fBitmapRect.bottom);
                                break;
                        case TRACKING_RIGHT_BOTTOM:
                                fBitmapRect.Set(fBitmapRect.left,
                                                                fBitmapRect.top,
                                                                fBitmapRect.right + offset.x,
                                                                fBitmapRect.bottom + offset.y);
                                break;
                        case TRACKING_LEFT_BOTTOM:
                                fBitmapRect.Set(fBitmapRect.left + offset.x,
                                                                fBitmapRect.top,
                                                                fBitmapRect.right,
                                                                fBitmapRect.bottom + offset.y);
                                break;
                        case TRACKING_RIGHT_TOP:
                                fBitmapRect.Set(fBitmapRect.left,
                                                                fBitmapRect.top + offset.y,
                                                                fBitmapRect.right + offset.x,
                                                                fBitmapRect.bottom);
                                break;
                        case TRACKING_LEFT:
                                fBitmapRect.Set(fBitmapRect.left + offset.x,
                                                                fBitmapRect.top,
                                                                fBitmapRect.right,
                                                                fBitmapRect.bottom);
                                break;
                        case TRACKING_TOP:
                                fBitmapRect.Set(fBitmapRect.left,
                                                                fBitmapRect.top + offset.y,
                                                                fBitmapRect.right,
                                                                fBitmapRect.bottom);
                                break;
                        case TRACKING_RIGHT:
                                fBitmapRect.Set(fBitmapRect.left,
                                                                fBitmapRect.top,
                                                                fBitmapRect.right + offset.x,
                                                                fBitmapRect.bottom);
                                break;
                        case TRACKING_BOTTOM:
                                fBitmapRect.Set(fBitmapRect.left,
                                                                fBitmapRect.top,
                                                                fBitmapRect.right,
                                                                fBitmapRect.bottom + offset.y);
                                break;
                        case TRACKING_ALL:
                        default:
                                fBitmapRect.OffsetBy(offset);
                                break;
                }
                fLastMousePos = where;
                if (old != fBitmapRect)
                        _InvalidateBitmapRect(old | fBitmapRect);
        }
}

// _ResetRect
void
TestView::_ResetRect()
{
        fBitmapRect = fBitmap->Bounds();
        fBitmapRect.OffsetBy(floorf((Bounds().Width() - fBitmapRect.Width()) / 2.0 + 0.5),
                                                 floorf((Bounds().Height() - fBitmapRect.Height()) / 2.0 + 0.5));
}

// _InvalidateBitmapRect
void
TestView::_InvalidateBitmapRect(BRect r)
{
        r.InsetBy(-4.0, -4.0);
        Invalidate(r);
}

// _DrawCross
void
TestView::_DrawCross(BPoint where, rgb_color c)
{
        BeginLineArray(4);
                AddLine(BPoint(where.x, where.y - 3),
                                BPoint(where.x, where.y - 1), c);
                AddLine(BPoint(where.x, where.y + 1),
                                BPoint(where.x, where.y + 3), c);
                AddLine(BPoint(where.x - 3, where.y),
                                BPoint(where.x - 1, where.y), c);
                AddLine(BPoint(where.x + 1, where.y),
                                BPoint(where.x + 3, where.y), c);
        EndLineArray();
}

// _FillBitmap
void
TestView::_FillBitmap(point* polygon)
{
        if (fBitmap->Lock()) {
                fOffscreenView->SetDrawingMode(B_OP_COPY);
                fOffscreenView->SetHighColor(0, 0, 0, 30);
                fOffscreenView->FillRect(fOffscreenView->Bounds());

                fOffscreenView->SetDrawingMode(B_OP_ALPHA);
                fOffscreenView->SetHighColor(fColor[0].value,
                                                                         fColor[1].value,
                                                                         fColor[2].value,
                                                                         30);
                fOffscreenView->SetPenSize(4);
                fOffscreenView->SetLineMode(B_BUTT_CAP, B_ROUND_JOIN);

                BPoint pointList[4];
                pointList[0].x = polygon[0].x;
                pointList[0].y = polygon[0].y;
                pointList[1].x = polygon[1].x;
                pointList[1].y = polygon[1].y;
                pointList[2].x = polygon[2].x;
                pointList[2].y = polygon[2].y;
                pointList[3].x = polygon[3].x;
                pointList[3].y = polygon[3].y;

                fOffscreenView->StrokePolygon(pointList, 4);

                fOffscreenView->Sync();
                fBitmap->Unlock();
        }
}

// _InitPolygon
void
TestView::_InitPolygon(const BRect& b, point* polygon) const
{
        polygon[0].x = b.left;
        polygon[0].y = b.top;
        polygon[0].direction_x = random_number_between(-SPEED, SPEED);
        polygon[0].direction_y = random_number_between(-SPEED, SPEED);
        polygon[0].velocity_x = 0.0;
        polygon[0].velocity_y = 0.0;
        polygon[1].x = b.right;
        polygon[1].y = b.top;
        polygon[1].direction_x = random_number_between(-SPEED, SPEED);
        polygon[1].direction_y = random_number_between(-SPEED, SPEED);
        polygon[1].velocity_x = 0.0;
        polygon[1].velocity_y = 0.0;
        polygon[2].x = b.right;
        polygon[2].y = b.bottom;
        polygon[2].direction_x = random_number_between(-SPEED, SPEED);
        polygon[2].direction_y = random_number_between(-SPEED, SPEED);
        polygon[2].velocity_x = 0.0;
        polygon[2].velocity_y = 0.0;
        polygon[3].x = b.left;
        polygon[3].y = b.bottom;
        polygon[3].direction_x = random_number_between(-SPEED, SPEED);
        polygon[3].direction_y = random_number_between(-SPEED, SPEED);
        polygon[3].velocity_x = 0.0;
        polygon[3].velocity_y = 0.0;
}

// _InitColor
void
TestView::_InitColor(color_cycle* color) const
{
        color[0].value = 0;
        color[0].direction = random_number_between(-SPEED * 4, SPEED * 4);
        color[1].value = 0;
        color[1].direction = random_number_between(-SPEED * 4, SPEED * 4);
        color[2].value = 0;
        color[2].direction = random_number_between(-SPEED * 4, SPEED * 4);
}

// morph
inline void
morph(double* value, double* direction, double* velocity, double min, double max)
{
        *value += *velocity;

        // flip direction if necessary
        if (*value < min && *direction < 0.0) {
                *direction = -*direction;
        } else if (*value > max && *direction > 0.0) {
                *direction = -*direction;
        }

        // accelerate velocity
        if (*direction < 0.0) {
                if (*velocity > *direction)
                        *velocity += *direction / 10.0;
                // truncate velocity
                if (*velocity < *direction)
                        *velocity = *direction;
        } else {
                if (*velocity < *direction)
                        *velocity += *direction / 10.0;
                // truncate velocity
                if (*velocity > *direction)
                        *velocity = *direction;
        }
}

// morph
inline void
morph(uint8* value, double* direction)
{
        int32 v = (int32)(*value + *direction);
        if (v < 0) {
                v = 0;
                *direction = -*direction;
        } else if (v > 255) {
                v = 255;
                *direction = -*direction;
        }
        *value = (uint8)v;
}

// _MorphPolygon
void
TestView::_MorphPolygon(const BRect& b, point* polygon)
{
        morph(&polygon[0].x, &polygon[0].direction_x, &polygon[0].velocity_x, b.left, b.right);
        morph(&polygon[1].x, &polygon[1].direction_x, &polygon[1].velocity_x, b.left, b.right);
        morph(&polygon[2].x, &polygon[2].direction_x, &polygon[2].velocity_x, b.left, b.right);
        morph(&polygon[3].x, &polygon[3].direction_x, &polygon[3].velocity_x, b.left, b.right);
        morph(&polygon[0].y, &polygon[0].direction_y, &polygon[0].velocity_y, b.top, b.bottom);
        morph(&polygon[1].y, &polygon[1].direction_y, &polygon[1].velocity_y, b.top, b.bottom);
        morph(&polygon[2].y, &polygon[2].direction_y, &polygon[2].velocity_y, b.top, b.bottom);
        morph(&polygon[3].y, &polygon[3].direction_y, &polygon[3].velocity_y, b.top, b.bottom);
}

// _MorphColor
void
TestView::_MorphColor(color_cycle* color)
{
        morph(&color[0].value, &color[0].direction);
        morph(&color[1].value, &color[1].direction);
        morph(&color[2].value, &color[2].direction);
}

// show_window
void
show_window(BRect frame, const char* name)
{
        BWindow* window = new BWindow(frame, name,
                                                                  B_TITLED_WINDOW,
                                                                  B_ASYNCHRONOUS_CONTROLS | B_QUIT_ON_WINDOW_CLOSE);

        BView* view = new TestView(window->Bounds(), "test", B_FOLLOW_ALL,
                                                           B_WILL_DRAW/* | B_FULL_UPDATE_ON_RESIZE*/);

        window->AddChild(view);
        BRect b(0.0, 0.0, 60.0, 15.0);
        b.OffsetTo(5.0, view->Bounds().bottom - (b.Height() + 15.0));
        BButton* control = new BButton(b, "button", "Reset", new BMessage(MSG_RESET),
                                                                   B_FOLLOW_LEFT | B_FOLLOW_BOTTOM);
        view->AddChild(control);
        control->SetTarget(view);
        control->SetViewUIColor(B_PANEL_BACKGROUND_COLOR);

        window->Show();
}

// main
int
main(int argc, char** argv)
{
        BApplication* app = new BApplication("application/x.vnd-Haiku.BitmapDrawing");

//      BRect frame(10.0, 30.0, 790.0, 590.0);
        BRect frame(10.0, 30.0, 330.0, 220.0);
        show_window(frame, "BitmapDrawing");

        app->Run();

        delete app;
        return 0;
}