# plicflix para Godot 4 (exportação Web). Guia: https://developers.plicflix.com/docs/MOTORES
#
# 1. Em Projeto → Exportar → Web → "Head Include", ponha:  <script src="plicflix.js"></script>
#    e copie o plicflix.js para a pasta exportada (ou use https://sdk.plicflix.com/plicflix.js).
# 2. Ponha este arquivo como Autoload com o nome "Plicflix" (Projeto → Configurações → Autoload).
# 3. No seu jogo:
#      Plicflix.progresso(30, "Carregando…")
#      var r = await Plicflix.entrar("/api/plicflix/entrar")   # o SEU servidor troca o token
#      Plicflix.pronto()
#      Plicflix.ao_sair = func(): salvar()                      # tem 4,5 s
#      Plicflix.onde({"texto": "Taverna", "area": "cidade/taverna"})
extends Node

signal entrou(resposta: Dictionary)
signal falhou(erro: String)

## Chamado quando o jogador toca em "Sair": salve aqui (síncrono ou com await).
var ao_sair: Callable
## "Ir até o amigo": recebe o destino (Dictionary) e devolve true/false.
var ao_ir_para: Callable

var _sdk: JavaScriptObject
var _cbs := []  # guarda os callbacks vivos (o Godot solta os que ninguém referencia)

func _ready() -> void:
	if not OS.has_feature("web"):
		return
	_sdk = JavaScriptBridge.get_interface("Plicflix")
	if _sdk == null or not dentro():
		return
	var sair_cb := JavaScriptBridge.create_callback(_on_sair)
	var ir_cb := JavaScriptBridge.create_callback(_on_ir_para)
	_cbs.append_array([sair_cb, ir_cb])
	# o SDK espera uma Promise: embrulhamos o callback do Godot numa
	JavaScriptBridge.eval("""
		window.__plicflixGodot = {
			sair: null, foi: null,
			aoSair: function (cb) { Plicflix.aoSair(function () { return new Promise(function (ok) { window.__plicflixGodot.sair = ok; cb(); setTimeout(ok, 4500); }); }); },
			aoIrPara: function (cb) { Plicflix.aoIrPara(function (d) { return new Promise(function (ok) { window.__plicflixGodot.foi = ok; cb(JSON.stringify(d || {})); setTimeout(function () { ok({ ok: false }); }, 8000); }); }); }
		};
	""", true)
	var ponte := JavaScriptBridge.get_interface("__plicflixGodot")
	ponte.aoSair(sair_cb)
	ponte.aoIrPara(ir_cb)

## O jogo foi aberto pelo plicflix?
func dentro() -> bool:
	return _sdk != null and bool(_sdk.dentro())

func progresso(pct: int, texto: String = "") -> void:
	if _sdk: _sdk.progresso(pct, texto)

func pronto() -> void:
	if _sdk: _sdk.pronto()

func erro(texto: String) -> void:
	if _sdk: _sdk.erro(texto)

## o: {"texto": "...", "area": "...", "ponto": {...}}
func onde(o: Dictionary) -> void:
	if _sdk: JavaScriptBridge.eval("Plicflix.onde(%s)" % JSON.stringify(o), true)

func abrir_amigos() -> void:
	if _sdk: _sdk.abrirAmigos()

func sair() -> void:
	if _sdk: _sdk.sair()

## O SEU servidor troca o token (recomendado). Devolve a resposta dele (Dictionary) ou {} se falhar.
func entrar(url: String) -> Dictionary:
	if _sdk == null:
		return {}
	return await _esperar(_sdk.entrar(url))

## Jogo sem servidor: só para mostrar o nome e salvar local (não protege nada de valor).
func jogador() -> Dictionary:
	if _sdk == null:
		return {}
	return await _esperar(_sdk.jogador())

signal _resposta(id: int, texto: String)
var _seq := 0

# espera uma Promise do SDK e devolve o resultado como Dictionary
# (cada espera tem o seu número: duas ao mesmo tempo não se misturam)
func _esperar(promessa: JavaScriptObject) -> Dictionary:
	_seq += 1
	var meu := _seq
	var json_js := JavaScriptBridge.get_interface("JSON")
	var ok_cb := JavaScriptBridge.create_callback(func(a): _resposta.emit(meu, "ok:" + str(json_js.stringify(a[0]))))
	var erro_cb := JavaScriptBridge.create_callback(func(a): _resposta.emit(meu, "erro:" + str(a[0].message if a[0] is JavaScriptObject else a[0])))
	_cbs.append_array([ok_cb, erro_cb])
	promessa.then(ok_cb, erro_cb)
	var r := ""
	while true:
		var veio: Array = await _resposta
		if veio[0] == meu:
			r = veio[1]
			break
	if r.begins_with("ok:"):
		var d = JSON.parse_string(r.substr(3))
		if d is Dictionary:
			entrou.emit(d)
			return d
		return {}
	falhou.emit(r.substr(5))
	return {}

func _on_sair(_args) -> void:
	if ao_sair.is_valid():
		await ao_sair.call()
	JavaScriptBridge.eval("window.__plicflixGodot.sair && window.__plicflixGodot.sair()", true)

func _on_ir_para(args) -> void:
	var destino = JSON.parse_string(str(args[0]))
	var ok := false
	if ao_ir_para.is_valid():
		ok = bool(await ao_ir_para.call(destino))
	JavaScriptBridge.eval("window.__plicflixGodot.foi && window.__plicflixGodot.foi({ ok: %s })" % ("true" if ok else "false"), true)