#!/usr/bin/env node
const { isAbsolute, resolve } = require('path')
let esm = global.esm = {
	parseArgs( args, opt = esm.argsopt )
	{
		for( let [ reg, fn ] of opt.entries() )
			args = args.filter( s=> reg.test(s) )
						.map( s=> reg.exec(s) )
						// .reduce( fn, Object.assign(args.filter( s=> !reg.test(s) ),args))
						.reduce( fn, 
							Object.assign(
								args.filter( s=> !reg.test(s) ),
								esm.getArgsKV(args)
							)
						)
		return args
	},
	argsopt: new Map()
		.set( /^-{1,2}(?<key>.*?)([:=](?<value>.*?))?$/
		,	(args,{groups:{key,value}})=> 
				Object.assign( args, {[key]: value || true} )
		)
		.set( /^\+(?<module>.*?)$/
		,	(args,{groups:{module}})=> 
				(( args.imports = args.imports || [] ).push( module ), args )
		)
		.set( /^=(?<key>.*?)([:=](?<value>.*?))?$/
		,	(args,{groups:{key,value}})=> 
				(Object.assign( args.flags = args.flags || {}, {[key]: value || true} )
				, args)
		),
	getArgsKV: args=> Object.keys(args)
						.filter(isNaN)
						.reduce((o,k)=>({...o,[k]:args[k]}),{}),

	softResolve: str=> {
		try{
			return require.resolve(str)
		}catch(e){return false}
	},

	searchInPathes: str=> ['.',...process.env.PATH.split(';')]
								.map( dir=> require('path').resolve(dir+'/'+str) )
								.filter( path=> esm.softResolve(path) )[0]

}

process.arguments = esm.parseArgs( process.argv.slice(2) )
process.arguments.flags = Object.assign( { json: false }, process.arguments.flags )

const splitted = (process.arguments.shift() || '').split(':')

// Issue on Windows: Volume letter is splitted ( ['C','Program files/module.js','export']
if( process.platform == 'win32' && splitted[0].length == 1 && isAbsolute(splitted[0]+':\\') )
{
	splitted[1] = splitted[0]+':'+splitted[1]
	splitted.shift()

}

// Issue on MINGW64: /c/dir/module:export is not transformed to C:/dir/module:export
let res
// Transforms a fake linux Windows path to Windows path
// Ex: /c/Program\ files/ >> C:/Program\ files
if( res = splitted[0].match(/^\/([a-zA-Z])\//) )
	splitted[0] = splitted[0].replace( /^\/./, res[1].toUpperCase()+':' )

const exported = splitted.length == 1 ? undefined : splitted.pop()
const esmodule = splitted.join(':')
,	package = esm.softResolve('./package.json')
//,	modulo = isAbsolute(esmodule) ? esmodule : resolve( esmodule )
,	modulo = isAbsolute(esmodule) ? esm.softResolve(esmodule) : esm.searchInPathes(esmodule)

if( process.arguments.flags.debug )
{
	console.log( process.cwd(), package )
	console.log( `
process.argv: %o
esmodule: %o
isAbsolute: %o
modulo: %o
package: %o
exported: %o
process.arguments: %o
`, 
	process.argv, esmodule, isAbsolute(esmodule), modulo, package ? require(package).module : 'no package', exported, process.arguments )
}

process.arguments.flags.dry && process.exit()
require = require('esm')( module, {await: true} )


const render = esm.render = obj=>
		process.arguments.flags.json
			? render.json( obj )
			: render.log( obj )
			// ? process.stdout.write( obj&& JSON.stringify(obj,null,'\t') || '' )
			// : console.log( obj || '' )
render.json = obj=> process.stdout.write( obj && JSON.stringify(obj,null,'\t') || '' )
render.log = obj=> console.log( obj || '' )


let mod = require( modulo || resolve(require(package).module) )
process.arguments.flags.debug
	 && console.log(mod)

let toCall = mod[ exported || 'default' ]
process.arguments.flags.debug
	 && console.log(mod, exported, toCall)

let returned =
		typeof toCall == 'function'
				? toCall( process.arguments )
				: toCall
process.arguments.flags.debug
	 && console.log( 'type' , typeof returned, returned instanceof Promise )

returned instanceof Promise
		? returned.then( render, e=>console.error(e) )
		: render(returned)

module.exports = mod