// main.cpp

#include <stdio.h>

#include <Application.h>
#include <Bitmap.h>
#include <GraphicsDefs.h>
#include <Region.h>
#include <Window.h>

#include "BitmapView.h"
#include "BitmapBuffer.h"
#include "FontManager.h"
#include "Painter.h"

const pattern kStripes = (pattern){ { 0xc7, 0x8f, 0x1f, 0x3e, 0x7c, 0xf8, 0xf1, 0xe3 } };
const pattern kDotted = (pattern){ { 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa } };
const pattern kDottedBigger = (pattern){ { 0x33, 0x33, 0xcc, 0xcc, 0x33, 0x33, 0xcc, 0xcc } };

// test_straight_lines
template<class Surface>
bigtime_t
test_straight_lines(Surface& s, uint32 width, uint32 height)
{
        bigtime_t now = system_time();

        s.SetPenSize(1.0);
        s.SetDrawingMode(B_OP_COPY);
        s.SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_OVERLAY);

        s.SetHighColor(0, 0, 0, 255);
        s.SetLowColor(130, 0, 20, 255);

        const pattern pat = B_SOLID_HIGH;

        for (uint32 y = 0; y <= height; y += 5) {
                s.StrokeLine(BPoint(0, y), BPoint(width - 1, y), pat);
        }
        for (uint32 x = 0; x <= width; x += 5) {
                s.StrokeLine(BPoint(x, 0), BPoint(x, height - 1), pat);
        }

        s.Sync();

        return system_time() - now;     
}

// test_fill_rect
template<class Surface>
bigtime_t
test_fill_rect(Surface& s, uint32 width, uint32 height)
{
        bigtime_t now = system_time();

        s.SetPenSize(1.0);
        s.SetDrawingMode(B_OP_COPY);
        s.SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_OVERLAY);

        s.SetHighColor(0, 0, 0, 255);
        s.SetLowColor(130, 0, 20, 255);

        const pattern pat = B_SOLID_HIGH;

        BRect r;
        for (uint32 y = 10; y <= height; y += 20) {
                for (uint32 x = 10; x <= width; x += 20) {
                        r.Set(x - 9, y - 9, x + 9, y + 9);
                        s.FillRect(r, pat);
                }
        }

        s.Sync();

        return system_time() - now;     
}

// test_ellipses
template<class Surface>
bigtime_t
test_ellipses(Surface& s, uint32 width, uint32 height)
{
        bigtime_t now = system_time();

        s.SetPenSize(2.0);
        s.SetDrawingMode(B_OP_COPY);
        s.SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_OVERLAY);

        s.SetHighColor(0, 0, 0, 255);
        s.SetLowColor(130, 0, 20, 255);

        const pattern pat = B_SOLID_HIGH;

        BPoint center(floorf(width / 2.0), floorf(height / 2.0));
        float xRadius = width / 2.0;
        float yRadius = height / 2.0;

        uint32 count = 40;
        for (uint32 i = 0; i < count; i ++) {
                s.StrokeEllipse(center, xRadius * (i / (float)count),
                                                                yRadius * (i / (float)count), pat);
        }

        s.Sync();

        return system_time() - now;     
}

// test_lines
template<class Surface>
bigtime_t
test_lines(Surface& s, uint32 width, uint32 height)
{
        bigtime_t now = system_time();

        s.SetPenSize(1.0);
        s.SetDrawingMode(B_OP_COPY);
        s.SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_OVERLAY);

        s.SetHighColor(0, 0, 0, 255);
        s.SetLowColor(130, 0, 20, 255);

        const pattern pat = B_SOLID_HIGH;

        for (uint32 y = 0; y <= height; y += 10) {
                s.StrokeLine(BPoint(0, 0), BPoint(width, y), pat);
                s.StrokeLine(BPoint(width - 1, 0), BPoint(0, y), pat);
        }
        for (uint32 x = 0; x <= width; x += 10) {
                s.StrokeLine(BPoint(0, 0), BPoint(x, height), pat);
                s.StrokeLine(BPoint(width - 1, 0), BPoint(x, height), pat);
        }

        s.Sync();

        return system_time() - now;     
}

// test
template<class Surface>
bigtime_t
test(Surface& s, uint32 width, uint32 height, BBitmap* testBitmap)
{
        bigtime_t now = system_time();

// TODO: Painter behaves differently when origin has subpixel offset
//      BPoint origin(20.3, 10.8);
        BPoint origin(20, 10);
        
        BPoint center(width / 2.0, height / 2.0);
        float xRadius = 30.0;
        float yRadius = 20.0;

        s.SetOrigin(origin);
        s.SetScale(1.0);

        s.SetDrawingMode(B_OP_COPY);
//      s.SetDrawingMode(B_OP_SUBTRACT);
//      s.SetDrawingMode(B_OP_OVER);
        s.SetHighColor(20, 20, 20, 255);
        s.SetLowColor(220, 120, 80, 255);
        for (uint32 y = 0; y <= height / 2; y += 10) 
                s.StrokeLine(BPoint(0, 0), BPoint(width / 2, y)/*, kDottedBigger*/);
        for (uint32 x = 0; x <= width; x += 10)
                s.StrokeLine(BPoint(0, 0), BPoint(x, height)/*, kDottedBigger*/);
        s.SetPenSize(1.0 * 5);
        s.SetHighColor(255, 0, 0, 255);
        s.SetLowColor(0, 0, 255, 255);
//      s.SetScale(1.0);
//      s.SetOrigin(B_ORIGIN);
//      s.SetDrawingMode(B_OP_INVERT);
        s.SetDrawingMode(B_OP_COPY);
//      s.StrokeRect(BRect(20.2, 45.6, 219.0, 139.0));
        s.StrokeRect(BRect(20.2, 45.6, 219.0, 139.0), kStripes);

//      s.ConstrainClipping(noClip);
/*      s.SetPenLocation(BPoint(230.0, 30.0));
        s.StrokeLine(BPoint(250.0, 30.0));
        s.StrokeLine(BPoint(250.0, 50.0));
        s.StrokeLine(BPoint(230.0, 50.0));
        s.StrokeLine(BPoint(230.0, 30.0));*/

        s.SetHighColor(255, 255, 0, 255);
        s.SetLowColor(128, 0, 50, 255);
//      s.SetDrawingMode(B_OP_OVER);
        s.SetDrawingMode(B_OP_ERASE);
        s.StrokeEllipse(center, xRadius, yRadius, kDottedBigger);
        s.SetHighColor(255, 0, 0, 255);
        s.SetDrawingMode(B_OP_INVERT);
        s.FillArc(center, xRadius * 2, yRadius * 2, 40.0, 230.0);
//      s.StrokeArc(center, xRadius * 2, yRadius * 2, 40.0, 230.0);
        s.SetDrawingMode(B_OP_OVER);
        s.SetPenSize(2.0);
        s.StrokeEllipse(center, xRadius * 3, yRadius * 2);
//      s.FillEllipse(center, xRadius * 3, yRadius * 2);
//      s.StrokeLine(bounds.RightTop());
//      s.FillRect(rect);
        s.SetHighColor(0, 0, 255, 255);
        s.SetLowColor(255, 0, 0, 255);
        s.SetPenSize(1.0);
//      s.SetDrawingMode(B_OP_SELECT);
        s.StrokeRoundRect(BRect(40, 100, 250, 220.0), 40, 40);
//      s.FillRoundRect(BRect(40, 100, 250, 220.0), 40, 40);

        // text rendering
        const char* string1 = "The Quick Brown Fox...";
        const char* string2 = "jumps!";
        BPoint stringLocation1(10.0, 220.0);
        BPoint stringLocation2(30.0 / 2.5, 115.0 / 2.5);

        BFont font(be_plain_font);
        font.SetSize(12.0);
        font.SetRotation(8.0);
//      font.SetFamilyAndStyle(1);

        s.SetFont(&font);
        s.SetHighColor(91, 105, 98, 120);
        s.SetDrawingMode(B_OP_OVER);
        s.DrawString(string1, stringLocation1);
        s.DrawString(string2);
        s.StrokeLine(BPoint(width - 1, 0));

//      s.SetScale(2.5);
        s.SetDrawingMode(B_OP_INVERT);
        s.SetHighColor(200, 200, 200, 255);
        s.DrawString("H", stringLocation2);
        s.DrawString("e");
        s.DrawString("l");
        s.DrawString("l");
        s.DrawString("o");
        s.DrawString(" ");
        s.DrawString("N");
        s.DrawString("u");
        s.DrawString("r");
        s.DrawString("s");
        s.DrawString("e");
        s.DrawString("!");
        // do the char locations match up?
//      s.SetHighColor(0, 60, 240);
//      s.DrawString("Hello Nurse!", stringLocation2);

        // bitmap drawing
        BRect testBitmapCrop(testBitmap->Bounds());
        testBitmapCrop.left += 20.0;
        BRect testBitmapDestRect(testBitmapCrop);
        testBitmapDestRect.OffsetBy(50, 20);

        s.SetScale(1.5);
        s.SetDrawingMode(B_OP_ALPHA);
        s.SetHighColor(0, 0, 0, 120);
        s.DrawBitmap(testBitmap, testBitmapCrop, testBitmapDestRect);

        s.Sync();

        return system_time() - now;
}



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

        // create the default instance of the FontManager
        // It takes a bit to scan through the font files;
        // "true" means to do the font scanning inline, not
        // in a separate thread.
        fprintf(stdout, "scanning font files...");
        fflush(stdout);
        FontManager::CreateDefault(true);
        fprintf(stdout, "done\n");

        BRect bounds(0.0, 0.0, 319.0, 239.0);

        // test the clipping
        BRegion noClip(bounds);

        int32 clipCount = 5;
        BRegion clip;
        float h = bounds.Width() / clipCount;
        float v = bounds.Height() / clipCount;
        float hInset = (h / 2.0) * 0.5;
        float vInset = (v / 2.0) * 0.5;
        for (int32 i = 0; i < clipCount; i++) {
/*              BRect b(h * i, bounds.top, h * i, bounds.bottom);
                b.InsetBy(-hInset, 0.0);
                clip.Include(b);
                b.Set(bounds.left, v * i, bounds.right, v * i);
                b.InsetBy(0.0, -vInset);
                clip.Include(b);*/
                BRect b(bounds.left, v * i, bounds.right, v * i);
                b.InsetBy(0.0, -vInset);
                clip.Include(b);
                b.Set(h * i, bounds.top, h * i, bounds.bottom);
                b.InsetBy(-hInset, 0.0);
                clip.Include(b);
        }

        // prepare a test bitmap for bitmap rendering
        BBitmap* testBitmap = new BBitmap(BRect(20, 0, 150, 50), 0, B_RGB32);
        // fill testBitmap with content
        uint8* bits = (uint8*)testBitmap->Bits();
        uint32 bitmapWidth = testBitmap->Bounds().IntegerWidth() + 1;
        uint32 bitmapHeight = testBitmap->Bounds().IntegerHeight() + 1;
        uint32 bpr = testBitmap->BytesPerRow();
        for (uint32 y = 0; y < bitmapHeight; y++) {
                uint8* h = bits;
                for (uint32 x = 0; x < bitmapWidth; x++) {
                        h[0] = (uint8)((float)x / (float)bitmapWidth * 255.0);
                        h[1] = (uint8)((float)y / (float)bitmapHeight * 255.0);
                        h[2] = 255 - (uint8)((float)y / (float)bitmapHeight * 255.0);
                        h[3] = (uint8)((float)y / (float)bitmapHeight * 255.0);
                        h += 4;
                }
                bits += bpr;
        }
        // make corners a black pixel for testing
        bits = (uint8*)testBitmap->Bits();
        *(uint32*)(&bits[0]) = 0;
        *(uint32*)(&bits[(bitmapWidth - 1) * 4]) = 0;
        *(uint32*)(&bits[(bitmapHeight - 1) * bpr]) = 0;
        *(uint32*)(&bits[(bitmapHeight - 1) * bpr + (bitmapWidth - 1) * 4]) = 0;

        // create a frame buffer
        BBitmap* bitmap = new BBitmap(bounds, B_RGB32);
//memset(bitmap->Bits(), 0, bitmap->BitsLength());
        BitmapBuffer* buffer = new BitmapBuffer(bitmap);
        Painter painter;
        painter.AttachToBuffer(buffer);

        uint32 width = buffer->Width();
        uint32 height = buffer->Height();

//      painter.ConstrainClipping(clip);

        int32 iterations = 40;

        fprintf(stdout, "Painter...");
        fflush(stdout);

        bigtime_t painterNow = 0;
        for (int32 i = 0; i < iterations; i++) {
                // reset bitmap contents
                memset(bitmap->Bits(), 255, bitmap->BitsLength());
                // run test
//              painterNow += test(painter, width, height, testBitmap);
//              painterNow += test_lines(painter, width, height);
//              painterNow += test_straight_lines(painter, width, height);
                painterNow += test_fill_rect(painter, width, height);
//              painterNow += test_ellipses(painter, width, height);
        }

fprintf(stdout, " %lld µsecs\n", painterNow / iterations);

        BitmapView* painterView = new BitmapView(bounds, "view", bitmap);

        bitmap = new BBitmap(bounds, B_RGB32, true);
        BView* view = new BView(bounds, NULL, B_FOLLOW_NONE, B_WILL_DRAW);
//memset(bitmap->Bits(), 0, bitmap->BitsLength());
        bitmap->Lock();
        bitmap->AddChild(view);

//      view->ConstrainClippingRegion(&clip);

        fprintf(stdout, "BView...");
        fflush(stdout);

        bigtime_t viewNow = 0;
        for (int32 i = 0; i < iterations; i++) {
                // reset bitmap contents
                memset(bitmap->Bits(), 255, bitmap->BitsLength());
                // run test
//              viewNow += test(*view, width, height, testBitmap);
//              viewNow += test_lines(*view, width, height);
//              viewNow += test_straight_lines(*view, width, height);
                viewNow += test_fill_rect(*view, width, height);
//              viewNow += test_ellipses(*view, width, height);
        }

        bitmap->Unlock();

        fprintf(stdout, " %lld µsecs\n", viewNow / iterations);
        
        if (painterNow > viewNow)
                printf("BView is %.2f times faster.\n", (float)painterNow / (float)viewNow);
        else
                printf("Painter is %.2f times faster.\n", (float)viewNow / (float)painterNow);


        BitmapView* bViewView = new BitmapView(bounds, "view", bitmap);
        bViewView->MoveTo(BPoint(bounds.left, bounds.bottom + 1));

        BWindow* window = new BWindow(BRect(50.0, 50.0, 50.0 + bounds.Width(), 50.0 + bounds.Height() * 2 + 1), "Painter Test",
                                                                  B_TITLED_WINDOW,
                                                                  B_ASYNCHRONOUS_CONTROLS | B_QUIT_ON_WINDOW_CLOSE);

        window->AddChild(painterView);
        window->AddChild(bViewView);

        window->Show();
        app->Run();
        delete app;
        return 0;
}