/***
 * 
 * 
 * 
 * 
 * 
 * 
 */

async function loadedFun(type, len, uint32text){
	const num = Math.ceil(len*4/(1024*64));
	let memory = new WebAssembly.Memory({initial: 3+num});
	return fetch('/s/js/webc/wmjs/im.wasm').then(response=>response.arrayBuffer())
		.then(bytes=>WebAssembly.instantiate(bytes)).then(result=>{                
			let exports = result.instance.exports;                
			let uint32 = new Uint32Array(exports.memory.buffer);
			uint32.set(uint32text);
			let len_u32 = exports.mix_fun(type, len, uint32);        
			let uint8 = new Uint8Array(len_u32*4);
			for(let i = 0; i < len_u32; i++){
				uint8[4*i] = uint32[i] & 0xff;
				uint8[4*i+1] = uint32[i] >> 8 & 0xff;
				uint8[4*i+2] = uint32[i] >> 16 & 0xff;
				uint8[4*i+3] = uint32[i] >> 24 & 0xff;
			}
		return uint8; 
	}) 
}


async function byteToString(arr) {
	if (typeof arr === 'string') {
		return arr;
	}
	var str = '', _arr = arr;
	for (var i = 0; i < _arr.length; i++) {
		var one = _arr[i].toString(2),
			v = one.match(/^1+?(?=0)/);
		if (v && one.length == 8) {
			var bytesLength = v[0].length;
			var store = _arr[i].toString(2).slice(7 - bytesLength);
			for (var st = 1; st < bytesLength; st++) {
				store += _arr[st + i].toString(2).slice(2);
			}
			str += String.fromCodePoint(parseInt(store, 2));
			i += bytesLength - 1;
		} else {
			str += String.fromCodePoint(_arr[i]);
		}
	}
	return str;
}

async function ed_fun(type,  text){
	const encoder = new TextEncoder('utf-8');
	const decoder = new TextDecoder('utf-8');
	if(type === 1){
		const addstr = '____cinraw__';
		let addText = text.trim()+addstr.trim();
		const uirtext = encoder.encode(addText);
		const len = uirtext.length;       
		const len_add = len%16 ? 16 - len%16 : len%16;
		let enText = new Uint8Array(len+len_add);
		for(let i = 0; i < len; i++) enText[i] = uirtext[i];
		for(let i = 0; i < len_add; i++) enText[i+len] = '_'.codePointAt(0);         
		let uint32Text = new Uint32Array(enText.buffer, enText.byteOffset, enText.byteLength/4);
		const len_u32 = (len+len_add)/4
		return loadedFun(1,  len_u32,  uint32Text).then(res=>{
			let eddata = String.fromCodePoint(...res);
			const len_eddata = eddata.length%3 ? 3 - eddata.length%3 : eddata.length%3;
			for(let i = 0; i < len_eddata; i++) eddata += '_'
			return _Base64.encode(eddata)
		})
	}else if(type === 0){
		const detext = _Base64.decode(text)
		const len_debs64 = detext.length;
		const len_add = len_debs64%16 ? 16 - len_debs64%16 : len_debs64%16;
		const len_u = len_debs64+len_add
		const uint8Text = new Uint8Array(len_u);
		for(let i = 0; i < len_debs64; i++) uint8Text[i] = detext[i].codePointAt(0);
		for(let i = 0; i < len_add; i++) uint8Text[i+len_debs64] = '_'.codePointAt(0); 
		const uin32text = new Uint32Array(uint8Text.buffer, uint8Text.byteOffset, uint8Text.length/4);
		return loadedFun(0, uin32text.length, uin32text).then(str=>{  
			let rs = '';    
			// for(let i = 0; i < str.length; i++) {
			// 	const code = str[i];         
			// 	if((0XE0 & code) === 0XE0) {  
			// 		const code1 = str[i + 1];    
			// 		const code2 = str[i + 2];    
			// 		// rs += ((code & 15) << 12 | (code1 & 63) << 6 | (code2 & 63)).toString(16);
			// 		rs += ((code & 15) << 12 | (code1 & 63) << 6 | (code2 & 63)).fromCodePoint(0);
			// 		i += 2;    
			// 	// } else if((192 & code) === 192) {
			// 	} else if((0XC0 & code) === 0XC0) {
			// 		const code1 = str[i + 1];    
			// 		// rs += ((code & 31) << 6 | (code1 & 63)).toString(16);    
			// 		rs += ((code & 31) << 6 | (code1 & 63)).fromCodePoint(0);   
			// 		i++;    
			// 	} else if((128 & code) === 0) {    
			// 		rs += code;    
			// 	}    
			// }   
			console.log("b", decoder.decode(str))
			console.log("rs",  String.fromCodePoint(...str))
			console.log("rs", str)
			return decoder.decode(str);
		// return rs;
		})
	}
}