#include <stdlib.h>
#include <string.h>

#include "eve.h"
#include "eve_touch_engine.h"

static EVETouch touch_obj[EVE_MAX_TOUCH];
static EVETouchTimer touch_timer;
static EVEPhyAcc touch_acc;

static eve_touch_handler_t touch_handler;
static void *touch_handler_param;
static uint8_t touch_tag_opt[256];

void eve_touch_init(void) {
    int i;

    memset(&touch_timer, 0, sizeof(touch_timer));
    for (i=0; i<EVE_MAX_TOUCH; i++) {
        EVETouch *touch = &touch_obj[i];

        memset(&touch_obj[i], 0, sizeof(EVETouch));
        touch->eevt |= EVE_TOUCH_EETYPE_NOTOUCH;
    }
    eve_phy_acc_init(&touch_acc, -EVE_TOUCH_ACC_A);
}

void eve_handle_touch(uint16_t intr_flags) {
    int i;

    for (i=0; i<EVE_MAX_TOUCH; i++) {
        uint32_t now = 0;
        uint16_t touch_evt = 0;
        EVETouch *touch = &touch_obj[i];

        now = eve_get_tick();

        if (intr_flags & EVE_INT_CONVCOMPLETE) {
            uint32_t touch_xy = eve_touch_reg_xy(i);
            uint16_t timer_evt;

            if (touch_xy != EVE_NOTOUCH) {
                int16_t touch_x = touch_xy >> 16;
                int16_t touch_y = touch_xy & 0xffff;
                int check_track, check_timer;

                if (touch->eevt & EVE_TOUCH_EETYPE_NOTOUCH) {
                    uint16_t _evt = 0;
                    uint16_t _eevt = 0;

                    timer_evt = eve_timer_get_evt(touch);
                    if (timer_evt) {
                        uint16_t _touch_evt = 0;

                        if (timer_evt & EVE_TOUCH_ETYPE_TAP2) {
                            int dx = touch_x - touch->x0;
                            int dy = touch_y - touch->y0;

                            dx = dx < 0 ? -dx : dx;
                            dy = dy < 0 ? -dy : dy;
                            if ((dx > EVE_TOUCH_THRESHOLD_X) || (dy > EVE_TOUCH_THRESHOLD_Y)) {
                                _touch_evt |= EVE_TOUCH_ETYPE_TAP1;
                            } else {
                                _evt |= EVE_TOUCH_ETYPE_TAP2;
                                _eevt |= EVE_TOUCH_EETYPE_TAP2;
                            }
                        }
                        if (timer_evt & EVE_TOUCH_ETYPE_TRACK) {
                            _eevt |= EVE_TOUCH_EETYPE_TRACK_ABORT;
                            _touch_evt |= (EVE_TOUCH_ETYPE_TRACK_STOP | EVE_TOUCH_ETYPE_TRACK_ABORT);
                            eve_vtrack_stop();
                        }

                        if (touch_handler && _touch_evt) {
                            touch_handler(touch_timer.touch, _touch_evt, touch_handler_param);
                        }
                        eve_timer_clear(touch);
                    }
                    touch_evt = EVE_TOUCH_ETYPE_POINT0 | _evt;
                    touch->eevt = _eevt;
                    touch->tag0 = 0;
                    touch->tag = 0;
                    touch->tag_up = 0;
                    touch->tracker.tag = 0;
                    touch->tracker.track = 0;
                    touch->tracker.val = 0;
                    touch->t = 0;
                    touch->vx = 0;
                    touch->vy = 0;
                    touch->x0 = touch_x;
                    touch->y0 = touch_y;
                } else if (touch->tracker.track) {
                    uint32_t dt = now - touch->t;
                    int vx = ((int)touch_x - touch->x) * EVE_RTC_FREQ / (int)dt;
                    int vy = ((int)touch_y - touch->y) * EVE_RTC_FREQ / (int)dt;

                    touch->vx = vx;
                    touch->vy = vy;
                }
                touch->x = touch_x;
                touch->y = touch_y;
                touch->t = now;

                timer_evt = eve_timer_get_evt(touch);
                check_track = touch->tracker.tag && !touch->tracker.track;
                check_timer = timer_evt & (EVE_TOUCH_ETYPE_LPRESS | EVE_TOUCH_ETYPE_TAP2);

                if (check_track || check_timer) {
                    int dx = touch->x - touch->x0;
                    int dy = touch->y - touch->y0;

                    dx = dx < 0 ? -dx : dx;
                    dy = dy < 0 ? -dy : dy;
                    if (check_track) {
                        if (((dx > EVE_TOUCH_THRESHOLD_X) && !(touch_tag_opt[touch->tracker.tag] & EVE_TOUCH_OPT_TRACK_X)) ||
                            ((dy > EVE_TOUCH_THRESHOLD_Y) && !(touch_tag_opt[touch->tracker.tag] & EVE_TOUCH_OPT_TRACK_Y))) {
                            touch->tracker.tag = 0;
                        }
                        if (touch->tracker.tag && ((dx > EVE_TOUCH_THRESHOLD_X) || (dy > EVE_TOUCH_THRESHOLD_Y))) {
                            int track_x, track_y;

                            track_x = 0;
                            track_y = 0;
                            if ((touch_tag_opt[touch->tracker.tag] & EVE_TOUCH_OPT_TRACK_X) && (dx > EVE_TOUCH_THRESHOLD_X)) track_x = 1;
                            if ((touch_tag_opt[touch->tracker.tag] & EVE_TOUCH_OPT_TRACK_Y) && (dy > EVE_TOUCH_THRESHOLD_Y)) track_y = 1;

                            if (track_x) touch->eevt |= touch->x > touch->x0 ? EVE_TOUCH_EETYPE_TRACK_RIGHT : EVE_TOUCH_EETYPE_TRACK_LEFT;
                            if (track_y) touch->eevt |= touch->y > touch->y0 ? EVE_TOUCH_EETYPE_TRACK_DOWN : EVE_TOUCH_EETYPE_TRACK_UP;

                            touch_evt |= EVE_TOUCH_ETYPE_TRACK_START;
                            touch->tracker.track = 1;
                        }
                    }
                    if (check_timer && ((dx > EVE_TOUCH_THRESHOLD_X) || (dy > EVE_TOUCH_THRESHOLD_Y))) {
                        eve_timer_set_evt(touch, timer_evt & ~(EVE_TOUCH_ETYPE_LPRESS | EVE_TOUCH_ETYPE_TAP2));
                    }
                }
                if (touch->tracker.track) {
                    if (touch_tag_opt[touch->tracker.tag] & EVE_TOUCH_OPT_TRACK_XY) touch_evt |= EVE_TOUCH_ETYPE_TRACK;
                    if (touch_tag_opt[touch->tracker.tag] & EVE_TOUCH_OPT_TRACK_REG) touch_evt |= EVE_TOUCH_ETYPE_TRACK_REG;
                }
                if (touch_evt & EVE_TOUCH_ETYPE_TRACK_REG) {
                    uint32_t touch_track = eve_touch_reg_track(i);

                    if (touch->tracker.tag == (touch_track & 0xff)) {
                        touch->tracker.val = touch_track >> 16;
                    } else {
                        touch_evt &= ~EVE_TOUCH_ETYPE_TRACK_REG;
                    }
                }
            } else if (!(touch->eevt & EVE_TOUCH_EETYPE_NOTOUCH)) {
                touch_evt |= EVE_TOUCH_ETYPE_POINT_UP;
                touch->eevt |= EVE_TOUCH_EETYPE_NOTOUCH;

                timer_evt = eve_timer_get_evt(touch);
                if (timer_evt & EVE_TOUCH_ETYPE_LPRESS) {
                    eve_timer_set_evt(touch, timer_evt & ~EVE_TOUCH_ETYPE_LPRESS);
                }
                if (touch->tracker.track) {
                    int start = 0;
                    uint8_t opt = touch_tag_opt[touch->tracker.tag];
                    uint8_t track_ext = ((opt & EVE_TOUCH_OPT_TRACK_EXT_X) && (touch->eevt & EVE_TOUCH_EETYPE_TRACK_X)) ||
                                        ((opt & EVE_TOUCH_OPT_TRACK_EXT_Y) && (touch->eevt & EVE_TOUCH_EETYPE_TRACK_Y));

                    if (!eve_timer_get_evt(NULL) && track_ext) {
                        start = eve_phy_acc_start(&touch_acc, touch->x, touch->y, touch->t, touch->vx, touch->vy);
                    }
                    if (start) {
                        eos_vtrack_cont(&touch_acc, eve_phy_acc_tick, EVE_TOUCH_TIMEOUT_TRACK, touch);
                    } else {
                        touch_evt |= EVE_TOUCH_ETYPE_TRACK_STOP;
                    }
                }
            }
        }

        if (intr_flags & EVE_INT_TAG) {
            uint8_t touch_tag = eve_touch_reg_tag(i);

            if (touch_tag != touch->tag) {
                if (touch_tag) {
                    if (!touch->tag0) {
                        touch_evt |= EVE_TOUCH_ETYPE_POINT;
                        touch->tag0 = touch_tag;
                        if (touch_tag_opt[touch_tag] & (EVE_TOUCH_OPT_TRACK_XY | EVE_TOUCH_OPT_TRACK_REG)) {
                            touch->tracker.tag = touch_tag;
                        }
                        if (touch->tracker.tag && !(touch_tag_opt[touch->tracker.tag] & EVE_TOUCH_OPT_TRACK_XY)) {
                            touch_evt |= EVE_TOUCH_ETYPE_TRACK_START;
                            touch->tracker.track = 1;
                        }
                        if (!eve_timer_get_evt(NULL) && (touch_tag_opt[touch_tag] & (EVE_TOUCH_OPT_LPRESS | EVE_TOUCH_OPT_TAP2))) {
                            uint16_t _evt = 0;

                            if (touch_tag_opt[touch_tag] & EVE_TOUCH_OPT_LPRESS) _evt |= EVE_TOUCH_ETYPE_LPRESS;
                            if (touch_tag_opt[touch_tag] & EVE_TOUCH_OPT_TAP2) _evt |= EVE_TOUCH_ETYPE_TAP2;
                            eve_timer_set(touch, _evt, EVE_TOUCH_TIMEOUT_TAP);
                        }
                    }
                }
                touch->tag_up = touch->tag;
                if (touch->tag_up) touch_evt |= EVE_TOUCH_ETYPE_TAG_UP;
                touch->tag = touch_tag;
                if (touch->tag) touch_evt |= EVE_TOUCH_ETYPE_TAG;
            }
        }

        if (touch_handler && touch_evt) {
            touch_handler(touch, touch_evt, touch_handler_param);
        }
    }
}

void eve_handle_time(void) {
    EVETouch *touch = touch_timer.touch;

    if (touch_timer.evt) {
        int more = 0;
        uint16_t touch_evt = 0;

        if (touch_timer.evt & EVE_TOUCH_ETYPE_LPRESS) {
            touch_evt |= EVE_TOUCH_ETYPE_LPRESS;
            if (touch) touch->eevt |= EVE_TOUCH_EETYPE_LPRESS;
        }
        if (touch_timer.evt & EVE_TOUCH_ETYPE_TAP2) {
            touch_evt |= EVE_TOUCH_ETYPE_TAP1;
        }
        if (touch_timer.evt & EVE_TOUCH_ETYPE_TRACK) {
            touch_evt |= EVE_TOUCH_ETYPE_TRACK;
            more = eve_vtrack_tick(&touch_evt);
            if (!more) {
                touch_evt |= EVE_TOUCH_ETYPE_TRACK_STOP;
            }
        }

        if (!more) {
            eve_timer_reset();
        }

        if (touch_handler && touch_evt) {
            touch_handler(touch, touch_evt, touch_handler_param);
        }
    }
}

void eve_touch_set_handler(eve_touch_handler_t handler, void *param) {
    touch_handler = handler;
    touch_handler_param = param;
}

EVETouch *eve_touch_get_obj(int i) {
    return &touch_obj[i];
}

int8_t eve_touch_get_idx(EVETouch *touch) {
    if (touch == NULL) return -1;
    return touch - touch_obj;
}

uint16_t eve_touch_evt(EVETouch *touch, uint16_t evt, uint8_t tag_min, uint8_t tag_n) {
    int tag_max;
    uint8_t _tag;
    uint16_t _evt;

    if (tag_min == EVE_NOTAG) return 0;
    if (evt & EVE_TOUCH_ETYPE_EXT) return 0;

    tag_max = tag_min + tag_n;
    if ((touch->tag0 < tag_min) || (touch->tag0 >= tag_max)) return 0;

    if (evt & EVE_TOUCH_ETYPE_TAG) {
        _tag = touch->tag;
        if ((_tag >= tag_min) && (_tag < tag_max)) _evt |= EVE_TOUCH_ETYPE_TAG;
    }
    if (evt & EVE_TOUCH_ETYPE_TAG_UP) {
        _tag = touch->tag_up;
        if ((_tag >= tag_min) && (_tag < tag_max)) _evt |= EVE_TOUCH_ETYPE_TAG_UP;
    }
    if (evt & EVE_TOUCH_ETYPE_TRACK_MASK) {
        _tag = touch->tracker.tag;
        if ((_tag >= tag_min) && (_tag < tag_max)) _evt |= evt & EVE_TOUCH_ETYPE_TRACK_MASK;
    }
    if (evt & (EVE_TOUCH_ETYPE_POINT_MASK | EVE_TOUCH_ETYPE_LPRESS | EVE_TOUCH_ETYPE_TAP1 | EVE_TOUCH_ETYPE_TAP2 | EVE_TOUCH_ETYPE_USR_MASK)) {
        _evt |= evt & (EVE_TOUCH_ETYPE_POINT_MASK | EVE_TOUCH_ETYPE_LPRESS | EVE_TOUCH_ETYPE_TAP1 | EVE_TOUCH_ETYPE_TAP2 | EVE_TOUCH_ETYPE_USR_MASK);
    }

    return _evt;
}

void eve_tag_set_opt(uint8_t tag, uint8_t opt) {
    if (tag == EVE_NOTAG) return;
    touch_tag_opt[tag] = opt;
}

uint8_t eve_tag_get_opt(uint8_t tag) {
    if (tag == EVE_NOTAG) return 0;
    return touch_tag_opt[tag];
}

void eve_tag_clear_opt(void) {
    memset(touch_tag_opt, 0, sizeof(touch_tag_opt));
}

void eve_timer_set(EVETouch *touch, uint16_t evt, uint32_t tick_ms) {
    touch_timer.touch = touch;
    touch_timer.evt = evt;
    eve_ostimer_set(tick_ms);
}

void eve_timer_clear(EVETouch *touch) {
    eve_timer_set_evt(touch, 0);
}

void eve_timer_reset(void) {
    touch_timer.touch = NULL;
    touch_timer.evt = 0;
}

void eve_timer_set_evt(EVETouch *touch, uint16_t evt) {
    if ((touch == NULL) || (touch == touch_timer.touch)) {
        touch_timer.evt = evt;
    }
    if (!touch_timer.evt) {
        eve_ostimer_clear();
        touch_timer.touch = NULL;
    }
}

uint16_t eve_timer_get_evt(EVETouch *touch) {
    uint16_t rv = 0;

    if ((touch == NULL) || (touch_timer.touch == touch)) {
        rv = touch_timer.evt;
    }
    return rv;
}