export function convert (objText) {
	const lines = objText.split("\n");
	let smoothing = false;

	const positions = [];
	const uvs = [];
	const normals = [];

	const vertices = [];
	const indices = [];

	for (let i = 0; i < lines.length; i++) {
		const line = lines[i];
		const rawchunks = line.split(" ").map(x => x.trim());
		const chunks = [];
		for (let i = 0; i < rawchunks.length; i++) {
			if (rawchunks[i] != '') {
				chunks.push(rawchunks[i]);
			}
		}
		switch (chunks[0]) {
			case "v": {
				positions.push(chunks.splice(1).map(parseFloat));
				break;
			}
			case "vt": {
				const uv = chunks.splice(1);
				uvs.push([parseFloat(uv[0]), parseFloat(uv[1])]);
				break;
			}
			case "vn": {
				normals.push(chunks.splice(1).map(parseFloat));
				break;
			}
			case "s": {
				if (chunks[1] > 0) {
					smoothing = true;
				} else {
					smoothing = false;

				}
				break;
			}
			case "f": {
				const c1 = (smoothing ? "s" : "") + chunks[1];
				const c2 = (smoothing ? "s" : "") + chunks[2];
				const c3 = (smoothing ? "s" : "") + chunks[3];


				let index1 = vertices.indexOf(c1);
				if (index1 === -1) {
					index1 = vertices.length;
					vertices.push(c1);
				}

				let index2 = vertices.indexOf(c2);
				if (index2 === -1) {
					index2 = vertices.length;
					vertices.push(c2);
				}

				let index3 = vertices.indexOf(c3);
				if (index3 === -1) {
					index3 = vertices.length;
					vertices.push(c3);
				}

				indices.push(index1, index2, index3);
				break;
			}
		}
	}

	const avgNormals = [];
	for (let i = 0; i < vertices.length; i++) {
		if (vertices[i].startsWith("s")) {
			const d = vertices[i].substr(1).split("/");
			const normal = normals[d[2] - 1];
			const index = d[0] - 1;

			if (avgNormals[index]) {
				avgNormals[index][0] += normal[0];
				avgNormals[index][1] += normal[1];
				avgNormals[index][2] += normal[2];
			} else {
				avgNormals[index] = normal;
			}
		}
	}

	for (let n of avgNormals) {
		const len = Math.hypot(...n);
		avgNormals[avgNormals.indexOf(n)] = n.map(x => x / len);
	}

	const outPositions = [];
	const outNormals = [];
  	const outUVs = [];

	for (let i = 0; i < vertices.length; i++) {
		const d = (vertices[i].startsWith("s") ? vertices[i].substr(1) : vertices[i]).split("/");

		outPositions.push(...positions[d[0] - 1]);

		if (vertices[i].startsWith("s")) {
			outNormals.push(...avgNormals[d[0] - 1]);
		} else {
			outNormals.push(...normals[d[2] - 1]);
		}
		outUVs.push(...uvs[d[1] - 1]);
	}

	return [outPositions, outNormals, outUVs, indices];
};