/*
 * Copyright 2019, Haiku, Inc.
 * Distributed under the terms of the MIT License.
 *
 * Author:
 *              Preetpal Kaur <preetpalok123@gmail.com>
 */


#include "MouseView.h"

#include <algorithm>

#include <Box.h>
#include <Button.h>
#include <Debug.h>
#include <GradientLinear.h>
#include <GradientRadial.h>
#include <MenuField.h>
#include <MenuItem.h>
#include <PopUpMenu.h>
#include <Region.h>
#include <Shape.h>
#include <Slider.h>
#include <TextControl.h>
#include <TranslationUtils.h>
#include <TranslatorFormats.h>
#include <Window.h>

#include "InputConstants.h"
#include "MouseSettings.h"


static const int32 kButtonTop = 3;
static const int32 kMouseDownWidth = 72;
static const int32 kMouseDownHeight = 35;

#define W kMouseDownWidth / 100
static const int32 kButtonOffsets[][7] = {
        { 0, 100 * W },
        { 0, 50 * W, 100 * W },
        { 0, 35 * W, 65 * W, 100 * W },
        { 0, 25 * W, 50 * W, 75 * W, 100 * W },
        { 0, 20 * W, 40 * W, 60 * W, 80 * W, 100 * W },
        { 0, 19 * W, 34 * W, 50 * W, 66 * W, 82 * W, 100 * W }
};
#undef W

static const rgb_color kButtonTextColor = {0, 0, 0, 255};
static const rgb_color kMouseShadowColor = {100, 100, 100, 128};
static const rgb_color kMouseBodyTopColor = {0xed, 0xed, 0xed, 255};
static const rgb_color kMouseBodyBottomColor = {0x85, 0x85, 0x85, 255};
static const rgb_color kMouseOutlineColor = {0x51, 0x51, 0x51, 255};
static const rgb_color kMouseButtonOutlineColor = {0xa0, 0xa0, 0xa0, 255};
static const rgb_color kButtonPressedColor = {110, 110, 110, 110};


static const int32*
getButtonOffsets(int32 type)
{
        if ((type - 1) >= (int32)B_COUNT_OF(kButtonOffsets))
                return kButtonOffsets[2];
        return kButtonOffsets[type - 1];
}


static uint32
getMappingNumber(uint32 mapping)
{
        if (mapping == 0)
                return 0;

        int i;
        for (i = 0; mapping != 1; i++)
                mapping >>= 1;

        return i;
}


MouseView::MouseView(const MouseSettings& settings)
        :
        BView("Mouse", B_PULSE_NEEDED | B_WILL_DRAW),
        fSettings(settings),
        fType(-1),
        fButtons(0),
        fOldButtons(0)
{
        SetEventMask(B_POINTER_EVENTS, B_NO_POINTER_HISTORY);
        fScaling = std::max(1.0f, be_plain_font->Size() / 7.0f);
}


MouseView::~MouseView()
{
}


void
MouseView::SetMouseType(int32 type)
{
        fType = type;
        Invalidate();
}


void
MouseView::MouseMapUpdated()
{
        Invalidate();
}


void
MouseView::UpdateFromSettings()
{
        if (fSettings.MouseType() > 6)
                debugger("Mouse type is invalid");
        SetMouseType(fSettings.MouseType());
}


void
MouseView::GetPreferredSize(float* _width, float* _height)
{
        if (_width != NULL)
                *_width = fScaling * (kMouseDownWidth + 2);
        if (_height != NULL)
                *_height = fScaling * 104;
}


void
MouseView::AttachedToWindow()
{
        AdoptParentColors();

        UpdateFromSettings();
        _CreateButtonsPicture();

        font_height fontHeight;
        GetFontHeight(&fontHeight);
        fDigitHeight = int32(ceilf(fontHeight.ascent) + ceilf(fontHeight.descent));
        fDigitBaseline = int32(ceilf(fontHeight.ascent));
}


void
MouseView::MouseUp(BPoint)
{
        fButtons = 0;
        Invalidate(_ButtonsRect());
        fOldButtons = fButtons;
}


void
MouseView::MouseDown(BPoint where)
{
        BMessage* mouseMsg = Window()->CurrentMessage();
        fButtons = mouseMsg->FindInt32("buttons");
        int32 modifiers = mouseMsg->FindInt32("modifiers");
        if (modifiers & B_CONTROL_KEY) {
                if (modifiers & B_COMMAND_KEY)
                        fButtons = B_TERTIARY_MOUSE_BUTTON;
                else
                        fButtons = B_SECONDARY_MOUSE_BUTTON;
        }
        // Get the current clipping region before requesting any updates.
        // Otherwise those parts would be excluded from the region.
        BRegion clipping;
        GetClippingRegion(&clipping);

        if (fOldButtons != fButtons) {
                Invalidate(_ButtonsRect());
                fOldButtons = fButtons;
        }

        const int32* offset = getButtonOffsets(fType);
        int32 button = -1;
        for (int32 i = 0; i <= fType; i++) {
                if (_ButtonRect(offset, i).Contains(where)) {
                        button = i;
                        break;
                }
        }
        if (button < 0)
                return;

        if (clipping.Contains(where)) {
                button = _ConvertFromVisualOrder(button);

                BPopUpMenu menu("Mouse Map Menu");
                BMessage message(kMsgMouseMap);
                message.AddInt32("button", button);

                for (int i = 1; i < 7; i++) {
                        char tmp[2];
                        sprintf(tmp, "%d", i);
                        menu.AddItem(new BMenuItem(tmp, new BMessage(message)));
                }

                int32 mapping = fSettings.Mapping(button);
                BMenuItem* item = menu.ItemAt(getMappingNumber(mapping));
                if (item)
                        item->SetMarked(true);
                menu.SetTargetForItems(Window());

                ConvertToScreen(&where);
                menu.Go(where, true);
        }
}


void
MouseView::Draw(BRect updateFrame)
{
        SetDrawingMode(B_OP_ALPHA);
        SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_OVERLAY);
        SetScale(fScaling * 1.8);

        BShape mouseShape;
        mouseShape.MoveTo(BPoint(16, 12));
        // left
        BPoint control[3] = {BPoint(12, 16), BPoint(8, 64), BPoint(32, 64)};
        mouseShape.BezierTo(control);
        // right
        BPoint control2[3] = {BPoint(56, 64), BPoint(52, 16), BPoint(48, 12)};
        mouseShape.BezierTo(control2);
        // top
        BPoint control3[3] = {BPoint(44, 8), BPoint(20, 8), BPoint(16, 12)};
        mouseShape.BezierTo(control3);
        mouseShape.Close();

        // Draw the shadow
        SetOrigin(-17 * fScaling, -11 * fScaling);
        SetHighColor(kMouseShadowColor);
        FillShape(&mouseShape, B_SOLID_HIGH);

        // Draw the body
        SetOrigin(-21 * fScaling, -14 * fScaling);
        BGradientRadial bodyGradient(28, 24, 128);
        bodyGradient.AddColor(kMouseBodyTopColor, 0);
        bodyGradient.AddColor(kMouseBodyBottomColor, 255);

        FillShape(&mouseShape, bodyGradient);

        // Draw the outline
        SetPenSize(1 / 1.8 / fScaling);
        SetDrawingMode(B_OP_OVER);
        SetHighColor(kMouseOutlineColor);

        StrokeShape(&mouseShape, B_SOLID_HIGH);

        // bottom button border
        BShape buttonsOutline;
        buttonsOutline.MoveTo(BPoint(13, 27));
        BPoint control4[] = {BPoint(18, 30), BPoint(46, 30), BPoint(51, 27)};
        buttonsOutline.BezierTo(control4);

        SetHighColor(kMouseButtonOutlineColor);
        StrokeShape(&buttonsOutline, B_SOLID_HIGH);

        SetScale(1);
        SetOrigin(0, 0);

        mouse_map map;
        fSettings.Mapping(map);

        SetDrawingMode(B_OP_OVER);

        // All button drawing is clipped to the outline of the buttons area,
        // simplifying the code below as it can overdraw things.
        ClipToPicture(&fButtonsPicture, B_ORIGIN, false);

        // Separator between the buttons
        const int32* offset = getButtonOffsets(fType);
        for (int32 i = 1; i < fType; i++) {
                BRect buttonRect = _ButtonRect(offset, i);
                StrokeLine(buttonRect.LeftTop(), buttonRect.LeftBottom());
        }

        for (int32 i = 0; i < fType; i++) {
                // draw mapping number centered over the button

                bool pressed = (fButtons & map.button[_ConvertFromVisualOrder(i)]) != 0;
                // is button currently pressed?
                if (pressed) {
                        SetDrawingMode(B_OP_ALPHA);
                        SetHighColor(kButtonPressedColor);
                        FillRect(_ButtonRect(offset, i));
                }

                BRect border(fScaling * (offset[i] + 1), fScaling * (kButtonTop + 5),
                        fScaling * offset[i + 1] - 1,
                        fScaling * (kButtonTop + kMouseDownHeight - 4));
                if (i == 0)
                        border.left += fScaling * 5;
                if (i == fType - 1)
                        border.right -= fScaling * 4;

                char label[2] = {0};
                int32 number = getMappingNumber(map.button[_ConvertFromVisualOrder(i)]);
                label[0] = number + '1';

                SetDrawingMode(B_OP_OVER);
                SetHighColor(kButtonTextColor);
                DrawString(label,
                        BPoint(border.left + (border.Width() - StringWidth(label)) / 2,
                                border.top + fDigitBaseline
                                        + (border.IntegerHeight() - fDigitHeight) / 2));
        }

        ClipToPicture(NULL);
}


BRect
MouseView::_ButtonsRect() const
{
        return BRect(0, fScaling * kButtonTop, fScaling * kMouseDownWidth,
                fScaling * (kButtonTop + kMouseDownHeight));
}


BRect
MouseView::_ButtonRect(const int32* offsets, int index) const
{
        return BRect(fScaling * offsets[index], fScaling * kButtonTop,
                fScaling * offsets[index + 1] - 1,
                fScaling * (kButtonTop + kMouseDownHeight));
}


/** The buttons on a mouse are normally 1 (left), 2 (right), 3 (middle) so
 * we need to reorder them */
int32
MouseView::_ConvertFromVisualOrder(int32 i)
{
        if (fType < 3)
                return i;

        switch (i) {
                case 0:
                        return 0;
                case 1:
                        return 2;
                case 2:
                        return 1;
                default:
                        return i;
        }
}


void
MouseView::_CreateButtonsPicture()
{
        BeginPicture(&fButtonsPicture);
        SetScale(1.8 * fScaling);
        SetOrigin(-21 * fScaling, -14 * fScaling);

        BShape mouseShape;
        mouseShape.MoveTo(BPoint(48, 12));
        // top
        BPoint control3[3] = {BPoint(44, 8), BPoint(20, 8), BPoint(16, 12)};
        mouseShape.BezierTo(control3);
        // left
        BPoint control[3] = {BPoint(12, 16), BPoint(13, 27), BPoint(13, 27)};
        mouseShape.BezierTo(control);
        // bottom
        BPoint control4[3] = {BPoint(18, 30), BPoint(46, 30), BPoint(51, 27)};
        mouseShape.BezierTo(control4);
        // right
        BPoint control2[3] = {BPoint(51, 27), BPoint(50, 14), BPoint(48, 12)};
        mouseShape.BezierTo(control2);

        mouseShape.Close();

        SetHighColor(255, 0, 0, 255);
        FillShape(&mouseShape, B_SOLID_HIGH);

        EndPicture();
        SetOrigin(0, 0);
        SetScale(1);
}