# _bgfx_bin2c_parse(
#	INPUT_FILE filename
#	OUTPUT_FILE filename
#	ARRAY_NAME name
# )
# Usage: bin2c -f <in> -o <out> -n <name>
function(_bgfx_bin2c_parse ARG_OUT)
	set(options "")
	set(oneValueArgs INPUT_FILE;OUTPUT_FILE;ARRAY_NAME)
	set(multiValueArgs "")
	cmake_parse_arguments(ARG "${options}" "${oneValueArgs}" "${multiValueArgs}" "${ARGN}")
	set(CLI "")

	# -f
	if(ARG_INPUT_FILE)
		list(APPEND CLI "-f" "${ARG_INPUT_FILE}")
	else()
		message(SEND_ERROR "Call to _bgfx_bin2c_parse() must have an INPUT_FILE")
	endif()

	# -o
	if(ARG_OUTPUT_FILE)
		list(APPEND CLI "-o" "${ARG_OUTPUT_FILE}")
	else()
		message(SEND_ERROR "Call to _bgfx_bin2c_parse() must have an OUTPUT_FILE")
	endif()

	# -n
	if(ARG_ARRAY_NAME)
		list(APPEND CLI "-n" "${ARG_ARRAY_NAME}")
	else()
		message(SEND_ERROR "Call to _bgfx_bin2c_parse() must have an ARRAY_NAME")
	endif()

	set(${ARG_OUT} ${CLI} PARENT_SCOPE)
endfunction()

# bgfx_compile_binary_to_header(
#	INPUT_FILE filename
#	OUTPUT_FILE filename
#	ARRAY_NAME name
# )
#
function(bgfx_compile_binary_to_header)
	set(options "")
	set(oneValueArgs INPUT_FILE;OUTPUT_FILE;ARRAY_NAME)
	set(multiValueArgs "")
	cmake_parse_arguments(ARG "${options}" "${oneValueArgs}" "${multiValueArgs}" "${ARGN}")
	_bgfx_bin2c_parse(
		CLI
		INPUT_FILE ${ARG_INPUT_FILE}
		OUTPUT_FILE ${ARG_OUTPUT_FILE}
		ARRAY_NAME ${ARG_ARRAY_NAME}
	)
	add_custom_command(
		OUTPUT ${ARG_OUTPUT_FILE} #
		COMMAND bgfx::bin2c ${CLI} #
		MAIN_DEPENDENCY ${ARG_INPUT_FILE} #
	)
endfunction()

# _bgfx_texturec_parse(
#	FILE filename
#	OUTPUT filename
#	[FORMAT format]
#	[QUALITY default|fastest|highest]
#	[MIPS]
#	[MIPSKIP N]
#	[NORMALMAP]
#	[EQUIRECT]
#	[STRIP]
#	[SDF]
#	[REF alpha]
#	[IQA]
#	[PMA]
#	[LINEAR]
#	[MAX max size]
#	[RADIANCE model]
#	[AS extension]
# )
function(_bgfx_texturec_parse ARG_OUT)
	cmake_parse_arguments(
		ARG "MIPS;NORMALMAP;EQUIRECT;STRIP;SDF;IQA;PMA;LINEAR" "FILE;OUTPUT;FORMAT;QUALITY;MIPSKIP;REF;MAX;RADIANCE;AS"
		"" ${ARGN}
	)
	set(CLI "")

	# -f
	if(ARG_FILE)
		list(APPEND CLI "-f" "${ARG_FILE}")
	endif()

	# -o
	if(ARG_OUTPUT)
		list(APPEND CLI "-o" "${ARG_OUTPUT}")
	endif()

	# -t
	if(ARG_FORMAT)
		list(APPEND CLI "-t" "${ARG_FORMAT}")
	endif()

	# -q
	if(ARG_QUALITY)
		list(APPEND CLI "-q" "${ARG_QUALITY}")
	endif()

	# --mips
	if(ARG_MIPS)
		list(APPEND CLI "--mips")
	endif()

	# --mipskip
	if(ARG_MIPSKIP)
		list(APPEND CLI "--mipskip" "${ARG_MIPSKIP}")
	endif()

	# --normalmap
	if(ARG_NORMALMAP)
		list(APPEND CLI "--normalmap")
	endif()

	# --equirect
	if(ARG_EQUIRECT)
		list(APPEND CLI "--equirect")
	endif()

	# --strip
	if(ARG_STRIP)
		list(APPEND CLI "--strip")
	endif()

	# --sdf
	if(ARG_SDF)
		list(APPEND CLI "--sdf")
	endif()

	# --ref
	if(ARG_REF)
		list(APPEND CLI "--ref" "${ARG_REF}")
	endif()

	# --iqa
	if(ARG_IQA)
		list(APPEND CLI "--iqa")
	endif()

	# --pma
	if(ARG_PMA)
		list(APPEND CLI "--pma")
	endif()

	# --linear
	if(ARG_LINEAR)
		list(APPEND CLI "--linear")
	endif()

	# --max
	if(ARG_MAX)
		list(APPEND CLI "--max" "${ARG_MAX}")
	endif()

	# --radiance
	if(ARG_RADIANCE)
		list(APPEND CLI "--radiance" "${ARG_RADIANCE}")
	endif()

	# --as
	if(ARG_AS)
		list(APPEND CLI "--as" "${ARG_AS}")
	endif()

	set(${ARG_OUT} ${CLI} PARENT_SCOPE)
endfunction()

# bgfx_compile_texture(
#	FILE filename
#	OUTPUT filename
#	[FORMAT format]
#	[QUALITY default|fastest|highest]
#	[MIPS]
#	[MIPSKIP N]
#	[NORMALMAP]
#	[EQUIRECT]
#	[STRIP]
#	[SDF]
#	[REF alpha]
#	[IQA]
#	[PMA]
#	[LINEAR]
#	[MAX max size]
#	[RADIANCE model]
#	[AS extension]
# )
#
function(bgfx_compile_texture)
	cmake_parse_arguments(
		ARG "MIPS;NORMALMAP;EQUIRECT;STRIP;SDF;IQA;PMA;LINEAR" "FILE;OUTPUT;FORMAT;QUALITY;MIPSKIP;REF;MAX;RADIANCE;AS"
		"" ${ARGN}
	)
	_bgfx_texturec_parse(CLI ${ARGV})
	add_custom_command(
		OUTPUT ${ARG_OUTPUT} #
		COMMAND bgfx::texturec ${CLI} #
		MAIN_DEPENDENCY ${ARG_INPUT} #
	)
endfunction()

# _bgfx_shaderc_parse(
#	FILE filename
#	OUTPUT filename
#	FRAGMENT|VERTEX|COMPUTE
#	ANDROID|ASM_JS|IOS|LINUX|NACL|OSX|WINDOWS
#	[PROFILE profile]
#	[O 0|1|2|3]
#	[VARYINGDEF filename]
#	[BIN2C filename]
#	[INCLUDES include;include]
#	[DEFINES include;include]
#	[DEPENDS]
#	[PREPROCESS]
#	[RAW]
#	[VERBOSE]
#	[DEBUG]
#	[DISASM]
#	[WERROR]
# )
function(_bgfx_shaderc_parse ARG_OUT)
	cmake_parse_arguments(
		ARG
		"DEPENDS;ANDROID;ASM_JS;IOS;LINUX;NACL;OSX;WINDOWS;PREPROCESS;RAW;FRAGMENT;VERTEX;COMPUTE;VERBOSE;DEBUG;DISASM;WERROR"
		"FILE;OUTPUT;VARYINGDEF;BIN2C;PROFILE;O"
		"INCLUDES;DEFINES"
		${ARGN}
	)
	set(CLI "")

	# -f
	if(ARG_FILE)
		list(APPEND CLI "-f" "${ARG_FILE}")
	endif()

	# -i
	if(ARG_INCLUDES)
		foreach(INCLUDE ${ARG_INCLUDES})
			list(APPEND CLI "-i")
			list(APPEND CLI "${INCLUDE}")
		endforeach()
	endif()

	# -o
	if(ARG_OUTPUT)
		list(APPEND CLI "-o" "${ARG_OUTPUT}")
	endif()

	# --bin2c
	if(ARG_BIN2C)
		list(APPEND CLI "--bin2c" "${ARG_BIN2C}")
	endif()

	# --depends
	if(ARG_DEPENDS)
		list(APPEND CLI "--depends")
	endif()

	# --platform
	set(PLATFORM "")
	set(PLATFORMS "ANDROID;ASM_JS;IOS;LINUX;NACL;OSX;WINDOWS")
	foreach(P ${PLATFORMS})
		if(ARG_${P})
			if(PLATFORM)
				message(SEND_ERROR "Call to _bgfx_shaderc_parse() cannot have both flags ${PLATFORM} and ${P}.")
				return()
			endif()
			set(PLATFORM "${P}")
		endif()
	endforeach()
	if(PLATFORM STREQUAL "")
		message(SEND_ERROR "Call to _bgfx_shaderc_parse() must have a platform flag: ${PLATFORMS}")
		return()
	elseif(PLATFORM STREQUAL ANDROID)
		list(APPEND CLI "--platform" "android")
	elseif(PLATFORM STREQUAL ASM_JS)
		list(APPEND CLI "--platform" "asm.js")
	elseif(PLATFORM STREQUAL IOS)
		list(APPEND CLI "--platform" "ios")
	elseif(PLATFORM STREQUAL NACL)
		list(APPEND CLI "--platform" "nacl")
	elseif(PLATFORM STREQUAL OSX)
		list(APPEND CLI "--platform" "osx")
	elseif(PLATFORM STREQUAL UNIX)
		list(APPEND CLI "--platform" "linux")
	elseif(PLATFORM STREQUAL WINDOWS)
		list(APPEND CLI "--platform" "windows")
	endif()

	# --preprocess
	if(ARG_PREPROCESS)
		list(APPEND CLI "--preprocess")
	endif()

	# --define
	if(ARG_DEFINES)
		list(APPEND CLI "--defines")
		set(DEFINES "")
		foreach(DEFINE ${ARG_DEFINES})
			if(NOT "${DEFINES}" STREQUAL "")
				set(DEFINES "${DEFINES}\\\\;${DEFINE}")
			else()
				set(DEFINES "${DEFINE}")
			endif()
		endforeach()
		list(APPEND CLI "${DEFINES}")
	endif()

	# --raw
	if(ARG_RAW)
		list(APPEND CLI "--raw")
	endif()

	# --type
	set(TYPE "")
	set(TYPES "FRAGMENT;VERTEX;COMPUTE")
	foreach(T ${TYPES})
		if(ARG_${T})
			if(TYPE)
				message(SEND_ERROR "Call to _bgfx_shaderc_parse() cannot have both flags ${TYPE} and ${T}.")
				return()
			endif()
			set(TYPE "${T}")
		endif()
	endforeach()
	if("${TYPE}" STREQUAL "")
		message(SEND_ERROR "Call to _bgfx_shaderc_parse() must have a type flag: ${TYPES}")
		return()
	elseif("${TYPE}" STREQUAL "FRAGMENT")
		list(APPEND CLI "--type" "fragment")
	elseif("${TYPE}" STREQUAL "VERTEX")
		list(APPEND CLI "--type" "vertex")
	elseif("${TYPE}" STREQUAL "COMPUTE")
		list(APPEND CLI "--type" "compute")
	endif()

	# --varyingdef
	if(ARG_VARYINGDEF)
		list(APPEND CLI "--varyingdef" "${ARG_VARYINGDEF}")
	endif()

	# --verbose
	if(ARG_VERBOSE)
		list(APPEND CLI "--verbose")
	endif()

	# --debug
	if(ARG_DEBUG)
		list(APPEND CLI "--debug")
	endif()

	# --disasm
	if(ARG_DISASM)
		list(APPEND CLI "--disasm")
	endif()

	# --profile
	if(ARG_PROFILE)
		list(APPEND CLI "--profile" "${ARG_PROFILE}")
	endif()

	# -O
	if(ARG_O)
		list(APPEND CLI "-O" "${ARG_O}")
	endif()

	# --Werror
	if(ARG_WERROR)
		list(APPEND CLI "--Werror")
	endif()

	set(${ARG_OUT} ${CLI} PARENT_SCOPE)
endfunction()

function(_bgfx_get_profile_ext PROFILE PROFILE_EXT)
	string(REPLACE 300_es essl PROFILE ${PROFILE})
	string(REPLACE 120 glsl PROFILE ${PROFILE})
	string(REPLACE spirv spv PROFILE ${PROFILE})
	string(REPLACE metal mtl PROFILE ${PROFILE})
	string(REPLACE s_3_0 dx9 PROFILE ${PROFILE})
	string(REPLACE s_4_0 dx10 PROFILE ${PROFILE})
	string(REPLACE s_5_0 dx11 PROFILE ${PROFILE})

	set(${PROFILE_EXT} ${PROFILE} PARENT_SCOPE)
endfunction()

# bgfx_compile_shader_to_header(
# 	TYPE VERTEX|FRAGMENT|COMPUTE
# 	SHADERS filenames
# 	VARYING_DEF filename
# 	OUTPUT_DIR directory
# )
#
function(bgfx_compile_shader_to_header)
	set(options "")
	set(oneValueArgs TYPE VARYING_DEF OUTPUT_DIR)
	set(multiValueArgs SHADERS)
	cmake_parse_arguments(ARGS "${options}" "${oneValueArgs}" "${multiValueArgs}" "${ARGN}")

	set(PROFILES 120 300_es spirv) # pssl
	if(UNIX AND NOT APPLE)
		set(PLATFORM LINUX)
	elseif(EMSCRIPTEN)
		set(PLATFORM ASM_JS)
	elseif(APPLE)
		set(PLATFORM OSX)
		list(APPEND PROFILES metal)
	elseif(
		WIN32
		OR MINGW
		OR MSYS
		OR CYGWIN
	)
		set(PLATFORM WINDOWS)
		if(ARGS_TYPE STREQUAL "VERTEX" OR ARGS_TYPE STREQUAL "FRAGMENT")
			list(APPEND PROFILES s_3_0)
			list(APPEND PROFILES s_4_0)
			list(APPEND PROFILES s_5_0)
		elseif(ARGS_TYPE STREQUAL "COMPUTE")
			list(APPEND PROFILES s_4_0)
			list(APPEND PROFILES s_5_0)
		else()
			message(error "shaderc: Unsupported type")
		endif()
	else()
		message(error "shaderc: Unsupported platform")
	endif()

	foreach(SHADER_FILE ${ARGS_SHADERS})
		source_group("Shaders" FILES "${SHADER}")
		get_filename_component(SHADER_FILE_BASENAME ${SHADER_FILE} NAME)
		get_filename_component(SHADER_FILE_NAME_WE ${SHADER_FILE} NAME_WE)
		get_filename_component(SHADER_FILE_ABSOLUTE ${SHADER_FILE} ABSOLUTE)

		# Build output targets and their commands
		set(OUTPUTS "")
		set(COMMANDS "")
		foreach(PROFILE ${PROFILES})
			_bgfx_get_profile_ext(${PROFILE} PROFILE_EXT)
			set(OUTPUT ${ARGS_OUTPUT_DIR}/${SHADER_FILE_BASENAME}.${PROFILE_EXT}.bin.h)
			set(PLATFORM_I ${PLATFORM})
			if(PROFILE STREQUAL "spirv")
				set(PLATFORM_I LINUX)
			endif()
			_bgfx_shaderc_parse(
				CLI #
				${ARGS_TYPE} ${PLATFORM_I} WERROR "$<$<CONFIG:debug>:DEBUG>$<$<CONFIG:relwithdebinfo>:DEBUG>"
				FILE ${SHADER_FILE_ABSOLUTE}
				OUTPUT ${OUTPUT}
				PROFILE ${PROFILE}
				O "$<$<CONFIG:debug>:0>$<$<CONFIG:release>:3>$<$<CONFIG:relwithdebinfo>:3>$<$<CONFIG:minsizerel>:3>"
				VARYINGDEF ${ARGS_VARYING_DEF}
				INCLUDES ${BGFX_SHADER_INCLUDE_PATH}
				BIN2C BIN2C ${SHADER_FILE_NAME_WE}_${PROFILE_EXT}
			)
			list(APPEND OUTPUTS ${OUTPUT})
			list(APPEND COMMANDS COMMAND bgfx::shaderc ${CLI})
		endforeach()

		add_custom_command(
			OUTPUT ${OUTPUTS}
			COMMAND ${CMAKE_COMMAND} -E make_directory ${ARGS_OUTPUT_DIR} ${COMMANDS}
			MAIN_DEPENDENCY ${SHADER_FILE_ABSOLUTE}
			DEPENDS ${ARGS_VARYING_DEF}
		)
	endforeach()
endfunction()