module ncurses

// Window is an opaque handle to an ncurses window.
pub type Window = voidptr

$if !windows {
	$if $pkgconfig('ncursesw') {
		#pkgconfig --cflags --libs ncursesw
	} $else $if $pkgconfig('ncurses') {
		#pkgconfig --cflags --libs ncurses
	} $else {
		#flag darwin -D_DARWIN_C_SOURCE -lncurses
		#flag linux -lncursesw
		#flag freebsd -lncursesw
		#flag openbsd -lcurses
		#flag netbsd -lcurses
		#flag dragonfly -lncurses
		#flag solaris -lncurses
	}
	#insert "@VEXEROOT/vlib/ncurses/ncurses_helpers.h"

	fn C.v_ncurses_initscr() Window
	fn C.v_ncurses_stdscr() Window
	fn C.v_ncurses_endwin() int
	fn C.v_ncurses_cbreak() int
	fn C.v_ncurses_nocbreak() int
	fn C.v_ncurses_raw() int
	fn C.v_ncurses_noraw() int
	fn C.v_ncurses_echo() int
	fn C.v_ncurses_noecho() int
	fn C.v_ncurses_keypad(win Window, enabled int) int
	fn C.v_ncurses_nodelay(win Window, enabled int) int
	fn C.v_ncurses_timeout(delay int)
	fn C.v_ncurses_wtimeout(win Window, delay int)
	fn C.v_ncurses_curs_set(visibility int) int
	fn C.v_ncurses_clear() int
	fn C.v_ncurses_refresh() int
	fn C.v_ncurses_getch() int
	fn C.v_ncurses_addstr(text &char) int
	fn C.v_ncurses_mvaddstr(y int, x int, text &char) int
	fn C.v_ncurses_newwin(lines int, cols int, begin_y int, begin_x int) Window
	fn C.v_ncurses_delwin(win Window) int
	fn C.v_ncurses_box(win Window, vertical u32, horizontal u32) int
	fn C.v_ncurses_getmaxx(win Window) int
	fn C.v_ncurses_getmaxy(win Window) int
	fn C.v_ncurses_wrefresh(win Window) int
	fn C.v_ncurses_wclear(win Window) int
	fn C.v_ncurses_wgetch(win Window) int
	fn C.v_ncurses_wmove(win Window, y int, x int) int
	fn C.v_ncurses_waddstr(win Window, text &char) int
	fn C.v_ncurses_mvwaddstr(win Window, y int, x int, text &char) int
	fn C.v_ncurses_start_color() int
	fn C.v_ncurses_has_colors() int
	fn C.v_ncurses_init_pair(pair i16, fg i16, bg i16) int
	fn C.v_ncurses_color_pair(pair int) int
	fn C.v_ncurses_attron(attr int) int
	fn C.v_ncurses_attroff(attr int) int
	fn C.v_ncurses_wattron(win Window, attr int) int
	fn C.v_ncurses_wattroff(win Window, attr int) int
	fn C.v_ncurses_key_f(n int) int
}

$if windows {
	pub const ok = 0
	pub const err = -1
	pub const key_code_yes = 0
	pub const key_down = 0
	pub const key_up = 0
	pub const key_left = 0
	pub const key_right = 0
	pub const key_home = 0
	pub const key_end = 0
	pub const key_npage = 0
	pub const key_ppage = 0
	pub const key_ic = 0
	pub const key_dc = 0
	pub const key_backspace = 0
	pub const key_enter = 0
	pub const cursor_invisible = 0
	pub const cursor_normal = 1
	pub const cursor_visible = 2
	pub const color_black = 0
	pub const color_red = 1
	pub const color_green = 2
	pub const color_yellow = 3
	pub const color_blue = 4
	pub const color_magenta = 5
	pub const color_cyan = 6
	pub const color_white = 7
	pub const a_normal = 0
	pub const a_standout = 0
	pub const a_underline = 0
	pub const a_reverse = 0
	pub const a_blink = 0
	pub const a_dim = 0
	pub const a_bold = 0
} $else {
	pub const ok = int(C.OK)
	pub const err = int(C.ERR)
	pub const key_code_yes = int(C.KEY_CODE_YES)
	pub const key_down = int(C.KEY_DOWN)
	pub const key_up = int(C.KEY_UP)
	pub const key_left = int(C.KEY_LEFT)
	pub const key_right = int(C.KEY_RIGHT)
	pub const key_home = int(C.KEY_HOME)
	pub const key_end = int(C.KEY_END)
	pub const key_npage = int(C.KEY_NPAGE)
	pub const key_ppage = int(C.KEY_PPAGE)
	pub const key_ic = int(C.KEY_IC)
	pub const key_dc = int(C.KEY_DC)
	pub const key_backspace = int(C.KEY_BACKSPACE)
	pub const key_enter = int(C.KEY_ENTER)
	pub const cursor_invisible = 0
	pub const cursor_normal = 1
	pub const cursor_visible = 2
	pub const color_black = int(C.COLOR_BLACK)
	pub const color_red = int(C.COLOR_RED)
	pub const color_green = int(C.COLOR_GREEN)
	pub const color_yellow = int(C.COLOR_YELLOW)
	pub const color_blue = int(C.COLOR_BLUE)
	pub const color_magenta = int(C.COLOR_MAGENTA)
	pub const color_cyan = int(C.COLOR_CYAN)
	pub const color_white = int(C.COLOR_WHITE)
	pub const a_normal = int(C.A_NORMAL)
	pub const a_standout = int(C.A_STANDOUT)
	pub const a_underline = int(C.A_UNDERLINE)
	pub const a_reverse = int(C.A_REVERSE)
	pub const a_blink = int(C.A_BLINK)
	pub const a_dim = int(C.A_DIM)
	pub const a_bold = int(C.A_BOLD)
}

fn unsupported_panic() {
	panic('ncurses is not supported on ${@OS}')
}

@[inline]
fn bool_to_c(enabled bool) int {
	return if enabled { 1 } else { 0 }
}

// is_supported reports whether this target has an ncurses backend in the standard library.
pub fn is_supported() bool {
	$if windows {
		return false
	} $else {
		return true
	}
}

// initscr initializes the curses screen and returns the default window handle.
pub fn initscr() Window {
	$if windows {
		unsupported_panic()
		return unsafe { nil }
	} $else {
		return C.v_ncurses_initscr()
	}
}

// stdscr returns the current default screen window handle.
pub fn stdscr() Window {
	$if windows {
		unsupported_panic()
		return unsafe { nil }
	} $else {
		return C.v_ncurses_stdscr()
	}
}

// endwin restores the terminal after `initscr`.
pub fn endwin() int {
	$if windows {
		unsupported_panic()
		return err
	} $else {
		return C.v_ncurses_endwin()
	}
}

// cbreak disables line buffering while keeping signal keys active.
pub fn cbreak() int {
	$if windows {
		unsupported_panic()
		return err
	} $else {
		return C.v_ncurses_cbreak()
	}
}

// nocbreak restores normal line buffering after `cbreak`.
pub fn nocbreak() int {
	$if windows {
		unsupported_panic()
		return err
	} $else {
		return C.v_ncurses_nocbreak()
	}
}

// raw enables raw input mode.
pub fn raw() int {
	$if windows {
		unsupported_panic()
		return err
	} $else {
		return C.v_ncurses_raw()
	}
}

// noraw disables raw input mode.
pub fn noraw() int {
	$if windows {
		unsupported_panic()
		return err
	} $else {
		return C.v_ncurses_noraw()
	}
}

// echo enables terminal echo for characters typed by the user.
pub fn echo() int {
	$if windows {
		unsupported_panic()
		return err
	} $else {
		return C.v_ncurses_echo()
	}
}

// noecho disables terminal echo for characters typed by the user.
pub fn noecho() int {
	$if windows {
		unsupported_panic()
		return err
	} $else {
		return C.v_ncurses_noecho()
	}
}

// keypad enables or disables keypad processing for a window.
pub fn keypad(win Window, enabled bool) int {
	$if windows {
		_ = win
		_ = enabled
		unsupported_panic()
		return err
	} $else {
		return C.v_ncurses_keypad(win, bool_to_c(enabled))
	}
}

// nodelay enables or disables nonblocking reads for a window.
pub fn nodelay(win Window, enabled bool) int {
	$if windows {
		_ = win
		_ = enabled
		unsupported_panic()
		return err
	} $else {
		return C.v_ncurses_nodelay(win, bool_to_c(enabled))
	}
}

// timeout sets the blocking behavior for `getch` on the default screen.
pub fn timeout(delay int) {
	$if windows {
		_ = delay
		unsupported_panic()
	} $else {
		C.v_ncurses_timeout(delay)
	}
}

// wtimeout sets the blocking behavior for `wgetch` on a specific window.
pub fn wtimeout(win Window, delay int) {
	$if windows {
		_ = win
		_ = delay
		unsupported_panic()
	} $else {
		C.v_ncurses_wtimeout(win, delay)
	}
}

// curs_set changes cursor visibility using the module cursor constants.
pub fn curs_set(visibility int) int {
	$if windows {
		_ = visibility
		unsupported_panic()
		return err
	} $else {
		return C.v_ncurses_curs_set(visibility)
	}
}

// clear clears the default screen buffer.
pub fn clear() int {
	$if windows {
		unsupported_panic()
		return err
	} $else {
		return C.v_ncurses_clear()
	}
}

// refresh flushes pending changes for the default screen.
pub fn refresh() int {
	$if windows {
		unsupported_panic()
		return err
	} $else {
		return C.v_ncurses_refresh()
	}
}

// getch reads one key code from the default screen.
pub fn getch() int {
	$if windows {
		unsupported_panic()
		return err
	} $else {
		return C.v_ncurses_getch()
	}
}

// addstr writes a string to the default screen at the current cursor position.
pub fn addstr(text string) int {
	$if windows {
		_ = text
		unsupported_panic()
		return err
	} $else {
		return C.v_ncurses_addstr(&char(text.str))
	}
}

// mvaddstr moves the cursor on the default screen and writes a string there.
pub fn mvaddstr(y int, x int, text string) int {
	$if windows {
		_ = y
		_ = x
		_ = text
		unsupported_panic()
		return err
	} $else {
		return C.v_ncurses_mvaddstr(y, x, &char(text.str))
	}
}

// newwin creates a new curses window.
pub fn newwin(lines int, cols int, begin_y int, begin_x int) Window {
	$if windows {
		_ = lines
		_ = cols
		_ = begin_y
		_ = begin_x
		unsupported_panic()
		return unsafe { nil }
	} $else {
		return C.v_ncurses_newwin(lines, cols, begin_y, begin_x)
	}
}

// delwin destroys a window created by `newwin`.
pub fn delwin(win Window) int {
	$if windows {
		_ = win
		unsupported_panic()
		return err
	} $else {
		return C.v_ncurses_delwin(win)
	}
}

// box draws a border around a window. Pass `0` for the default border characters.
pub fn box(win Window, vertical int, horizontal int) int {
	$if windows {
		_ = win
		_ = vertical
		_ = horizontal
		unsupported_panic()
		return err
	} $else {
		return C.v_ncurses_box(win, u32(vertical), u32(horizontal))
	}
}

// getmaxx returns the width of a window in columns.
pub fn getmaxx(win Window) int {
	$if windows {
		_ = win
		unsupported_panic()
		return 0
	} $else {
		return C.v_ncurses_getmaxx(win)
	}
}

// getmaxy returns the height of a window in rows.
pub fn getmaxy(win Window) int {
	$if windows {
		_ = win
		unsupported_panic()
		return 0
	} $else {
		return C.v_ncurses_getmaxy(win)
	}
}

// wrefresh flushes pending changes for a specific window.
pub fn wrefresh(win Window) int {
	$if windows {
		_ = win
		unsupported_panic()
		return err
	} $else {
		return C.v_ncurses_wrefresh(win)
	}
}

// wclear clears a specific window.
pub fn wclear(win Window) int {
	$if windows {
		_ = win
		unsupported_panic()
		return err
	} $else {
		return C.v_ncurses_wclear(win)
	}
}

// wgetch reads one key code from a specific window.
pub fn wgetch(win Window) int {
	$if windows {
		_ = win
		unsupported_panic()
		return err
	} $else {
		return C.v_ncurses_wgetch(win)
	}
}

// wmove moves the cursor inside a specific window.
pub fn wmove(win Window, y int, x int) int {
	$if windows {
		_ = win
		_ = y
		_ = x
		unsupported_panic()
		return err
	} $else {
		return C.v_ncurses_wmove(win, y, x)
	}
}

// waddstr writes a string to a specific window at its current cursor position.
pub fn waddstr(win Window, text string) int {
	$if windows {
		_ = win
		_ = text
		unsupported_panic()
		return err
	} $else {
		return C.v_ncurses_waddstr(win, &char(text.str))
	}
}

// mvwaddstr moves the cursor in a window and writes a string there.
pub fn mvwaddstr(win Window, y int, x int, text string) int {
	$if windows {
		_ = win
		_ = y
		_ = x
		_ = text
		unsupported_panic()
		return err
	} $else {
		return C.v_ncurses_mvwaddstr(win, y, x, &char(text.str))
	}
}

// start_color enables ncurses color support.
pub fn start_color() int {
	$if windows {
		unsupported_panic()
		return err
	} $else {
		return C.v_ncurses_start_color()
	}
}

// has_colors reports whether the terminal supports colors.
pub fn has_colors() bool {
	$if windows {
		return false
	} $else {
		return C.v_ncurses_has_colors() != 0
	}
}

// init_pair defines a foreground/background color pair for use with `color_pair`.
pub fn init_pair(pair int, fg int, bg int) int {
	$if windows {
		_ = pair
		_ = fg
		_ = bg
		unsupported_panic()
		return err
	} $else {
		return C.v_ncurses_init_pair(i16(pair), i16(fg), i16(bg))
	}
}

// color_pair returns the attribute mask for a color pair number.
pub fn color_pair(pair int) int {
	$if windows {
		_ = pair
		unsupported_panic()
		return 0
	} $else {
		return C.v_ncurses_color_pair(pair)
	}
}

// attron enables an attribute on the default screen.
pub fn attron(attr int) int {
	$if windows {
		_ = attr
		unsupported_panic()
		return err
	} $else {
		return C.v_ncurses_attron(attr)
	}
}

// attroff disables an attribute on the default screen.
pub fn attroff(attr int) int {
	$if windows {
		_ = attr
		unsupported_panic()
		return err
	} $else {
		return C.v_ncurses_attroff(attr)
	}
}

// wattron enables an attribute on a specific window.
pub fn wattron(win Window, attr int) int {
	$if windows {
		_ = win
		_ = attr
		unsupported_panic()
		return err
	} $else {
		return C.v_ncurses_wattron(win, attr)
	}
}

// wattroff disables an attribute on a specific window.
pub fn wattroff(win Window, attr int) int {
	$if windows {
		_ = win
		_ = attr
		unsupported_panic()
		return err
	} $else {
		return C.v_ncurses_wattroff(win, attr)
	}
}

// key_f returns the key code for function keys like F1, F2, and so on.
pub fn key_f(n int) int {
	$if windows {
		_ = n
		unsupported_panic()
		return 0
	} $else {
		return C.v_ncurses_key_f(n)
	}
}