CHOMPStation2/code/modules/tgui/modal.dm

/**
 * tgui modals
 *
 * Allows creation of modals within tgui.
 */

GLOBAL_LIST(tgui_modals)

/**
  * Call this from a proc that is called in tgui_act() to process modal actions
  *
  * Example: /obj/machinery/chem_master/proc/tgui_act_modal
  * You can then switch based on the return value and show different
  * modals depending on the answer.
  * Arguments:
  * * source - The source datum
  * * action - The called action
  * * params - The params to the action
  */
/datum/proc/tgui_modal_act(datum/source = src, action = "", params)
	ASSERT(istype(source))

	. = null
	switch(action)
		if("modal_open") // Params: id, arguments
			return TGUI_MODAL_OPEN
		if("modal_answer") // Params: id, answer, arguments
			params["answer"] = tgui_modal_preprocess_answer(source, params["answer"])
			if(tgui_modal_answer(source, params["id"], params["answer"])) // If there's a current modal with a delegate that returned TRUE, no need to continue
				. = TGUI_MODAL_DELEGATE
			else
				. = TGUI_MODAL_ANSWER
			tgui_modal_clear(source)
		if("modal_close") // Params: id
			tgui_modal_clear(source)
			return TGUI_MODAL_CLOSE

/**
  * Call this from tgui_data() to return modal information if needed

  * Arguments:
  * * source - The source datum
  */
/datum/proc/tgui_modal_data(datum/source = src)
	ASSERT(istype(source))

	var/datum/tgui_modal/current = LAZYACCESS(GLOB.tgui_modals, REF(source))
	if(!current)
		return null

	return current.to_data()

/**
  * Clears the current modal for a given datum
  *
  * Arguments:
  * * source - The source datum
  */
/datum/proc/tgui_modal_clear(datum/source = src)
	ASSERT(istype(source))

	LAZYINITLIST(GLOB.tgui_modals)
	var/datum/tgui_modal/previous = GLOB.tgui_modals[REF(source)]
	if(!previous)
		return FALSE

	for(var/i in 1 to length(GLOB.tgui_modals))
		var/key = GLOB.tgui_modals[i]
		if(previous == GLOB.tgui_modals[key])
			GLOB.tgui_modals.Cut(i, i + 1)
			break

	SStgui.update_uis(source)
	return TRUE

/**
  * Opens a message TGUI modal
  *
  * Arguments:
  * * source - The source datum
  * * id - The ID of the modal
  * * text - The text to display above the answers
  * * delegate - The proc to call when closed
  * * arguments - List of arguments passed to and from JS (mostly useful for chaining modals)
  */
/datum/proc/tgui_modal_message(datum/source = src, id, text = "Default modal message", delegate, arguments)
	ASSERT(length(id))

	var/datum/tgui_modal/modal = new(id, text, delegate, arguments)
	return tgui_modal_new(source, modal)

/**
  * Opens a text input TGUI modal
  *
  * Arguments:
  * * source - The source datum
  * * id - The ID of the modal
  * * text - The text to display above the answers
  * * delegate - The proc to call when submitted
  * * arguments - List of arguments passed to and from JS (mostly useful for chaining modals)
  * * value - The default value of the input
  * * max_length - The maximum char length of the input
  */
/datum/proc/tgui_modal_input(datum/source = src, id, text = "Default modal message", delegate, arguments, value = "", max_length = TGUI_MODAL_INPUT_MAX_LENGTH)
	ASSERT(length(id))
	ASSERT(max_length > 0)

	var/datum/tgui_modal/input/modal = new(id, text, delegate, arguments, value, max_length)
	return tgui_modal_new(source, modal)

/**
  * Opens a dropdown input TGUI modal
  *
  * Internally checks if the answer is in the list of choices.
  * Arguments:
  * * source - The source datum
  * * id - The ID of the modal
  * * text - The text to display above the answers
  * * delegate - The proc to call when submitted
  * * arguments - List of arguments passed to and from JS (mostly useful for chaining modals)
  * * value - The default value of the dropdown
  * * choices - The list of available choices in the dropdown
  */
/datum/proc/tgui_modal_choice(datum/source = src, id, text = "Default modal message", delegate, arguments, value = "", choices)
	ASSERT(length(id))

	var/datum/tgui_modal/input/choice/modal = new(id, text, delegate, arguments, value, choices)
	return tgui_modal_new(source, modal)

/**
  * Opens a bento input TGUI modal
  *
  * Internally checks if the answer is in the list of choices.
  * Arguments:
  * * source - The source datum
  * * id - The ID of the modal
  * * text - The text to display above the answers
  * * delegate - The proc to call when submitted
  * * arguments - List of arguments passed to and from JS (mostly useful for chaining modals)
  * * value - The default value of the bento
  * * choices - The list of available choices in the bento
  */
/datum/proc/tgui_modal_bento(datum/source = src, id, text = "Default modal message", delegate, arguments, value, choices)
	ASSERT(length(id))

	var/datum/tgui_modal/input/bento/modal = new(id, text, delegate, arguments, value, choices)
	return tgui_modal_new(source, modal)

//Bento but spritesheet edition
/datum/proc/tgui_modal_bento_spritesheet(datum/source = src, id, text = "Default modal message", delegate, arguments, value, choices)
	ASSERT(length(id))

	var/datum/tgui_modal/input/bento/spritesheet/modal = new(id, text, delegate, arguments, value, choices)
	return tgui_modal_new(source, modal)

/**
  * Opens a yes/no TGUI modal
  *
  * Arguments:
  * * source - The source datum
  * * id - The ID of the modal
  * * text - The text to display above the answers
  * * delegate - The proc to call when "Yes" is pressed
  * * delegate_no - The proc to call when "No" is pressed
  * * arguments - List of arguments passed to and from JS (mostly useful for chaining modals)
  * * yes_text - The text to show in the "Yes" button
  * * no_text - The text to show in the "No" button
  */
/datum/proc/tgui_modal_boolean(datum/source = src, id, text = "Default modal message", delegate, delegate_no, arguments, yes_text = "Yes", no_text = "No")
	ASSERT(length(id))

	var/datum/tgui_modal/boolean/modal = new(id, text, delegate, delegate_no, arguments, yes_text, no_text)
	return tgui_modal_new(source, modal)

/**
  * Registers a given modal to a source. Private.
  *
  * Arguments:
  * * source - The source datum
  * * modal - The datum/tgui_modal to register
  * * replace_previous - Whether any modal currently assigned to source should be replaced
  * * instant_update - Whether the changes should reflect immediately
  */
/datum/proc/tgui_modal_new(datum/source = src, datum/tgui_modal/modal = null, replace_previous = TRUE, instant_update = TRUE)
	ASSERT(istype(source))
	ASSERT(istype(modal))

	var/datum/tgui_modal/previous = LAZYACCESS(GLOB.tgui_modals, REF(source))
	if(previous && !replace_previous)
		return FALSE

	modal.owning_source = source

	// Previous one should get GC'd
	LAZYSET(GLOB.tgui_modals, REF(source), modal)
	if(instant_update)
		SStgui.update_uis(source)
	return TRUE

/**
  * Calls the source's currently assigned modal's (if there is one) on_answer() proc. Private.
  *
  * Arguments:
  * * source - The source datum
  * * id - The ID of the modal
  * * answer - The provided answer
  */
/datum/proc/tgui_modal_answer(datum/source = src, id, answer = "")
	ASSERT(istype(source))

	var/datum/tgui_modal/current = LAZYACCESS(GLOB.tgui_modals, REF(source))
	if(!current)
		return FALSE

	return current.on_answer(answer)

/**
  * Passes an answer from JS through the modal's proc.
  *
  * Used namely for cutting the text short if it's longer
  * than an input modal's max_length.
  * Arguments:
  * * source - The source datum
  * * answer - The provided answer
  */
/datum/proc/tgui_modal_preprocess_answer(datum/source = src, answer = "")
	ASSERT(istype(source))

	var/datum/tgui_modal/current = LAZYACCESS(GLOB.tgui_modals, REF(source))
	if(!current)
		return answer

	return current.preprocess_answer(answer)

/**
  * Modal datum (contains base information for a modal)
  */
/datum/tgui_modal
	var/datum/owning_source
	var/id
	var/text
	var/delegate
	var/list/arguments
	var/modal_type = "message"

/datum/tgui_modal/New(id, text, delegate, list/arguments)
	src.id = id
	src.text = text
	src.delegate = delegate
	src.arguments = arguments

/**
  * Called when it's time to pre-process the answer before using it
  *
  * Arguments:
  * * answer - The answer, a nullable text
  */
/datum/tgui_modal/proc/preprocess_answer(answer)
	return reject_bad_text(answer, TGUI_MODAL_INPUT_MAX_LENGTH) // bleh

/**
  * Called when a modal receives an answer
  *
  * Arguments:
  * * answer - The answer, a nullable text
  */
/datum/tgui_modal/proc/on_answer(answer)
	if(delegate)
		return call(owning_source, delegate)(answer, arguments)
	return FALSE

/**
  * Creates a list that describes a modal visually to be passed to JS
  */
/datum/tgui_modal/proc/to_data()
	. = list()
	.["id"] = id
	.["text"] = text
	.["args"] = arguments || list()
	.["type"] = modal_type

/**
  * Input modal - has a text entry that can be used to enter an answer
  */
/datum/tgui_modal/input
	modal_type = "input"
	var/value
	var/max_length

/datum/tgui_modal/input/New(id, text, delegate, list/arguments, value, max_length)
	..(id, text, delegate, arguments)
	src.value = value
	src.max_length = max_length

/datum/tgui_modal/input/preprocess_answer(answer)
	. = ..(answer)
	if(length(answer) > max_length)
		. = copytext(., 1, max_length + 1)

/datum/tgui_modal/input/to_data()
	. = ..()
	.["value"] = value

/**
  * Choice modal - has a dropdown menu that can be used to select an answer
  */
/datum/tgui_modal/input/choice
	modal_type = "choice"
	var/choices

/datum/tgui_modal/input/choice/New(id, text, delegate, list/arguments, value, choices)
	..(id, text, delegate, arguments, value, TGUI_MODAL_INPUT_MAX_LENGTH) // Max length doesn't really matter in dropdowns, but whatever
	src.choices = choices

/datum/tgui_modal/input/choice/on_answer(answer)
	if(answer in choices) // Make sure the answer is actually in our choices!
		return ..(answer, arguments)
	return FALSE

/datum/tgui_modal/input/choice/to_data()
	. = ..()
	.["choices"] = choices

/**
  * Bento modal - Similar to choice, it displays the choices in a grid of images
  *
  * The returned answer is the index of the choice.
  */
/datum/tgui_modal/input/bento
	modal_type = "bento"
	var/choices

/datum/tgui_modal/input/bento/New(id, text, delegate, list/arguments, value, choices)
	..(id, text, delegate, arguments, text2num(value), TGUI_MODAL_INPUT_MAX_LENGTH) // Max length doesn't really matter in here, but whatever
	src.choices = choices

/datum/tgui_modal/input/bento/preprocess_answer(answer)
	return text2num(answer) || 0

/datum/tgui_modal/input/bento/on_answer(answer)
	if(answer >= 1 && answer <= length(choices)) // Make sure the answer index is actually in our indexes!
		return ..(answer, arguments)
	return FALSE

/datum/tgui_modal/input/bento/to_data()
	. = ..()
	.["choices"] = choices

//Bento modal but takes spritesheet classes as choices
/datum/tgui_modal/input/bento/spritesheet
	modal_type = "bentospritesheet"

/**
  * Boolean modal - has yes/no buttons that do different actions depending on which is pressed
  */
/datum/tgui_modal/boolean
	modal_type = "boolean"
	var/delegate_no
	var/yes_text
	var/no_text

/datum/tgui_modal/boolean/New(id, text, delegate, delegate_no, list/arguments, yes_text, no_text)
	..(id, text, delegate, arguments)
	src.delegate_no = delegate_no
	src.yes_text = yes_text
	src.no_text = no_text

/datum/tgui_modal/boolean/preprocess_answer(answer)
	return text2num(answer) || FALSE

/datum/tgui_modal/boolean/on_answer(answer)
	if(answer)
		return ..(answer, arguments)
	else if(delegate_no)
		return call(owning_source, delegate_no)(arguments)
	return FALSE

/datum/tgui_modal/boolean/to_data()
	. = ..()
	.["yes_text"] = yes_text
	.["no_text"] = no_text