glink

import * as ink from "ink"
import * as React from "react"
import runtime from "react/jsx-runtime"

import { jsx } from "../redraw/redraw.ffi.mjs"

import { App, Focus, FocusManager, Instance, Key, Size, Stderr, Stdin, Stdout } from "./glink.mjs"
import { to_props_object } from "./internal.ffi.mjs"

export function box(styles, props, children) {
  return jsx(ink.Box, to_props_object([...styles, ...props]), children)
}

export function newline(count) {
  return runtime.jsxs(ink.Newline, { count })
}

export function spacer() {
  return runtime.jsxs(ink.Spacer)
}

export function static_(items, styles, children_) {
  const children = (item, index) => {
    const [key, node] = children_(item, index)
    if ("key" in node) {
      return React.cloneElement(node, { key })
    }
    return node
  }

  return runtime.jsx(ink.Static, { items: items.toArray(), style: to_props_object(styles), children })
}

export function text(props, children) {
  return jsx(ink.Text, to_props_object(props), children)
}

export function text_(props, text) {
  return runtime.jsxs(ink.Text, { ...to_props_object(props), children: [text] })
}

export function transform(transformFn, children) {
  return jsx(ink.Transform, { transform: transformFn }, children)
}

export function measure_element(node) {
  const size = ink.measureElement(node)
  return new Size(size.width, size.height)
}

export function render(component) {
  const instance = ink.render(component)
  return new Instance(
    instance.rerender,
    instance.unmount,
    instance.waitUntilExit,
    instance.cleanup,
    instance.clear,
  )
}

export function use_app() {
  const app = ink.useApp()
  return new App(app.exit)
}

export function use_focus(props) {
  const output = ink.useFocus(to_props_object(props))
  return new Focus(output.isFocused, output.focus)
}

export function use_focus_manager() {
  const output = ink.useFocusManager()
  return new FocusManager(
    output.enableFocus,
    output.disableFocus,
    output.focusNext,
    output.focusPrevious,
    output.focus,
  )
}

export function use_input(handler, isActive) {
  ink.useInput((input, key) => {
    handler(
      input,
      new Key(
        key.upArrow,
        key.downArrow,
        key.leftArrow,
        key.rightArrow,
        key.pageDown,
        key.pageUp,
        key.return,
        key.escape,
        key.ctrl,
        key.shift,
        key.tab,
        key.backspace,
        key.delete,
        key.meta,
      ),
    )
  }, { isActive })
}

export function use_stdin() {
  const stdin = ink.useStdin()
  return new Stdin(
    stdin.stdin,
    stdin.setRawMode,
    stdin.isRawModeSupported,
    stdin.internal_exitOnCtrlC,
    stdin.internal_eventEmitter,
  )
}

export function use_stderr() {
  const stderr = ink.useStderr()
  return new Stderr(
    stderr.stderr,
    stderr.write,
  )
}

export function use_stdout() {
  const stdout = ink.useStdout()
  return new Stdout(
    stdout.stdout,
    stdout.write,
  )
}