'use strict';

const gamepadsEnable = enhancedMode;
const inputWASDEmulateDirection = enhancedMode;
const allowTouch = enhancedMode;
const isTouchDevice = allowTouch && window.ontouchstart !== undefined;
const touchGamepadEnable = enhancedMode;
const touchGamepadAlpha = .3;

///////////////////////////////////////////////////////////////////////////////
// Input user functions

const keyIsDown      = (key) => inputData[key] & 1; 
const keyWasPressed  = (key) => inputData[key] & 2 ? 1 : 0;
const keyWasReleased = (key) => inputData[key] & 4 ? 1 : 0;
const clearInput = () => inputData = [];

let mousePos = vec3();
const mouseIsDown      = keyIsDown;
const mouseWasPressed  = keyWasPressed;
const mouseWasReleased = keyWasReleased;

let isUsingGamepad;
const gamepadIsDown      = (key, gamepad=0) => !!(gamepadData[gamepad][key] & 1); 
const gamepadWasPressed  = (key, gamepad=0) => !!(gamepadData[gamepad][key] & 2); 
const gamepadWasReleased = (key, gamepad=0) => !!(gamepadData[gamepad][key] & 4); 
const gamepadStick       = (stick, gamepad=0) =>
    gamepadStickData[gamepad] ? gamepadStickData[gamepad][stick] || vec3() : vec3();
const gamepadGetValue    = (key, gamepad=0) => gamepadDataValues[gamepad][key]; 

///////////////////////////////////////////////////////////////////////////////
// Input event handlers

let inputData = []; // track what keys are down

function inputInit()
{
    if (gamepadsEnable)
    {
        gamepadData = [];
        gamepadStickData = [];
        gamepadDataValues = [];
        gamepadData[0] = [];
        gamepadDataValues[0] = [];
    }

    onkeydown = (e)=>
    {
        isUsingGamepad = 0;
        if (!e.repeat)
        {
            inputData[e.code] = 3;
            if (inputWASDEmulateDirection)
                inputData[remapKey(e.code)] = 3;
        }
    }

    onkeyup = (e)=>
    {
        inputData[e.code] = 4;
        if (inputWASDEmulateDirection)
            inputData[remapKey(e.code)] = 4;
    }
    
    // mouse event handlers
    onmousedown   = (e)=>
    {
        isUsingGamepad = 0;
        inputData[e.button] = 3; 
        mousePos = mouseToScreen(vec3(e.x,e.y)); 
    }
    onmouseup     = (e)=> inputData[e.button] = inputData[e.button] & 2 | 4;
    onmousemove   = (e)=>
    {
        mousePos = mouseToScreen(vec3(e.x,e.y));
        if (freeCamMode)
        {
            mouseDelta.x += e.movementX/mainCanvasSize.x;
            mouseDelta.y += e.movementY/mainCanvasSize.y;
        }
    }
    oncontextmenu = (e)=> false; // prevent right click menu

    // handle remapping wasd keys to directions
    const remapKey = (c) => inputWASDEmulateDirection ? 
        c == 'KeyW' ? 'ArrowUp' : 
        c == 'KeyS' ? 'ArrowDown' : 
        c == 'KeyA' ? 'ArrowLeft' : 
        c == 'KeyD' ? 'ArrowRight' : c : c;

    // init touch input
    isTouchDevice && touchInputInit();
}

function inputUpdate()
{
    // clear input when lost focus (prevent stuck keys)
    isTouchDevice || document.hasFocus() || clearInput();
    gamepadsEnable && gamepadsUpdate();
}

function inputUpdatePost()
{
    // clear input to prepare for next frame
    for (const i in inputData)
        inputData[i] &= 1;
}
    
// convert a mouse position to screen space
const mouseToScreen = (mousePos) =>
{
    if (!clampAspectRatios)
    {
        // canvas always takes up full screen
        return vec3(mousePos.x/mainCanvasSize.x,mousePos.y/mainCanvasSize.y);
    }
    else
    {
        const rect = mainCanvas.getBoundingClientRect();
        return vec3(percent(mousePos.x, rect.left, rect.right), percent(mousePos.y, rect.top, rect.bottom));
    }
}

///////////////////////////////////////////////////////////////////////////////
// gamepad input

// gamepad internal variables
let gamepadData, gamepadStickData, gamepadDataValues;

// gamepads are updated by engine every frame automatically
function gamepadsUpdate()
{
    const applyDeadZones = (v)=>
    {
        const min=.2, max=.8;
        const deadZone = (v)=> 
            v >  min ?  percent( v, min, max) : 
            v < -min ? -percent(-v, min, max) : 0;
        return vec3(deadZone(v.x), deadZone(-v.y)).clampLength();
    }

    // update touch gamepad if enabled
    isTouchDevice && touchGamepadUpdate();

    // return if gamepads are disabled or not supported
    if (!navigator || !navigator.getGamepads)
        return;

    // only poll gamepads when focused or in debug mode (allow playing when not focused in debug)
    if (!devMode && !document.hasFocus())
        return;

    // poll gamepads
    const gamepads = navigator.getGamepads();
    for (let i = gamepads.length; i--;)
    {
        // get or create gamepad data
        const gamepad = gamepads[i];
        const data = gamepadData[i] || (gamepadData[i] = []);
        const dataValue = gamepadDataValues[i] || (gamepadDataValues[i] = []);
        const sticks = gamepadStickData[i] || (gamepadStickData[i] = []);

        if (gamepad)
        {
            // read analog sticks
            for (let j = 0; j < gamepad.axes.length-1; j+=2)
                sticks[j>>1] = applyDeadZones(vec3(gamepad.axes[j],gamepad.axes[j+1]));
            
            // read buttons
            for (let j = gamepad.buttons.length; j--;)
            {
                const button = gamepad.buttons[j];
                const wasDown = gamepadIsDown(j,i);
                data[j] = button.pressed ? wasDown ? 1 : 3 : wasDown ? 4 : 0;
                dataValue[j] = percent(button.value||0,.1,.9); // apply deadzone
                isUsingGamepad ||= !i && button.pressed;
            }

            const gamepadDirectionEmulateStick = 1;
            if (gamepadDirectionEmulateStick)
            {
                // copy dpad to left analog stick when pressed
                const dpad = vec3(
                    (gamepadIsDown(15,i)&&1) - (gamepadIsDown(14,i)&&1), 
                    (gamepadIsDown(12,i)&&1) - (gamepadIsDown(13,i)&&1));
                if (dpad.lengthSquared())
                    sticks[0] = dpad.clampLength();
            }
        }
    }
}

///////////////////////////////////////////////////////////////////////////////
// touch input

// try to enable touch mouse
function touchInputInit()
{
    // add non passive touch event listeners
    let handleTouch = handleTouchDefault;
    if (touchGamepadEnable)
    {
        // touch input internal variables
        handleTouch = handleTouchGamepad;
        touchGamepadButtons = [];
        touchGamepadStick = vec3();
    }
    document.addEventListener('touchstart', (e) => handleTouch(e), { passive: false });
    document.addEventListener('touchmove',  (e) => handleTouch(e), { passive: false });
    document.addEventListener('touchend',   (e) => handleTouch(e), { passive: false });

    // override mouse events
    onmousedown = onmouseup = ()=> 0;

    // handle all touch events the same way
    let wasTouching;
    function handleTouchDefault(e)
    {
        // fix stalled audio requiring user interaction
        if (soundEnable && !audioContext)
            audioContext = new AudioContext; // create audio context
        //if (soundEnable && audioContext && audioContext.state != 'running')
        //    sound_bump.play(); // play sound to fix audio

        // check if touching and pass to mouse events
        const touching = e.touches.length;
        const button = 0; // all touches are left mouse button
        if (touching)
        {
            // average all touch positions
            const p = vec3();
            for (let touch of e.touches)
            {
                p.x += touch.clientX/e.touches.length;
                p.y += touch.clientY/e.touches.length;
            }

            mousePos = mouseToScreen(p);
            wasTouching ? 0 : inputData[button] = 3;
        }
        else if (wasTouching)
            inputData[button] = inputData[button] & 2 | 4;

        // set was touching
        wasTouching = touching;

        // prevent default handling like copy and magnifier lens
        if (document.hasFocus()) // allow document to get focus
            e.preventDefault();
        
        // must return true so the document will get focus
        return true;
    }
}

///////////////////////////////////////////////////////////////////////////////
// touch gamepad

// touch gamepad internal variables
let touchGamepadTimer = new Timer, touchGamepadButtons, touchGamepadStick, touchGamepadSize;

// special handling for virtual gamepad mode
function handleTouchGamepad(e)
{
    if (soundEnable)
    {
        if (!audioContext)
            audioContext = new AudioContext; // create audio context
            
        // fix stalled audio
        if (audioContext.state != 'running')
            audioContext.resume();
    }

    // clear touch gamepad input
    touchGamepadStick = vec3();
    touchGamepadButtons = [];
    isUsingGamepad = true;
        
    const touching = e.touches.length;
    if (touching)
    {
        touchGamepadTimer.set();
        if (paused || titleScreenMode || gameOverTimer.isSet())
        {
            // touch anywhere to press start
            touchGamepadButtons[9] = 1;
            return;
        }
    }

    // get center of left and right sides
    const stickCenter = vec3(touchGamepadSize, mainCanvasSize.y-touchGamepadSize);
    const buttonCenter = mainCanvasSize.subtract(vec3(touchGamepadSize, touchGamepadSize));
    const startCenter = mainCanvasSize.scale(.5);

    // check each touch point
    for (const touch of e.touches)
    {
        let touchPos = mouseToScreen(vec3(touch.clientX, touch.clientY));
        touchPos = touchPos.multiply(mainCanvasSize);
        if (touchPos.distance(stickCenter) < touchGamepadSize)
        {
            // virtual analog stick
            touchGamepadStick = touchPos.subtract(stickCenter).scale(2/touchGamepadSize);
            //touchGamepadStick = touchGamepadStick.clampLength(); // circular clamp
            touchGamepadStick.x = clamp(touchGamepadStick.x,-1,1);
            touchGamepadStick.y = clamp(touchGamepadStick.y,-1,1);
        }
        else if (touchPos.distance(buttonCenter) < touchGamepadSize)
        {
            // virtual face buttons
            const button = touchPos.y > buttonCenter.y ? 1 : 0;
            touchGamepadButtons[button] = 1;
        }
        else if (touchPos.distance(startCenter) < touchGamepadSize)
        {
            // hidden virtual start button in center
            touchGamepadButtons[9] = 1;
        }
    }

    // call default touch handler so normal touch events still work
    //handleTouchDefault(e);

    // prevent default handling like copy and magnifier lens
    if (document.hasFocus()) // allow document to get focus
        e.preventDefault();
    
    // must return true so the document will get focus
    return true;
}

// update the touch gamepad, called automatically by the engine
function touchGamepadUpdate()
{
    if (!touchGamepadEnable)
        return;

    // adjust for thin canvas
    touchGamepadSize = clamp(mainCanvasSize.y/8, 99, mainCanvasSize.x/2);

    ASSERT(touchGamepadButtons, 'set touchGamepadEnable before calling init!');
    if (!touchGamepadTimer.isSet())
        return;
    
    // read virtual analog stick
    const sticks = gamepadStickData[0] || (gamepadStickData[0] = []);
    sticks[0] = touchGamepadStick.copy();

    // read virtual gamepad buttons
    const data = gamepadData[0];
    for (let i=10; i--;)
    {
        const wasDown = gamepadIsDown(i,0);
        data[i] = touchGamepadButtons[i] ? wasDown ? 1 : 3 : wasDown ? 4 : 0;
    }
}

// render the touch gamepad, called automatically by the engine
function touchGamepadRender()
{
    if (!touchGamepadEnable || !touchGamepadTimer.isSet())
        return;
    
    // fade off when not touching or paused
    const alpha = percent(touchGamepadTimer.get(), 4, 3);
    if (!alpha || paused)
        return;

    // setup the canvas
    const context = mainContext;
    context.save();
    context.globalAlpha = alpha*touchGamepadAlpha;
    context.strokeStyle = '#fff';
    context.lineWidth = 3;

    // draw left analog stick
    context.fillStyle = touchGamepadStick.lengthSquared() > 0 ? '#fff' : '#000';
    context.beginPath();

    // draw circle shaped gamepad
    const leftCenter = vec3(touchGamepadSize, mainCanvasSize.y-touchGamepadSize);
    context.arc(leftCenter.x, leftCenter.y, touchGamepadSize/2, 0, 9);
    context.fill();
    context.stroke();

    // draw right face buttons
    const rightCenter = vec3(mainCanvasSize.x-touchGamepadSize, mainCanvasSize.y-touchGamepadSize);
    for (let i=2; i--;)
    {
        const pos = rightCenter.add(vec3(0,(i?1:-1)*touchGamepadSize/2));
        context.fillStyle = touchGamepadButtons[i] ? '#fff' : '#000';
        context.beginPath();
        context.arc(pos.x, pos.y, touchGamepadSize/3, 0, 9);
        context.fill();
        context.stroke();
    }

    // set canvas back to normal
    context.restore();
}