/*
 * Copyright 2014 Stephan Aßmus <superstippi@gmx.de>
 * All rights reserved. Distributed under the terms of the MIT license.
 */


#include <algorithm>
#include <stdio.h>
#include <string.h>

#include <Application.h>
#include <Bitmap.h>
#include <GradientLinear.h>
#include <Picture.h>
#include <Region.h>
#include <Resources.h>
#include <Roster.h>
#include <String.h>
#include <StringView.h>

#include "harness.h"

static const char* kAppSignature = "application/x-vnd.Haiku-Transformation";


class BitmapTest : public Test {
public:
        BitmapTest(const char* name)
                :
                Test(name),
                fBitmap(_LoadBitmap(555))
        {
        }

private:
        status_t
        _GetAppResources(BResources& resources) const
        {
                app_info info;
                status_t status = be_app->GetAppInfo(&info);
                if (status != B_OK)
                        return status;
        
                return resources.SetTo(&info.ref);
        }


        BBitmap* _LoadBitmap(int resourceID) const
        {
                BResources resources;
                status_t status = _GetAppResources(resources);
                if (status != B_OK)
                        return NULL;
        
                size_t dataSize;
                const void* data = resources.LoadResource(B_MESSAGE_TYPE, resourceID,
                        &dataSize);
                if (data == NULL)
                        return NULL;

                BMemoryIO stream(data, dataSize);

                // Try to read as an archived bitmap.
                BMessage archive;
                status = archive.Unflatten(&stream);
                if (status != B_OK)
                        return NULL;

                BBitmap* bitmap = new BBitmap(&archive);

                status = bitmap->InitCheck();
                if (status != B_OK) {
                        delete bitmap;
                        bitmap = NULL;
                }

                return bitmap;
        }

protected:
        BBitmap*        fBitmap;
};


// #pragma mark - Test1


class RectsTest : public Test {
public:
        RectsTest()
                :
                Test("Rects")
        {
        }
        
        virtual void Draw(BView* view, BRect updateRect)
        {
                view->DrawString("Rects", BPoint(20, 30));

                view->SetDrawingMode(B_OP_ALPHA);
                view->SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_OVERLAY);

                BRect rect(view->Bounds());
                rect.OffsetTo(B_ORIGIN);

                rect.InsetBy(rect.Width() / 3, rect.Height() / 3);
                BPoint center(
                        rect.left + rect.Width() / 2,
                        rect.top + rect.Height() / 2);

                for (int32 i = 0; i < 360; i += 40) {
                        BAffineTransform transform;
                        transform.RotateBy(center, i * M_PI / 180.0);
                        view->SetTransform(transform);

                        view->SetHighColor(51, 151, 255, 20);
                        view->FillRect(rect);

                        view->SetHighColor(51, 255, 151, 180);
                        view->DrawString("Rect", center);
                }
        }
};


// #pragma mark - AlphaMaskBitmapTest


class AlphaMaskBitmapTest : public BitmapTest {
public:
        AlphaMaskBitmapTest()
                :
                BitmapTest("Alpha Masked Bitmap")
        {
        }

        virtual void Draw(BView* view, BRect updateRect)
        {
                BRect rect(view->Bounds());

                if (fBitmap == NULL) {
                        view->SetHighColor(255, 0, 0);
                        view->FillRect(rect);
                        view->SetHighColor(0, 0, 0);
                        view->DrawString("Failed to load the bitmap.", BPoint(20, 20));
                        return;
                }

                rect.left = (rect.Width() - fBitmap->Bounds().Width()) / 2;
                rect.top = (rect.Height() - fBitmap->Bounds().Height()) / 2;
                rect.right = rect.left + fBitmap->Bounds().Width();
                rect.bottom = rect.top + fBitmap->Bounds().Height();

                BPoint center(
                        rect.left + rect.Width() / 2,
                        rect.top + rect.Height() / 2);

                BPicture picture;
                view->BeginPicture(&picture);
                view->SetDrawingMode(B_OP_ALPHA);
                view->SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_COMPOSITE);
                BFont font;
                view->GetFont(&font);
                font.SetSize(70);
                view->SetFont(&font);
                view->SetHighColor(0, 0, 0, 80);
                view->FillRect(view->Bounds());
                view->SetHighColor(0, 0, 0, 255);
                view->DrawString("CLIPPING", BPoint(0, center.y + 35));
                view->EndPicture();

                view->ClipToPicture(&picture);

                BAffineTransform transform;
                        transform.RotateBy(center, 30 * M_PI / 180.0);
                        view->SetTransform(transform);
        
                view->DrawBitmap(fBitmap, fBitmap->Bounds(), rect);
        }
};


// #pragma mark - Gradient


class GradientTest : public Test {
public:
        GradientTest()
                :
                Test("Gradient")
        {
        }
        
        virtual void Draw(BView* view, BRect updateRect)
        {
                BRect rect(view->Bounds());
                rect.InsetBy(rect.Width() / 3, rect.Height() / 3);
                BPoint center(
                        rect.left + rect.Width() / 2,
                        rect.top + rect.Height() / 2);

                BAffineTransform transform;
                transform.RotateBy(center, 30.0 * M_PI / 180.0);
                view->SetTransform(transform);

                rgb_color top = (rgb_color){ 255, 255, 0, 255 };
                rgb_color bottom = (rgb_color){ 0, 255, 255, 255 };

                BGradientLinear gradient;
                gradient.AddColor(top, 0.0f);
                gradient.AddColor(bottom, 255.0f);
                gradient.SetStart(rect.LeftTop());
                gradient.SetEnd(rect.LeftBottom());

                float radius = std::min(rect.Width() / 5, rect.Height() / 5);

                view->FillRoundRect(rect, radius, radius, gradient);
        }
};


// #pragma mark - NestedStates


class NestedStatesTest : public Test {
public:
        NestedStatesTest()
                :
                Test("Nested view states")
        {
        }
        
        virtual void Draw(BView* view, BRect updateRect)
        {
                BAffineTransform transform;
                transform.RotateBy(BPoint(100, 100), 30.0 * M_PI / 180.0);
                view->SetTransform(transform);

                rgb_color top = (rgb_color){ 255, 0, 0, 255 };
                rgb_color bottom = (rgb_color){ 255, 255, 0, 255 };

                BRect rect(20, 20, 120, 120);

                BGradientLinear gradient;
                gradient.AddColor(top, 0.0f);
                gradient.AddColor(bottom, 255.0f);
                gradient.SetStart(rect.LeftTop());
                gradient.SetEnd(rect.LeftBottom());

                view->FillRoundRect(rect, 20, 20, gradient);

                view->PushState();
                // Should be in the same place!
                view->StrokeRoundRect(rect, 20, 20);

                // Now rotated by another 30 degree
                view->SetTransform(transform);

                view->SetDrawingMode(B_OP_ALPHA);
                view->SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_COMPOSITE);
                view->SetHighColor(0, 0, 255, 120);
                view->FillRoundRect(rect, 20, 20);

                view->PopState();
        }
};


// #pragma mark - Clipping


class ClippingTest : public Test {
public:
        ClippingTest()
                :
                Test("View bounds clipping")
        {
        }

        virtual void Draw(BView* view, BRect updateRect)
        {
                BRect r (20, 20, 50, 50);
                view->SetHighColor(ui_color(B_FAILURE_COLOR));
                view->FillRect(r);

                BAffineTransform transform;
                transform.TranslateBy(400, 400);
                view->SetTransform(transform);

                // Make sure this rectangle is drawn, even when the original one is out
                // of the view bounds (for example because of scrolling).
                view->SetHighColor(ui_color(B_SUCCESS_COLOR));
                view->FillRect(r);
        }
};


// #pragma mark - Clipping


class TextClippingTest : public Test {
public:
        TextClippingTest()
                :
                Test("Text clipping")
        {
        }

        virtual void Draw(BView* view, BRect updateRect)
        {
                BFont font;
                view->GetFont(&font);
                font.SetSize(70);
                view->SetFont(&font);

                float width = view->Bounds().Width();

                // The translation make the text, which has negative coordinates, be
                // visible inside the viewport.
                BAffineTransform transform;
                transform.TranslateBy(width, 0);
                view->SetTransform(transform);

                const char* str = "CLIPPING";

                // Test the standard DrawString method

                // Draw the text bounds
                float size = view->StringWidth(str);
                BRect r(-width, 0, size - width, 70);
                view->SetHighColor(ui_color(B_SUCCESS_COLOR));
                view->FillRect(r);

                // Draw the text (which should fit inside the bounds rectangle)
                view->SetHighColor(0, 0, 0, 255);
                view->DrawString(str, BPoint(-width, 70));

                // Test with offset-based DrawString
                BPoint offsets[strlen(str)];
                for(unsigned int i = 0; i < strlen(str); i++)
                {
                        offsets[i].x = i * 35 - width;
                        offsets[i].y = 145;
                }

                // Draw the text bounds
                view->SetHighColor(ui_color(B_SUCCESS_COLOR));
                r = BRect(offsets[0], offsets[strlen(str) - 1]);
                r.top = 75;
                view->FillRect(r);

                // Draw the text (which should fit inside the bounds rectangle)
                view->SetHighColor(0, 0, 0, 255);
                view->DrawString(str, offsets, strlen(str));

        }
};


// #pragma mark - BitmapClipTest


class BitmapClipTest : public BitmapTest {
public:
        BitmapClipTest()
                :
                BitmapTest("Bitmap clipping")
        {
        }

        virtual void Draw(BView* view, BRect updateRect)
        {
                BRect rect(view->Bounds());

                if (fBitmap == NULL) {
                        view->SetHighColor(255, 0, 0);
                        view->FillRect(rect);
                        view->SetHighColor(0, 0, 0);
                        view->DrawString("Failed to load the bitmap.", BPoint(20, 20));
                        return;
                }

                rect = fBitmap->Bounds();

                view->SetHighColor(ui_color(B_FAILURE_COLOR));
                view->FillRect(rect);

                // The rect offset should compensate the transform translation, so the
                // bitmap should be drawn at the view origin. It will then exactly
                // cover the red rectangle, which should not be visible anymore.
                rect.OffsetBy(0, 40);

                BAffineTransform transform;
                        transform.TranslateBy(0, -40);
                view->SetTransform(transform);

                view->DrawBitmap(fBitmap, fBitmap->Bounds(), rect);
        }
};


// #pragma mark - PixelAlignTest


class PixelAlignTest : public Test {
public:
        PixelAlignTest()
                :
                Test("Pixel alignment")
        {
        }

        virtual void Draw(BView* view, BRect updateRect)
        {
                BRect rect(20, 20, 120, 120);
                view->SetHighColor(ui_color(B_SUCCESS_COLOR));
                view->StrokeRect(rect);

                BAffineTransform transform;
                        transform.TranslateBy(140, 0);
                view->SetTransform(transform);

                // Translating a pixel-aligned rectangle by an integer number of
                // pixels should result in a pixel-aligned rectangle.
                view->SetHighColor(ui_color(B_FAILURE_COLOR));
                view->StrokeRect(rect);
        }
};


// #pragma mark -


int
main(int argc, char** argv)
{
        BApplication app(kAppSignature);

        TestWindow* window = new TestWindow("Transformation tests");

        window->AddTest(new RectsTest());
        window->AddTest(new BitmapClipTest());
        window->AddTest(new TextClippingTest());
        window->AddTest(new AlphaMaskBitmapTest());
        window->AddTest(new GradientTest());
        window->AddTest(new NestedStatesTest());
        window->AddTest(new ClippingTest());
        window->AddTest(new PixelAlignTest());

        window->SetToTest(2);
        window->Show();

        app.Run();
        return 0;
}