/*
 * Copyright 2008-2011, Clemens Zeidler <haiku@clemens-zeidler.de>
 * Copyright 2022-2025, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Stephan Aßmus <superstippi@gmx.de>
 *              Augustin Cavalier <waddlesplash@gmail.com>
 *              Adrien Destugues <pulkomandy@pulkomandy.tk>
 *              Axel Dörfler <axeld@pinc-software.de>
 *              Fredrik Holmqvist <fredrik.holmqvist@gmail.com>
 *              Michael Kanis <mks@skweez.net>
 *              Sylvain Kerjean <sylvain_kerjean@hotmail.com>
 *              Murai Takashi <tmurai01@gmail.com>
 *              PawanYr <pawan.yerramilli@gmail.com>
 *              Samuel Rodríguez Pérez <samuelrp84@gmail.com>
 *              Clemens Zeidler <clemens.zeidler@googlemail.com>
 */

#include "movement_maker.h"

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

#include <util/BitUtils.h>

//#define TRACE_MOVEMENT_MAKER

#ifdef TRACE_MOVEMENT_MAKER
#       include <String.h>
#       include <headers/private/shared/FunctionTracer.h>

        static int32 sFunctionDepth = -1;
#       define CALLED(x...)     FunctionTracer _ft(debug_printf, this, __PRETTY_FUNCTION__, sFunctionDepth)
#       define TRACE(x...)      do { BString _to; \
                                                        _to.Append(' ', (sFunctionDepth + 1) * 2); \
                                                        char _extra[1024]; \
                                                        sprintf(_extra, x); \
                                                        debug_printf("%p -> %s%s", this, _to.String(), _extra); \
                                                } while (0)
#       define LOG_EVENT(text...) do {} while (0)
#       define LOG_ERROR(text...) TRACE(text)
#else
#       define TRACE(x...)
#       define CALLED(x...)
#       define LOG_ERROR(x...)  do { debug_printf(x); } while(0)
#       define LOG_EVENT(x...)
#endif


// magic constants
#define SYN_WIDTH                               (4100)
#define SYN_HEIGHT                              (3140)


static int32
make_small(float value)
{
        return (int32)truncf(value);
}

static inline bool
two_fingers(const touchpad_movement* event) {
        // TODO: Replace fingerWith related conditions when drivers are adjusted.
        // They seem to be taken from specifics of Synaptics device driver values
        // for w where 0 means 2 fingers and 1 is means 3 or more fingers.
        return count_set_bits(event->fingers) == 2
//              || event->nFingers == 2
                || event->fingerWidth == 0;
}


static inline bool
two_or_more_fingers(const touchpad_movement* event) {
        // TODO: Replace fingerWith related conditions when drivers are adjusted.
        // They seem to be taken from specifics of Synaptics device driver values
        // for w where 0 means 2 fingers and 1 is means 3 or more fingers.
        return count_set_bits(event->fingers) >= 2
//              || event->nFingers >= 2
                || event->fingerWidth == 0 || event->fingerWidth == 1;
}


static inline bool
three_fingers(const touchpad_movement* event) {
        // TODO: Replace fingerWith related conditions when drivers are adjusted.
        // They seem to be taken from specifics of Synaptics device driver values
        // for w where 0 means 2 fingers and 1 is means 3 or more fingers.
        return count_set_bits(event->fingers) == 3
//              || event->nFingers = 3
                || event->fingerWidth == 1; // This is 3 or more fingers for Synaptic
}


static inline bool
three_or_more_fingers(const touchpad_movement* event) {
        // TODO: Replace fingerWith related conditions when drivers are adjusted.
        // They seem to be taken from specifics of Synaptics device driver values
        // for w where 0 means 2 fingers and 1 is means 3 or more fingers.
        return count_set_bits(event->fingers) > 2
//              || event->nFingers > 2
                || event->fingerWidth == 1;
}


// #pragma mark -


void
MovementMaker::SetSettings(const touchpad_settings& settings)
{
        CALLED();

        fSettings = settings;
}


void
MovementMaker::SetSpecs(const touchpad_specs& specs)
{
        CALLED();

        fSpecs = specs;

        fAreaWidth = fSpecs.areaEndX - fSpecs.areaStartX;
        fAreaHeight = fSpecs.areaEndY - fSpecs.areaStartY;

        // calibrated on the synaptics touchpad
        fSpeed = SYN_WIDTH / fAreaWidth;
        fSmallMovement = 3 / fSpeed;
}


void
MovementMaker::StartNewMovment()
{
        CALLED();

        if (fSettings.scroll_xstepsize <= 0)
                fSettings.scroll_xstepsize = 1;
        if (fSettings.scroll_ystepsize <= 0)
                fSettings.scroll_ystepsize = 1;

        fMovementMakerStarted = true;
        scrolling_x = 0;
        scrolling_y = 0;
}


void
MovementMaker::GetMovement(uint32 posX, uint32 posY)
{
        CALLED();

        _GetRawMovement(posX, posY);
}


void
MovementMaker::GetScrolling(uint32 posX, uint32 posY, bool reverse)
{
        CALLED();

        int32 stepsX = 0, stepsY = 0;
        int32 directionMultiplier = reverse ? -1 : 1;

        _GetRawMovement(posX, posY);
        _ComputeAcceleration(fSettings.scroll_acceleration);

        if (fSettings.scroll_xstepsize > 0) {
                scrolling_x += directionMultiplier * xDelta;

                stepsX = make_small(scrolling_x / fSettings.scroll_xstepsize);

                scrolling_x -= stepsX * fSettings.scroll_xstepsize;
                xDelta = stepsX;
        } else {
                scrolling_x = 0;
                xDelta = 0;
        }

        if (fSettings.scroll_ystepsize > 0) {
                scrolling_y += directionMultiplier * yDelta;

                stepsY = make_small(scrolling_y / fSettings.scroll_ystepsize);

                scrolling_y -= stepsY * fSettings.scroll_ystepsize;
                yDelta = -1 * stepsY;
        } else {
                scrolling_y = 0;
                yDelta = 0;
        }
}


void
MovementMaker::_GetRawMovement(uint32 posX, uint32 posY)
{
        CALLED();

        // calibrated on the synaptics touchpad
        posX = posX * SYN_WIDTH / fAreaWidth;
        posY = posY * SYN_HEIGHT / fAreaHeight;

        const float acceleration = 0.8;
        const float translation = 12.0;

        int diff;

        if (fMovementMakerStarted) {
                fMovementMakerStarted = false;
                // init delta tracking
                fPreviousX = posX;
                fPreviousY = posY;
                // deltas are automatically reset
        }

        // accumulate delta and store current pos, reset if pos did not change
        diff = posX - fPreviousX;
        // lessen the effect of small diffs
        if ((diff > -fSmallMovement && diff < -1)
                || (diff > 1 && diff < fSmallMovement)) {
                diff /= 2;
        }
        if (diff == 0)
                fDeltaSumX = 0;
        else
                fDeltaSumX += diff;

        diff = posY - fPreviousY;
        // lessen the effect of small diffs
        if ((diff > -fSmallMovement && diff < -1)
                || (diff > 1 && diff < fSmallMovement)) {
                diff /= 2;
        }
        if (diff == 0)
                fDeltaSumY = 0;
        else
                fDeltaSumY += diff;

        fPreviousX = posX;
        fPreviousY = posY;

        // compute current delta and reset accumulated delta if
        // abs() is greater than 1
        xDelta = fDeltaSumX / translation;
        yDelta = fDeltaSumY / translation;
        if (xDelta > 1.0) {
                fDeltaSumX = 0.0;
                xDelta = 1.0 + (xDelta - 1.0) * acceleration;
        } else if (xDelta < -1.0) {
                fDeltaSumX = 0.0;
                xDelta = -1.0 + (xDelta + 1.0) * acceleration;
        }

        if (yDelta > 1.0) {
                fDeltaSumY = 0.0;
                yDelta = 1.0 + (yDelta - 1.0) * acceleration;
        } else if (yDelta < -1.0) {
                fDeltaSumY = 0.0;
                yDelta = -1.0 + (yDelta + 1.0) * acceleration;
        }

        xDelta = make_small(xDelta);
        yDelta = make_small(yDelta);
}


void
MovementMaker::_ComputeAcceleration(int8 accel_factor)
{
        CALLED();

        // acceleration
        float acceleration = 1;
        if (accel_factor != 0) {
                acceleration = 1 + sqrtf(xDelta * xDelta
                        + yDelta * yDelta) * accel_factor / 50.0;
        }

        xDelta = make_small(xDelta * acceleration);
        yDelta = make_small(yDelta * acceleration);
}


// #pragma mark -


#define fTapTimeOUT                     200000


TouchpadMovement::TouchpadMovement()
{
        CALLED();

        fMovementStarted = false;
        fScrollingStarted = false;
        fTapStarted = false;
        fValidEdgeMotion = false;
        fDoubleClick = false;
}

TouchpadMovement::~TouchpadMovement() {
        CALLED();
}


status_t
TouchpadMovement::EventToMovement(const touchpad_movement* _event, mouse_movement* movement,
        bigtime_t& repeatTimeout)
{
        CALLED();

        if (!movement)
                return B_ERROR;

        TRACE("TM_EVENT: b:0x%" B_PRIx8 " nf:%" B_PRId8 " f:0x%" B_PRIx8
                " x:%" B_PRIu32 " y:%" B_PRIu32 " p:%" B_PRIu8 " w:%" B_PRIu8 "\n",
                _event->buttons,
                count_set_bits(_event->fingers),
                _event->fingers,
                _event->xPosition,
                _event->yPosition,
                _event->zPressure,
                _event->fingerWidth
        );
        TRACE("TM_STATUS: b:0x%" B_PRIx8 " %c%c%c%c%c%c"
                " dx:%" B_PRId32 " dy:%" B_PRId32
                " tcks:%" B_PRId32 " cks:%" B_PRId32 "\n",
                fButtonsState,

                fMovementStarted        ? 'M' : 'm',
                fScrollingStarted       ? 'S' : 's',
                fTapStarted                     ? 'T' : 't',
                fTapdragStarted         ? 'D' : 'd',
                fValidEdgeMotion        ? 'E' : 'e',
                fDoubleClick            ? 'C' : 'c',

                fTapDeltaX,
                fTapDeltaY,
                fTapClicks,
                fClickCount
        );

        movement->xdelta = 0;
        movement->ydelta = 0;
        movement->buttons = 0;
        movement->wheel_ydelta = 0;
        movement->wheel_xdelta = 0;
        movement->modifiers = 0;
        movement->clicks = 0;
        movement->timestamp = system_time();

        touchpad_movement event2 = *_event;
        if (!_ClickFingerButtonEmulator(&event2))
                _SoftwareButtonAreas(&event2);
        const touchpad_movement* event = &event2;

        if ((movement->timestamp - fTapTime) > fTapTimeOUT) {
                if (fTapStarted)
                        TRACE("TouchpadMovement: tap gesture timed out\n");
                fTapStarted = false;
                if (!fDoubleClick
                        || (movement->timestamp - fTapTime) > 2 * fTapTimeOUT) {
                        fTapClicks = 0;
                }
        }

        if (event->buttons || two_or_more_fingers(event)) {
                fTapClicks = 0;
                fTapdragStarted = false;
                fTapStarted = false;
                if ((fSettings.edge_motion
                        & (B_EDGE_MOTION_ON_BUTTON_CLICK_MOVE | B_EDGE_MOTION_ON_BUTTON_CLICK_DRAG)) != 0)
                        fValidEdgeMotion = false;
        }

        if (event->zPressure >= fSpecs.minPressure
                && event->zPressure < fSpecs.maxPressure
                && ((event->fingerWidth >= 4 && event->fingerWidth <= 7)
                        || two_or_more_fingers(event))
                && (event->xPosition != 0 || event->yPosition != 0)) {
                // The touch pad is in touch with at least one finger
                if (!_CheckScrollingToMovement(event, movement))
                        _MoveToMovement(event, movement);
        } else
                _NoTouchToMovement(event, movement);


        if (fTapdragStarted || fValidEdgeMotion) {
                // We want the current event to be repeated in 50ms if no other
                // events occur in the interim.
                repeatTimeout = 1000 * 50;
        } else
                repeatTimeout = B_INFINITE_TIMEOUT;

        return B_OK;
}


bool
TouchpadMovement::_ClickFingerButtonEmulator(touchpad_movement *event) {
        CALLED();

        if (event->buttons != 0) {
                // ClickFinger behaviour.
                // Simulate with 2 fingers click => right button click
                // Simulate with 3 fingers click => middle button click
                if (fSettings.finger_click && two_fingers(event)) {
                        event->buttons = 2;
                        return true;
                } else if (fSettings.finger_click && three_fingers(event)) {
                        event->buttons = 4;
                        return true;
                }
        }

        return false;
}


void
TouchpadMovement::_SoftwareButtonAreas(touchpad_movement *event) {
        CALLED();

        // Software button areas.
        // - Emulation of button areas as clickpads do not have separated physical buttons from the one
        //   overlapping the touch area.
        // - Pretend the the same button is still pressed if the finger hasn't been released regardless
        //   of its current possition.
        // TODO:
        // - Implement top button area.
        // - Implement trackpoint emulator in an area.
        //   i.e.: small centered square on the top of the clickpad.
        // - Make the areas configurable from settings and Input preference app.
        //   i.e.: to allow switch left and right buttons, etc.
        if (event->buttons != 0) {
                if (fSettings.software_button_areas) {
                        if (fButtonsState == 0) {
                                uint32 evaluatePositionX = (event->xPosition == 0) ? fPreviousX : event->xPosition;
                                uint32 evaluatePositionY = (event->yPosition == 0) ? fPreviousY : event->yPosition;
                                if (evaluatePositionY > 0 && evaluatePositionY < (uint32) fSpecs.areaEndY / 5) {
                                        #if 0
                                        // 2 software buttons:
                                        // - Emulates right buttom hardcoded to half left side of the touchpad,
                                        //   otherwise left button.
                                        if (evaluatePositionX > (uint32) fSpecs.areaEndX / 2) {
                                                event->buttons = 2;
                                        } else {
                                                event->buttons = 1;
                                        }
                                        #else
                                        // 3 software buttons where the the middle button uses 1/6 of the area.
                                        if (evaluatePositionX > (uint32) fSpecs.areaEndX / 12 * 7) {
                                                event->buttons = 2;
                                        } else if (evaluatePositionX > (uint32) fSpecs.areaEndX / 12 * 5) {
                                                // Middle button area smaller than left and right buttons' area.
                                                event->buttons = 4;
                                        } else {
                                                event->buttons = 1;
                                        }
                                        #endif
                                }
                        } else {
                                event->buttons = fButtonsState;
                        }
                }
        }
}

// in pixel per second
const int32 kEdgeMotionSpeed = 200;


bool
TouchpadMovement::_EdgeMotion(const touchpad_movement *event, mouse_movement *movement,
        bool validStart)
{
        CALLED();

        float xdelta = 0;
        float ydelta = 0;

        bigtime_t time = system_time();
        if (fLastEdgeMotion != 0) {
                xdelta = fRestEdgeMotion + kEdgeMotionSpeed *
                        float(time - fLastEdgeMotion) / (1000 * 1000);
                fRestEdgeMotion = xdelta - int32(xdelta);
                ydelta = xdelta;
        } else {
                fRestEdgeMotion = 0;
        }

        bool inXEdge = false;
        bool inYEdge = false;

        if (int32(event->xPosition) < fSpecs.areaStartX + fSpecs.edgeMotionWidth) {
                inXEdge = true;
                xdelta *= -1;
        } else if (event->xPosition > uint16(
                fSpecs.areaEndX - fSpecs.edgeMotionWidth)) {
                inXEdge = true;
        }

        if (int32(event->yPosition) < fSpecs.areaStartY + fSpecs.edgeMotionWidth) {
                inYEdge = true;
                ydelta *= -1;
        } else if (event->yPosition > uint16(
                fSpecs.areaEndY - fSpecs.edgeMotionWidth)) {
                inYEdge = true;
        }

        // for a edge motion the drag has to be started in the middle of the pad
        // TODO: this is difficult to understand simplify the code
        if (inXEdge && validStart)
                movement->xdelta = make_small(xdelta);
        if (inYEdge && validStart)
                movement->ydelta = make_small(ydelta);

        if (!inXEdge && !inYEdge)
                fLastEdgeMotion = 0;
        else
                fLastEdgeMotion = time;

        if ((inXEdge || inYEdge) && !validStart)
                return false;

        return true;
}


/*!     If a button has been clicked (movement->buttons must be set accordingly),
        this function updates the fClickCount, as well as the
        \a movement's clicks field.
        Also, it sets the button state from movement->buttons.
*/
void
TouchpadMovement::_UpdateButtons(mouse_movement *movement)
{
        CALLED();

        // set click count correctly according to double click timeout
        if (movement->buttons != 0 && fButtonsState == 0) {
                if (fClickLastTime + click_speed > movement->timestamp)
                        fClickCount++;
                else
                        fClickCount = 1;

                fClickLastTime = movement->timestamp;
        }

        if (movement->buttons != 0)
                movement->clicks = fClickCount;

        fButtonsState = movement->buttons;
}


void
TouchpadMovement::_NoTouchToMovement(const touchpad_movement *event,
        mouse_movement *movement)
{
        CALLED();

        uint32 buttons = event->buttons;

        if (fMovementStarted)
                TRACE("TouchpadMovement: no touch event\n");

        fScrollingStarted = false;
        fMovementStarted = false;
        fLastEdgeMotion = 0;

        if (fTapdragStarted
                && (movement->timestamp - fTapTime) < fTapTimeOUT) {
                buttons = kLeftButton;
        }

        // if the movement stopped switch off the tap drag when timeout is expired
        if ((movement->timestamp - fTapTime) > fTapTimeOUT) {
                if (fTapdragStarted)
                        TRACE("TouchpadMovement: tap drag gesture timed out\n");
                fTapdragStarted = false;
                fValidEdgeMotion = false;
        }

        if (abs(fTapDeltaX) > 15 || abs(fTapDeltaY) > 15) {
                fTapStarted = false;
                fTapClicks = 0;
        }

        if (fTapStarted || fDoubleClick) {
                TRACE("TouchpadMovement: tap gesture\n");
                fTapClicks++;

                if (fTapClicks > 1) {
                        TRACE("TouchpadMovement: empty click\n");
                        buttons = kNoButton;
                        fTapClicks = 0;
                        fDoubleClick = true;
                } else {
                        buttons = kLeftButton;
                        fTapStarted = false;
                        fTapdragStarted = true;
                        fDoubleClick = false;
                }
        }

        movement->buttons = buttons;
        _UpdateButtons(movement);
}


void
TouchpadMovement::_MoveToMovement(const touchpad_movement *event, mouse_movement *movement)
{
        CALLED();

        bool isStartOfMovement = false;
        float pressure = 0;

        TRACE("TouchpadMovement: movement event\n");
        if (!fMovementStarted) {
                isStartOfMovement = true;
                fMovementStarted = true;
                StartNewMovment();
        }

        GetMovement(event->xPosition, event->yPosition);

        movement->xdelta = make_small(xDelta);
        movement->ydelta = make_small(yDelta);

        // tap gesture
        fTapDeltaX += make_small(xDelta);
        fTapDeltaY += make_small(yDelta);

        if (fTapdragStarted) {
                movement->buttons = kLeftButton;
                movement->clicks = 0;

                if (fSettings.edge_motion & B_EDGE_MOTION_ON_TAP_DRAG
                        || (event->buttons && (fSettings.edge_motion & B_EDGE_MOTION_ON_BUTTON_CLICK_DRAG)))
                        fValidEdgeMotion = _EdgeMotion(event, movement, fValidEdgeMotion);
                TRACE("TouchpadMovement: tap drag\n");
        } else {
                if (fSettings.edge_motion & B_EDGE_MOTION_ON_MOVE
                        || (event->buttons && (fSettings.edge_motion & B_EDGE_MOTION_ON_BUTTON_CLICK_MOVE)))
                        fValidEdgeMotion = _EdgeMotion(event, movement, fValidEdgeMotion);
                TRACE("TouchpadMovement: movement set buttons\n");
                movement->buttons = event->buttons;
        }

        // use only a fraction of pressure range, the max pressure seems to be
        // to high
        pressure = 20 * (event->zPressure - fSpecs.minPressure)
                / (fSpecs.realMaxPressure - fSpecs.minPressure);
        if (!fTapStarted
                && isStartOfMovement
                && fSettings.tapgesture_sensibility > 0.
                && fSettings.tapgesture_sensibility > (20 - pressure)) {
                TRACE("TouchpadMovement: tap started\n");
                fTapStarted = true;
                fTapTime = system_time();
                fTapDeltaX = 0;
                fTapDeltaY = 0;
        }

        _UpdateButtons(movement);
}


/*!     Checks if this is a scrolling event or not, and also actually does the
        scrolling work if it is.

        \return \c true if this was a scrolling event, \c false if not.
*/
bool
TouchpadMovement::_CheckScrollingToMovement(const touchpad_movement *event,
        mouse_movement *movement)
{
        CALLED();

        bool isSideScrollingV = false;
        bool isSideScrollingH = false;

        // if a button is pressed don't allow to scroll
        if (event->buttons != 0)
                return false;

        if ((fSpecs.areaEndX - fAreaWidth * fSettings.scroll_rightrange
                        < event->xPosition && !fMovementStarted
                && fSettings.scroll_rightrange > 0.000001)
                        || fSettings.scroll_rightrange > 0.999999) {
                isSideScrollingV = true;
        }
        if ((fSpecs.areaStartY + fAreaHeight * fSettings.scroll_bottomrange
                                > event->yPosition && !fMovementStarted
                        && fSettings.scroll_bottomrange > 0.000001)
                                || fSettings.scroll_bottomrange > 0.999999) {
                isSideScrollingH = true;
        }
        bool isTwoFingerScrolling = two_fingers(event)
                && fSettings.scroll_twofinger;
        if (isTwoFingerScrolling) {
                // two finger scrolling is enabled
                isSideScrollingV = true;
                isSideScrollingH = fSettings.scroll_twofinger_horizontal;
        }

        if (!isSideScrollingV && !isSideScrollingH) {
                fScrollingStarted = false;
                return false;
        }

        TRACE("TouchpadMovement: scroll event\n");

        fTapStarted = false;
        fTapClicks = 0;
        fTapdragStarted = false;
        fValidEdgeMotion = false;
        if (!fScrollingStarted) {
                fScrollingStarted = true;
                StartNewMovment();
        }
        GetScrolling(event->xPosition, event->yPosition, isTwoFingerScrolling
                        ? fSettings.scroll_twofinger_natural_scrolling
                        : fSettings.scroll_reverse);
        movement->wheel_ydelta = make_small(yDelta);
        movement->wheel_xdelta = make_small(xDelta);

        if (isSideScrollingV && !isSideScrollingH)
                movement->wheel_xdelta = 0;
        else if (isSideScrollingH && !isSideScrollingV)
                movement->wheel_ydelta = 0;

        fButtonsState = movement->buttons;

        return true;
}