/*
 * Copyright (C) 2018 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.android.launcher3.touch;

import android.graphics.PointF;
import android.util.Log;
import android.util.Pair;
import android.util.SparseArray;
import android.view.MotionEvent;
import android.view.MotionEvent.PointerCoords;
import android.view.MotionEvent.PointerProperties;

import java.util.function.Consumer;

/**
 * To minimize the size of the MotionEvent, historic events are not copied and passed via the
 * listener.
 */
public class TouchEventTranslator {

    private static final String TAG = "TouchEventTranslator";
    private static final boolean DEBUG = false;

    private class DownState {
        long timeStamp;
        float downX;
        float downY;
        public DownState(long timeStamp, float downX, float downY) {
            this.timeStamp = timeStamp;
            this.downX = downX;
            this.downY = downY;
        }
    };
    private final DownState ZERO = new DownState(0, 0f, 0f);

    private final Consumer<MotionEvent> mListener;

    private final SparseArray<DownState> mDownEvents;
    private final SparseArray<PointF> mFingers;

    private final SparseArray<Pair<PointerProperties[], PointerCoords[]>> mCache;

    public TouchEventTranslator(Consumer<MotionEvent> listener) {
        mDownEvents = new SparseArray<>();
        mFingers = new SparseArray<>();
        mCache = new SparseArray<>();

        mListener = listener;
    }

    public void reset() {
        mDownEvents.clear();
        mFingers.clear();
    }

    public float getDownX() {
        return mDownEvents.get(0).downX;
    }

    public float getDownY() {
        return mDownEvents.get(0).downY;
    }

    public void setDownParameters(int idx, MotionEvent e) {
        DownState ev = new DownState(e.getEventTime(), e.getX(idx), e.getY(idx));
        mDownEvents.append(idx, ev);
    }

    public void dispatchDownEvents(MotionEvent ev) {
        for(int i = 0; i < ev.getPointerCount() && i < mDownEvents.size(); i++) {
            int pid = ev.getPointerId(i);
            put(pid, i, ev.getX(i), 0, mDownEvents.get(i).timeStamp, ev);
        }
    }

    public void processMotionEvent(MotionEvent ev) {
        if (DEBUG) {
            printSamples(TAG + " processMotionEvent", ev);
        }
        int index = ev.getActionIndex();
        float x = ev.getX(index);
        float y = ev.getY(index) - mDownEvents.get(index, ZERO).downY;
        switch (ev.getActionMasked()) {
            case MotionEvent.ACTION_POINTER_DOWN:
                int pid = ev.getPointerId(index);
                if(mFingers.get(pid, null) != null) {
                    for(int i=0; i < ev.getPointerCount(); i++) {
                        pid = ev.getPointerId(i);
                        position(pid, x, y);
                    }
                    generateEvent(ev.getAction(), ev);
                } else {
                    put(pid, index, x, y, ev);
                }
                break;
            case MotionEvent.ACTION_MOVE:
                for(int i=0; i < ev.getPointerCount(); i++) {
                    pid = ev.getPointerId(i);
                    position(pid, x, y);
                }
                generateEvent(ev.getAction(), ev);
                break;
            case MotionEvent.ACTION_POINTER_UP:
            case MotionEvent.ACTION_UP:
                pid = ev.getPointerId(index);
                lift(pid, index, x, y, ev);
                break;
            case MotionEvent.ACTION_CANCEL:
                cancel(ev);
                break;
            default:
                Log.v(TAG, "Didn't process ");
                printSamples(TAG, ev);

        }
    }

    private TouchEventTranslator put(int id, int index, float x, float y, MotionEvent ev) {
        return put(id, index, x, y, ev.getEventTime(), ev);
    }

    private TouchEventTranslator put(int id, int index, float x, float y, long ms, MotionEvent ev) {
        checkFingerExistence(id, false);
        boolean isInitialDown = (mFingers.size() == 0);

        mFingers.put(id, new PointF(x, y));
        int n = mFingers.size();

        if (mCache.get(n) == null) {
            PointerProperties[] properties = new PointerProperties[n];
            PointerCoords[] coords = new PointerCoords[n];
            for (int i = 0; i < n; i++) {
                properties[i] = new PointerProperties();
                coords[i] = new PointerCoords();
            }
            mCache.put(n, new Pair(properties, coords));
        }

        int action;
        if (isInitialDown) {
            action = MotionEvent.ACTION_DOWN;
        } else {
            action = MotionEvent.ACTION_POINTER_DOWN;
            // Set the id of the changed pointer.
            action |= index << MotionEvent.ACTION_POINTER_INDEX_SHIFT;
        }
        generateEvent(action, ms, ev);
        return this;
    }

    public TouchEventTranslator position(int id, float x, float y) {
        checkFingerExistence(id, true);
        mFingers.get(id).set(x, y);
        return this;
    }

    private TouchEventTranslator lift(int id, int index, MotionEvent ev) {
        checkFingerExistence(id, true);
        boolean isFinalUp = (mFingers.size() == 1);
        int action;
        if (isFinalUp) {
            action = MotionEvent.ACTION_UP;
        } else {
            action = MotionEvent.ACTION_POINTER_UP;
            // Set the id of the changed pointer.
            action |= index << MotionEvent.ACTION_POINTER_INDEX_SHIFT;
        }
        generateEvent(action, ev);
        mFingers.remove(id);
        return this;
    }

    private TouchEventTranslator lift(int id, int index, float x, float y, MotionEvent ev) {
        checkFingerExistence(id, true);
        mFingers.get(id).set(x, y);
        return lift(id, index, ev);
    }

    public TouchEventTranslator cancel(MotionEvent ev) {
        generateEvent(MotionEvent.ACTION_CANCEL, ev);
        mFingers.clear();
        return this;
    }

    private void checkFingerExistence(int id, boolean shouldExist) {
        if (shouldExist != (mFingers.get(id, null) != null)) {
            throw new IllegalArgumentException(
                    shouldExist ? "Finger does not exist" : "Finger already exists");
        }
    }


    /**
     * Used to debug MotionEvents being sent/received.
     */
    public void printSamples(String msg, MotionEvent ev) {
        System.out.printf("%s %s", msg, MotionEvent.actionToString(ev.getActionMasked()));
        final int pointerCount = ev.getPointerCount();
        System.out.printf("#%d/%d", ev.getActionIndex(), pointerCount);
        System.out.printf(" t=%d:", ev.getEventTime());
        for (int p = 0; p < pointerCount; p++) {
            System.out.printf("  id=%d: (%f,%f)",
                    ev.getPointerId(p), ev.getX(p), ev.getY(p));
        }
        System.out.println();
    }

    private void generateEvent(int action, MotionEvent ev) {
        generateEvent(action, ev.getEventTime(), ev);
    }

    private void generateEvent(int action, long ms, MotionEvent ev) {
        Pair<PointerProperties[], PointerCoords[]> state = getFingerState();
        MotionEvent event = MotionEvent.obtain(
                mDownEvents.get(0).timeStamp,
                ms,
                action,
                state.first.length,
                state.first,
                state.second,
                ev.getMetaState(),
                ev.getButtonState() /* buttonState */,
                ev.getXPrecision() /* xPrecision */,
                ev.getYPrecision() /* yPrecision */,
                ev.getDeviceId(),
                ev.getEdgeFlags(),
                ev.getSource(),
                ev.getFlags() /* flags */);
        if (DEBUG) {
            printSamples(TAG + " generateEvent", event);
        }
        if (event.getPointerId(event.getActionIndex()) < 0) {
            printSamples(TAG + "generateEvent", event);
            throw new IllegalStateException(event.getActionIndex() + " not found in MotionEvent");
        }
        mListener.accept(event);
        event.recycle();
    }

    /**
     * Returns the description of the fingers' state expected by MotionEvent.
     */
    private Pair<PointerProperties[], PointerCoords[]> getFingerState() {
        int nFingers = mFingers.size();

        Pair<PointerProperties[], PointerCoords[]> result = mCache.get(nFingers);
        PointerProperties[] properties = result.first;
        PointerCoords[] coordinates = result.second;

        int index = 0;
        for (int i = 0; i < mFingers.size(); i++) {
            int id = mFingers.keyAt(i);
            PointF location = mFingers.get(id);

            PointerProperties property = properties[i];
            property.id = id;
            property.toolType = MotionEvent.TOOL_TYPE_FINGER;
            properties[index] = property;

            PointerCoords coordinate = coordinates[i];
            coordinate.x = location.x;
            coordinate.y = location.y;
            coordinate.pressure = 1.0f;
            coordinates[index] = coordinate;

            index++;
        }
        return mCache.get(nFingers);
    }
}