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

#include <Message.h>
#include <MessageQueue.h>
#include <MessageRunner.h>
#include <Messenger.h>
#include <Rect.h>
#include <String.h>

#include "WindowLayer.h"

#include "ClientLooper.h"

#define SLOW_DRAWING 0

#define SPEED 2.0

// random_number_between
static 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;
}

// init_polygon
static void
init_polygon(const BRect& b, point* polygon)
{
        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[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[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[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);
}

// morph
static inline void
morph(double* value, double* direction, double min, double max)
{
        *value += *direction;
        if (*value < min) {
                *value = min;
                *direction = -*direction;
        } else if (*value > max) {
                *value = max;
                *direction = -*direction;
        }
}

// morph_polygon
static inline void
morph_polygon(const BRect& b, point* polygon)
{
        morph(&polygon[0].x, &polygon[0].direction_x, b.left, b.right);
        morph(&polygon[1].x, &polygon[1].direction_x, b.left, b.right);
        morph(&polygon[2].x, &polygon[2].direction_x, b.left, b.right);
        morph(&polygon[3].x, &polygon[3].direction_x, b.left, b.right);
        morph(&polygon[0].y, &polygon[0].direction_y, b.top, b.bottom);
        morph(&polygon[1].y, &polygon[1].direction_y, b.top, b.bottom);
        morph(&polygon[2].y, &polygon[2].direction_y, b.top, b.bottom);
        morph(&polygon[3].y, &polygon[3].direction_y, b.top, b.bottom);
}



// constructor
ClientLooper::ClientLooper(const char* name, WindowLayer* serverWindow)
        : BLooper("", B_DISPLAY_PRIORITY),
          fServerWindow(serverWindow),
          fViewCount(0)
{
        BString clientName(name);
        clientName << " client";
        SetName(clientName.String());

        BMessenger messenger(this);
        fTicker = new BMessageRunner(messenger, new BMessage(MSG_TICK), 40000);

        init_polygon(BRect(0, 0, 100, 100), fPolygon);
}

// destructor
ClientLooper::~ClientLooper()
{
        delete fTicker;
}

// MessageReceived
void
ClientLooper::MessageReceived(BMessage* message)
{
        switch (message->what) {
                case MSG_UPDATE:

                        fServerWindow->PostMessage(MSG_BEGIN_UPDATE);

                        for (int32 i = 0; i < fViewCount; i++) {
                                // the client is slow
//                              snooze(40000L);
                                // send the command to redraw a view
                                if (i == 5) {
                                        _DrawAnimatedLayer(i);
                                } else {
                                        BMessage command(MSG_DRAWING_COMMAND);
                                        command.AddInt32("token", i);
                                        fServerWindow->PostMessage(&command);
                                }
                        }

                        fServerWindow->PostMessage(MSG_END_UPDATE);

                        break;
                case MSG_VIEWS_ADDED: {
                        int32 count;
                        if (message->FindInt32("count", &count) >= B_OK) {
                                fViewCount += count;
                        }
                        break;
                }
                case MSG_VIEWS_REMOVED: {
                        int32 count;
                        if (message->FindInt32("count", &count) >= B_OK)
                                fViewCount -= count;
                        break;
                }

                case MSG_WINDOW_HIDDEN:
                        // there is no way we're going to accept this
                        // discrimination for longer than 2 seconds!
                        snooze(2000000);
                        fServerWindow->PostMessage(MSG_SHOW);
                        break;

                case MSG_TICK: {
                        BMessage invalidate(MSG_INVALIDATE_VIEW);
                        invalidate.AddInt32("token", 5);
                        fServerWindow->PostMessage(&invalidate);

                        morph_polygon(BRect(0, 0, 100, 100), fPolygon);
                        break;
                }

                default:
                        BLooper::MessageReceived(message);
                        break;
        }
}

// _DrawAnimatedLayer
void
ClientLooper::_DrawAnimatedLayer(int32 token)
{
        BMessage message(MSG_DRAW_POLYGON);
        message.AddInt32("token", token);

        message.AddPoint("point", BPoint(fPolygon[0].x, fPolygon[0].y));
        message.AddPoint("point", BPoint(fPolygon[1].x, fPolygon[1].y));
        message.AddPoint("point", BPoint(fPolygon[2].x, fPolygon[2].y));
        message.AddPoint("point", BPoint(fPolygon[3].x, fPolygon[3].y));

        fServerWindow->PostMessage(&message);
}