const uint8ToBuffer = array => array.buffer.slice(array.byteOffset, array.byteLength + array.byteOffset)
const bufferToUint8 = array => Array.from(new Uint8Array(array))
const updateDetails = info => document.querySelector("#details").innerHTML = info
const generateUint8 = length => (new Uint8Array(length)).map(() => Math.floor(Math.random() * 256))

let firstMessageTimeout

const timer = {
	time: 0,

	start() {
		return this.time = Date.now()
	},

	stop() {
		return this.time = Date.now() - this.time
	}
}

const concatUint8 = (...arrays) => {
		let totalLength = 0;
		for (const arr of arrays) {
				totalLength += arr.length;
		}
		const result = new Uint8Array(totalLength);
		let offset = 0;
		for (const arr of arrays) {
				result.set(arr, offset);
				offset += arr.length;
		}
		return result;
}

const download = (filename, blob) => {
		
	const blobUrl = URL.createObjectURL(blob)
	const tempLink = document.createElement("a")
	tempLink.href = blobUrl
	tempLink.download = filename
	document.body.appendChild(tempLink)
	// tempLink.dispatchEvent(
	// 	new MouseEvent('click', { 
	// 		bubbles: true, 
	// 		cancelable: true, 
	// 		view: window 
	// 	})
	// )
	tempLink.click()
	document.body.removeChild(tempLink)

}

const triggerFilePicker = () => new Promise((accept, reject) => {
	const tempInput = document.createElement("input")
	tempInput.type = "file"
	tempInput.accept = ".zip,.zrp"
	tempInput.oninput = (event) => {
		if (event.target.files.length === 0) reject()
		else {
			const file = event.target.files[0]
			accept(file)
		}
	}
	tempInput.dispatchEvent(
		new MouseEvent('click', { 
			bubbles: true, 
			cancelable: true, 
			view: window 
		})
	)
})

const stopPropagation = (e) => {
	e.stopPropagation()
	e.preventDefault()
}

const dropbox = document.querySelector("#dropbox")
dropbox.addEventListener("dragenter", (e) => {
	stopPropagation(e)
	dropbox.classList.add("dropping-down")
}, false)
dropbox.addEventListener("dragover", (e) => {
	stopPropagation(e)
	dropbox.classList.add("dropping-down")
}, false)
dropbox.addEventListener("dragleave", (e) => {
	stopPropagation(e)
	dropbox.classList.remove("dropping-down")
}, false)
dropbox.addEventListener("dragend", (e) => {
	stopPropagation(e)
	dropbox.classList.remove("dropping-down")
}, false)
dropbox.addEventListener("drop", (e) => {
	stopPropagation(e)
	dropbox.classList.remove("dropping-down")
	const dt = e.dataTransfer
	const files = dt.files
	handleFile(files[0])
}, false)
dropbox.addEventListener("click", async (e) => {
	stopPropagation(e)
	triggerFilePicker().then(file => handleFile(file))
}, false)

const handleFile = async (file) => {

	timer.start()
	
	const archiveFile = file
	const archiveName = file.name.substr(0, archiveFile.name.length - 4)
	const archiveType = file.name.substr(this.length - 3)
		
	let blob
	
	try {
		
		if (archiveType === "zrp") {
			
			const key = bufferToUint8(await archiveFile.slice(0, 16).arrayBuffer())
			const iv = key
			const cbc = new aesjs.ModeOfOperation.cbc(key, iv)
			updateDetails("Obtaining key...")

			const decryptedFile = cbc.decrypt(bufferToUint8(await archiveFile.slice(16).arrayBuffer())).slice(16)
			// DYK that C#'s implementation of AES (AESManaged) prepends a random data with a length of 16 bytes? Yeah, it's weird.
			updateDetails("Decrpyting...")
			
			download(`${archiveName}.zip`, new Blob([uint8ToBuffer(decryptedFile)], {type: 'application/zip'}))
			updateDetails(`<code>${archiveName}.zrp</code> has been decrypted to the <code>.zip</code> format in ${timer.stop()/1000} seconds.`)
			
		} else if (archiveType === "zip") {
		
			let key = generateUint8(16)
			const iv = key
			console.log(key)
			const cbc = new aesjs.ModeOfOperation.cbc(key, iv)
			updateDetails("Generating key...")
		
			let padding = new Uint8Array()
			if (await archiveFile.size % 16) {
				const paddingCount = 16 - archiveFile.size % 16
				padding = new Uint8Array(paddingCount)
				padding = padding.map(() => paddingCount)
			}
			updateDetails("Adding padding...")

			const encryptedFile = concatUint8(key, cbc.encrypt(concatUint8(generateUint8(16), bufferToUint8(await archiveFile.arrayBuffer()), padding)))
			// DYK that C#'s implementation of AES (AESManaged) prepends a random data with a length of 16 bytes? Yeah, it's weird.
			updateDetails("Encrypting...")
			
			download(`${archiveName}.zrp`, new Blob([uint8ToBuffer(encryptedFile)], {type: 'application/octet-stream'}))
			updateDetails(`<code>${archiveName}.zip</code> has been encrypted to the <code>.zrp</code> format in ${timer.stop()/1000} seconds.`)
			
		} else {
		
			throw "NotAnArchive"
		
		}

		} catch (e) {
	
		if (e === "NotAnArchive") updateDetails(`This is neither a <code>.zrp</code> archive nor a <code>.zip</code> archive!`)
		else updateDetails(`Something went wrong: ${e}`)
	
	} finally {
		
		try {clearInterval(firstMessageTimeout)}
		catch (e) {}
		firstMessageTimeout = setTimeout(() => updateDetails("Drop a <code>.zrp</code> archive to decrypt it or a <code>.zip</code> archive to encrypt it."), 10000)
		
	}	
	
}