let slideShowInterval = null
let grabHotspot = null

/**
 * Disables hiding of various child items 
 * once model has loaded
 */
modelLoaded = function() {
    $('.awaiting-model').css('display', 'flex').removeClass('awaiting-model')
}

/**
 * Reads the json string in the edit panel 
 * and updates hotspot elements
 * 
 * @return {bool} true on successful read and update
 */
readMetadata = function() {
    let hotspotsObj = []
    var metadata
    try {
        [_, metadata] = extractMetadata()
    } catch (err) {
        console.warn('Failed to read model metadata:' + err.message)
        return false
    }
    Object.keys(metadata.annotations).forEach((hs, idx) => {
        let newHs = document.createElement('button')
        newHs.classList.add('Hotspot')
        newHs.setAttribute('slot',`hotspot-${idx + 1}`)
        newHs.setAttribute('ontouchstart', 'event.stopPropagation()')
        newHs.setAttribute('onclick', 'onAnnotation(event)')
        newHs.setAttribute('onmousedown', 'grabAnnotation(event)')
        newHs.setAttribute('onmouseup', 'releaseAnnotation(event)')
        Object.keys(metadata.annotations[hs]).forEach((prop) => {
            newHs.setAttribute(prop, metadata.annotations[hs][prop])
        })
        let newAn = document.createElement('div')
        newAn.classList.add('HotspotAnnotation', 'HiddenAnnotation')
        newAn.innerText = hs
        newHs.appendChild(newAn)
        newLabel = document.createElement('span')
        newLabel.innerText = idx + 1
        newHs.appendChild(newLabel)
        hotspotsObj.push(newHs)
    })
    $('model-viewer button').remove()
    const mView = $('model-viewer')[0]
    hotspotsObj.forEach(hs => {
        mView.appendChild(hs)
    })
    return true
}

/**
 * Parses the current hotspots into json object
 * and writes the json string to the edit panel
 * 
 * @return {bool} true on successful write to edit panel
 */
writeMetadata = function () {
    let annotationsObj = {}
    currentButtons = $('.Hotspot').each(function() {
        let buttonEl = $(this)[0]
        annotationsObj[buttonEl.childNodes[0].innerText] = {
            "data-position": buttonEl.getAttribute('data-position'),
            "data-normal": buttonEl.getAttribute('data-normal'),
            "data-orbit": buttonEl.getAttribute('data-orbit'),
            "data-target": buttonEl.getAttribute('data-target')
        }
    })
    if (Object.keys(annotationsObj).length === 0) return false
    const [currentText, metadata] = extractMetadata()
    metadata.annotations = annotationsObj
    const newText = currentText.replace(/(.*?<pre>)[\S\s]*?(<\/pre>.*)/,`$1\n${JSON.stringify(metadata, null, 2)}\n$2`)
    $('#wpTextbox1').val(newText)
    return true
}

/**
 * Convert text in the preview text editor to js object
 * 
 * @return object containing metadata information
 */
extractMetadata = function() {
    const editText = $('#wpTextbox1').val()
    const extractMetadata = editText.match(/<pre>([\S\s]*?)<\/pre>/)
    let metadata = (extractMetadata.length >= 2) ? JSON.parse(extractMetadata[1]) : {viewerConfig: {}, annotations: {}, annotationSets: {}}
    if (metadata.annotations === undefined) {
        metadata.annotations = {}
    }
    return [editText, metadata]
}

/**
 * Sets listener and attributes on model-viewer to
 * allow for click registering of a new hotspot
 */
readyAddHotspot = function() {
    const previewMv = $('model-viewer')
    previewMv.one('click', clickAddHotspot)
    previewMv.addClass('AddingHotspot')
    previewMv[0].disableTap = true
    previewMv[0].toggleAttribute('camera-controls')
}

/**
 * Event listener callback to retrieve the info
 * about the model surface point selected by the
 * mouse and add that information to the editor
 * text input
 * 
 * @param {PointerEvent} e 
 */
clickAddHotspot = function(e) {
    const previewMv = $('model-viewer')
    previewMv.removeClass('AddingHotspot')
    let hsPosition = null
    let targetModel = previewMv[0]
    targetModel.disableTap = false
    targetModel.toggleAttribute('camera-controls')
    if (targetModel) {
        hsPosition = targetModel.positionAndNormalFromPoint(e.clientX, e.clientY)
    }
    if (hsPosition) {
        let currentText = $('#wpTextbox1').val()
        let [_, metadata] = extractMetadata(currentText)
        let hsOutput = {}
        hsOutput['data-position'] = hsPosition.position.toString().replaceAll(/(\d{5})(\d*?m)/g,"$1m")
        hsOutput['data-normal'] = hsPosition.normal.toString().replaceAll(/(\d{5})(\d*?m)/g,"$1m")
        let orbitObj = targetModel.getCameraOrbit()
        hsOutput['data-orbit'] = `${orbitObj.theta.toFixed(2)}rad ${orbitObj.phi.toFixed(2)}rad ${orbitObj.radius.toFixed(2)}m`
        let targetObj = targetModel.getCameraTarget()
        hsOutput['data-target'] = `${targetObj.x.toFixed(5)}m ${targetObj.y.toFixed(5)}m ${targetObj.z.toFixed(5)}m`
        metadata.annotations['Hotspot ' + (Object.keys(metadata.annotations).length + 1)] = hsOutput
        let newText = currentText.replace(/(.*?<pre>)[\S\s]*?(<\/pre>.*)/,`$1\n${JSON.stringify(metadata, null, 2)}\n$2`)
        $('#wpTextbox1').val(newText)
    }
    readMetadata()
}

/**
 * Event listener callback to toggle the visibility
 * of a hotspot's annotation when the hotspot is 
 * clicked
 * 
 * @param {PointerEvent} e 
 */
onAnnotation = function(e) {
	e.stopPropagation()
	let targetAnnotation = Number.parseInt(e.target.slot.split('-')[1])
	let targetModel = e.target.closest('model-viewer')
    selectAnnotation(targetModel, targetAnnotation)
}

/**
 * Event listener callback to hide all hotspot
 * annotations when the model-viewer receives
 * a click event
 */
clearAnnotations = function() {
	[...document.getElementsByClassName('HotspotAnnotation')].forEach( an => {
		an.classList.add('HiddenAnnotation')
	})
};

/**
 * Select the numbered hotspot of the given model
 * 
 * @param {ModelViewer} mView
 * @param {number} annotId
 * 
 * @return {bool} true if annotation selected false if unselected
 */
selectAnnotation = function(mView, annotId) {
    let anSelected = false;
    [...mView.querySelectorAll('.HotspotAnnotation')].forEach( (an, idx) => {
		if (idx + 1 == annotId && an.classList.contains('HiddenAnnotation')) {
			an.classList.remove('HiddenAnnotation');
			if (an.parentElement.dataset.target) {mView.cameraTarget = an.parentElement.dataset.target}
			if (an.parentElement.dataset.orbit) {mView.cameraOrbit = an.parentElement.dataset.orbit}
            anSelected = true
		} else {
			an.classList.add('HiddenAnnotation');
		}        
	});
    return anSelected
}

/**
 * Select the next numbered hotspot
 * 
 * @param {ModelViewer} mView
 * 
 * @return {number} ID number of the newly selected hotspot
 */
nextAnnotation = function(mView) {
    let incrAnnotation = 0
    const numSpots = [...mView.querySelectorAll('Button')].length
    const currentAnnotation = mView.querySelectorAll('Button:has(.HotspotAnnotation:not(.HiddenAnnotation))')[0]
    if (!currentAnnotation) {
        incrAnnotation = 1
    } else {
        const annotationId = Number.parseInt(currentAnnotation.slot.split('-')[1])
        incrAnnotation = (annotationId >= numSpots)
            ? 1
            : annotationId + 1
    }
    selectAnnotation(mView, incrAnnotation)
    return incrAnnotation
}

/**
 * Select the previous numbered hotspot
 * 
 * @param {ModelViewer} mView
 * 
 * @return {number} ID number of the newly selected hotspot
 */
prevAnnotation = function(mView) {
    let decrAnnotation = 0
    const numSpots = [...mView.querySelectorAll('Button')].length
    const currentAnnotation = mView.querySelectorAll('Button:has(.HotspotAnnotation:not(.HiddenAnnotation))')[0]
    if (!currentAnnotation) {
        decrAnnotation = numSpots
    } else {
        const annotationId = Number.parseInt(currentAnnotation.slot.split('-')[1])
        decrAnnotation = (annotationId <= 1)
            ? numSpots
            : annotationId - 1
    }
    selectAnnotation(mView, decrAnnotation)
    return decrAnnotation
}

/**
 * Cycle through the available annotations
 * 
 * @param {ModelViewer} mView
 * 
 * @param {Number} [slideDuration = 5000]
 * 
 * @return {intervalID} ID of the created interval timer
 */
slideshowAnnotations = function(mView, slideDuration = 3000) {
    if (slideShowInterval) {
        clearInterval(slideShowInterval)
    } else {
        nextAnnotation(mView)
        slideShowInterval = setInterval(nextAnnotation, slideDuration, mView)
    }
}

/**
 * Toggle visibility of all annotations
 * 
 * @param {ModelViewer} mView 
 */
toggleAnnotations = function(mView) {
    if (slideShowInterval) {
        clearInterval(slideShowInterval)
        const slideButton = mView.parentElement.querySelector('[toggled]')
        if (slideButton) slideButton.toggleAttribute('toggled')
    }
    [...mView.querySelectorAll('button')].forEach( hs => {
        hs.toggleAttribute('hidden')
    })
    const hsButtons = [...mView.parentElement.querySelectorAll('.disable-on-hide')]
    hsButtons.forEach( mb => {
        mb.toggleAttribute('disabled')
    })
}

/**
 * Prepare to drag a hotspot
 * 
 * @param {MouseEvent} event
 */
grabAnnotation = function(e) {
    if (e.ctrlKey) {
        grabHotspot = {x: e.x, y: e.y}
        const contEl = $('.glmv-container')[0]
        contEl.addEventListener('mousemove', moveAnnotation)
        const mvEl = $('model-viewer')[0]
        console.log(contEl)
        console.log(e)
        console.log(mvEl.queryHotspot(e.target.slot))
    } else {
        grabHotspot = null
    }
}

/**
 * Drag currently clicked hotspot
 * 
 * @param {MouseEvent} event
 */
moveAnnotation = function(e) {
    if (grabHotspot) {
        grabHotspot.move = true
        e.target.style['transform'] = `translate(${e.x - grabHotspot.x}px, ${e.y - grabHotspot.y}px) scale(1.1,1.1)`
    }
}

/**
 * End dragging a hotspot and update information
 * 
 * @param {MouseEvent} event
 */
releaseAnnotation = function(e) {
    if (grabHotspot && grabHotspot.move) {
        console.log(e.target)
        e.target.style['transform']=''
        const contEl = $('.glmv-container')[0]
        contEl.removeEventListener('mousemove', moveAnnotation)
        const mvEl = $('model-viewer')[0]
        let newPosition = mvEl.positionAndNormalFromPoint(e.clientX, e.clientY)
        const newPos = newPosition.position.toString().replaceAll(/(\d{5})(\d*?m)/g,"$1m")
        const newNorm = newPosition.normal.toString().replaceAll(/(\d{5})(\d*?m)/g,"$1m")
        mvEl.updateHotspot({
            name: e.target.slot,
            position: newPos,
            normal: newNorm
        })
        let orbitObj = mvEl.getCameraOrbit()
        const newOrb = `${orbitObj.theta.toFixed(2)}rad ${orbitObj.phi.toFixed(2)}rad ${orbitObj.radius.toFixed(2)}m`
        e.target.setAttribute('data-orbit', newOrb)
        let targetObj = mvEl.getCameraTarget()
        const newTarg = `${targetObj.x.toFixed(5)}m ${targetObj.y.toFixed(5)}m ${targetObj.z.toFixed(5)}m`
        e.target.setAttribute('data-target', newTarg)
        let currentText = $('#wpTextbox1').val()
        let metadata = extractMetadata(currentText)
        metadata.annotations[e.target.childNodes[0].innerText] = {
            "data-position": newPos,
            "data-normal": newNorm,
            "data-orbit": newOrb,
            "data-target": newTarg
        }
        const newText = currentText.replace(/(.*?<pre>)[\S\s]*?(<\/pre>.*)/,`$1\n${JSON.stringify(metadata, null, 2)}\n$2`)
        $('#wpTextbox1').val(newText)
    }
    grabHotspot = null
}