// Tipos do SDK do navegador do plicflix (plicflix.js 2.3).
// Guia: https://developers.plicflix.com/docs/SDK

/** O contexto da partida, vindo do app do plicflix. */
export interface PlicflixContexto {
  ref: "plicflix";
  /** ex.: "pt-BR", "en", "es" */
  idioma: string;
  plataforma: "web" | "android" | "ios" | "desktop" | "tv";
}

/** A resposta da troca do token (no SEU servidor, ou pelo Plicflix.jogador()). */
export interface PlicflixTroca {
  jogador: {
    /** "pf_" + 24 caracteres: fixo para esta pessoa NESTE jogo. Use como chave da conta. */
    id: string;
    /** o apelido no plicflix (pode mudar: atualize a cada entrada) */
    nome: string;
  };
  /** o identificador (slug) do seu jogo */
  jogo: string;
  /** a partida ("pt_…") */
  partida: string;
  /** se a pessoa tem a assinatura ativa (testadores podem jogar sem) */
  assinante: boolean;
  contexto: PlicflixContexto;
  /** true quando veio do Plicflix.jogador() (troca feita no navegador: não confiável) */
  pelo_navegador?: boolean;
}

/** Onde o jogador está (amigos veem; "ir até" leva para o ponto). */
export interface PlicflixOnde {
  /** o que as pessoas leem: "Taverna do Porto" (até 60 caracteres) */
  texto: string;
  /** um caminho estável para agrupar: "cidade/taverna" (até 60; minúsculas, números e / _ . -) */
  area?: string;
  /** o ponto exato, no formato que o SEU jogo entende (objeto JSON de até 1 KB; volta no aoIrPara) */
  ponto?: Record<string, unknown>;
}

/** Para onde levar o jogador ("ir até o amigo" / "chamar para cá"). */
export interface PlicflixDestino extends Partial<PlicflixOnde> {
  /** o código de QUEM ESTÁ LÁ, no SEU jogo (o mesmo id da troca do token) */
  jogador_id: string;
  /** o apelido de quem está lá */
  jogador: string;
  /** o slug do seu jogo */
  jogo: string;
}

/** A resposta do aoIrPara: true/false ou { ok, motivo }. */
export type PlicflixResultado = boolean | void | { ok?: boolean; motivo?: string };

export interface PlicflixSDK {
  readonly versao: string;
  /** O jogo foi aberto pelo plicflix? (token no endereço ou ?ref=plicflix) */
  dentro(): boolean;
  /** O token de uso único (5 min ou 1 troca), ou null. */
  token(): string | null;
  contexto(): PlicflixContexto;
  /**
   * Manda { token, contexto } (POST JSON, com cookies) para o SEU servidor, que troca
   * o token na API do plicflix com a chave pk_ e abre a sessão. Devolve a resposta do
   * seu servidor. Rejeita se o seu servidor responder erro.
   */
  entrar<T = unknown>(urlDoSeuServidor: string, opcoes?: { credentials?: RequestCredentials; headers?: Record<string, string> }): Promise<T>;
  /** Jogo SEM servidor: troca no navegador (só na origem do jogo). Não confiável para nada de valor. */
  jogador(): Promise<PlicflixTroca>;
  /** Andamento do carregamento (0–100) e um texto curto. */
  progresso(pct: number, texto?: string): void;
  /** O jogo está pronto: o plicflix tira a tela de carregamento. */
  pronto(): void;
  /** Deu errado: a tela de carregamento mostra o texto e "tentar de novo". */
  erro(texto: string): void;
  /** Ao tocar em "Sair" na bolha: salve aqui. O plicflix espera a Promise (até 5 s). */
  aoSair(fn: () => void | Promise<unknown>): void;
  /** Pede ao plicflix para fechar o jogo (o aoSair roda antes). */
  sair(): void;
  /** Onde o jogador está (texto ou objeto). Mande ao mudar de lugar; o mesmo lugar repetido é ignorado. */
  onde(onde: string | PlicflixOnde): void;
  /** "Ir até o amigo"/"chamar para cá": leve o jogador ao ponto e devolva o resultado. */
  aoIrPara(fn: (destino: PlicflixDestino) => PlicflixResultado | Promise<PlicflixResultado>): void;
  /** Abre a lista de amigos do plicflix por cima do jogo. */
  abrirAmigos(): void;

  // ---- "Entrar com Plicflix" (fora do app — OAuth 2.0 + PKCE, /docs/OAUTH) ----
  /** Vai para plicflix.com/oauth/authorize (o PKCE e o state ficam na aba). `volta` precisa estar cadastrado no developers. */
  entrarComPlicflix(opcoes: PlicflixOpcoesOAuth): Promise<void>;
  /**
   * Na página de volta: confere o state e troca o código — no SEU servidor (`servidor`, recomendado:
   * recebe { code, code_verifier, redirect_uri }) ou direto na API (cliente público). null se não há ?code.
   * Recusado: rejeita com .codigo = "access_denied".
   */
  voltouDoPlicflix<T = PlicflixEntradaOAuth>(opcoes?: { servidor?: string; api?: string; credentials?: RequestCredentials; headers?: Record<string, string> }): Promise<T | null>;
  /** O botão oficial "Entrar com Plicflix" dentro de `onde`. Com `href`, vira um link para a SUA rota de login. */
  botaoEntrar(onde: string | Element, opcoes: Partial<PlicflixOpcoesOAuth> & { href?: string; texto?: string; largura?: string; tema?: "escuro" | "claro" }): HTMLElement;
}

export interface PlicflixOpcoesOAuth {
  /** O client_id: o slug do jogo. */
  cliente: string;
  /** O redirect_uri cadastrado (developers → o jogo → Integração). */
  volta: string;
  /** "consent": pergunta de novo mesmo se o jogador já autorizou. */
  prompt?: "consent";
  /** Outro plicflix (testes): padrão https://plicflix.com */
  plicflix?: string;
  api?: string;
}

/** A resposta do POST /v1/oauth/token. */
export interface PlicflixEntradaOAuth {
  jogador: { id: string; nome: string };
  jogo: string;
  assinante: boolean;
  sub: string;
  name: string;
  access_token: string;
  token_type: "Bearer";
  expires_in: number;
  scope: string;
}

declare global {
  interface Window {
    Plicflix: PlicflixSDK;
  }
  const Plicflix: PlicflixSDK;
}