/* $OpenBSD: window-border.c,v 1.3 2026/07/23 09:38:27 nicm Exp $ */

/*

 * Copyright (c) 2026 Nicholas Marriott <nicholas.marriott@gmail.com>

 *

 * Permission to use, copy, modify, and distribute this software for any

 * purpose with or without fee is hereby granted, provided that the above

 * copyright notice and this permission notice appear in all copies.

 *

 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES

 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR

 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER

 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING

 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

 */

#include <sys/types.h>

#include <stdlib.h>

#include <string.h>

#include "tmux.h"

/* Set window fill cell. */

static void

window_set_fill_cell(struct window *w, int inside, struct grid_cell *gc)

{

  struct format_tree  *ft;

  struct screen    s;

  struct screen_write_ctx  ctx;

  struct grid_cell   new_gc;

  const char    *value;

  char      *expanded;

  memcpy(gc, &grid_default_cell, sizeof *gc);

  gc->attr |= GRID_ATTR_CHARSET;

  utf8_set(&gc->data, CELL_BORDERS[CELL_NONE]);

  ft = format_create(NULL, NULL, FORMAT_WINDOW|w->id, FORMAT_NOJOBS);

  format_defaults(ft, NULL, NULL, NULL, w->active);

  format_add(ft, "is_inside", "%d", inside);

  format_add(ft, "is_outside", "%d", !inside);

  value = options_get_string(w->options, "fill-character");

  expanded = format_expand(ft, value);

  format_free(ft);

  screen_init(&s, 1, 1, 0);

  screen_write_start(&ctx, &s);

  format_draw(&ctx, &grid_default_cell, 1, expanded, NULL, 0);

  screen_write_stop(&ctx);

  free(expanded);

  grid_view_get_cell(s.grid, 0, 0, &new_gc);

  if (new_gc.data.width == 1)

    memcpy(gc, &new_gc, sizeof *gc);

  screen_free(&s);

}

/* Set window fill cells. */

void

window_set_fill_cells(struct window *w)

{

  window_set_fill_cell(w, 1, &w->inside_cell);

  window_set_fill_cell(w, 0, &w->outside_cell);

}

/* Merge a window fill cell over an existing style. */

static void

window_copy_fill_cell(struct grid_cell *gc, const struct grid_cell *fill)

{

  utf8_copy(&gc->data, &fill->data);

  gc->attr |= fill->attr;

  gc->flags |= fill->flags;

  if (fill->fg != 8)

    gc->fg = fill->fg;

  if (fill->bg != 8)

    gc->bg = fill->bg;

  if (fill->us != 8)

    gc->us = fill->us;

}

/* Get window fill cell. */

void

window_get_fill_cell(struct window *w, int inside, struct grid_cell *gc)

{

  if (inside)

    window_copy_fill_cell(gc, &w->inside_cell);

  else

    window_copy_fill_cell(gc, &w->outside_cell);

}

/* Get border cell. */

void

window_get_border_cell(struct window_pane *wp, enum pane_lines pane_lines,

    int cell_type, struct grid_cell *gc)

{

  u_int idx;

  switch (pane_lines) {

  case PANE_LINES_NUMBER:

    if (cell_type == CELL_NONE) {

      gc->attr |= GRID_ATTR_CHARSET;

      utf8_set(&gc->data, CELL_BORDERS[CELL_NONE]);

      break;

    }

    gc->attr &= ~GRID_ATTR_CHARSET;

    if (wp != NULL && window_pane_index(wp, &idx) == 0)

      utf8_set(&gc->data, '0' + (idx % 10));

    else

      utf8_set(&gc->data, '*');

    break;

  case PANE_LINES_DOUBLE:

    gc->attr &= ~GRID_ATTR_CHARSET;

    utf8_copy(&gc->data, tty_acs_double_borders(cell_type));

    break;

  case PANE_LINES_HEAVY:

    gc->attr &= ~GRID_ATTR_CHARSET;

    utf8_copy(&gc->data, tty_acs_heavy_borders(cell_type));

    break;

  case PANE_LINES_SIMPLE:

    gc->attr &= ~GRID_ATTR_CHARSET;

    utf8_set(&gc->data, SIMPLE_BORDERS[cell_type]);

    break;

  case PANE_LINES_NONE:

  case PANE_LINES_SPACES:

    gc->attr &= ~GRID_ATTR_CHARSET;

    utf8_set(&gc->data, ' ');

    break;

  default:

    gc->attr |= GRID_ATTR_CHARSET;

    utf8_set(&gc->data, CELL_BORDERS[cell_type]);

    break;

  }

}

/* Get pane border cell. */

void

window_pane_get_border_cell(struct window_pane *wp, int cell_type,

    struct grid_cell *gc)

{

  enum pane_lines pane_lines = window_pane_get_pane_lines(wp);

  window_get_border_cell(wp, pane_lines, cell_type, gc);

}

/* Get pane border style. */

void

window_pane_get_border_style(struct window_pane *wp, struct client *c,

    struct grid_cell *gc)

{

  struct session    *s = c->session;

  struct format_tree  *ft;

  const char    *option;

  struct grid_cell  *saved;

  int     *flag;

  if (wp == c->session->curw->window->active) {

    flag = &wp->active_border_gc_set;

    saved = &wp->active_border_gc;

    option = "pane-active-border-style";

  } else {

    flag = &wp->border_gc_set;

    saved = &wp->border_gc;

    option = "pane-border-style";

  }

  if (!*flag) {

    ft = format_create_defaults(NULL, c, s, s->curw, wp);

    style_apply(saved, wp->options, option, ft);

    format_free(ft);

    *flag = 1;

  }

  memcpy(gc, saved, sizeof *gc);

}

/* Build pane status line. */

int

window_make_pane_status(struct window_pane *wp, struct client *c, u_int width,

    struct redraw_span *span)

{

  struct grid_cell   gc;

  const char    *fmt;

  struct format_tree  *ft;

  struct style_line_entry *sle = &wp->border_status_line;

  struct screen_write_ctx  ctx;

  struct screen    old;

  char      *expanded;

  u_int      i;

  enum pane_lines    pane_lines;

  int      pane_status, cell_type;

  pane_status = window_pane_get_pane_status(wp);

  if (pane_status == PANE_STATUS_OFF || width == 0)

    return (0);

  ft = format_create(c, NULL, FORMAT_PANE|wp->id, FORMAT_STATUS);

  format_defaults(ft, c, c->session, c->session->curw, wp);

  fmt = options_get_string(wp->options, "pane-border-format");

  expanded = format_expand_time(ft, fmt);

  memcpy(&old, &wp->status_screen, sizeof old);

  screen_init(&wp->status_screen, width, 1, 0);

  wp->status_screen.mode = 0;

  screen_write_start(&ctx, &wp->status_screen);

  window_pane_get_border_style(wp, c, &gc);

  pane_lines = window_pane_get_pane_lines(wp);

  for (i = 0; i < width; i++) {

    cell_type = redraw_get_status_border_cell_type(&span, i);

    window_get_border_cell(wp, pane_lines, cell_type, &gc);

    screen_write_cell(&ctx, &gc);

  }

  gc.attr &= ~GRID_ATTR_CHARSET;

  screen_write_cursormove(&ctx, 0, 0, 0);

  style_ranges_free(&sle->ranges);

  format_draw(&ctx, &gc, width, expanded, &sle->ranges, 0);

  screen_write_stop(&ctx);

  format_free(ft);

  free(sle->expanded);

  sle->expanded = expanded;

  if (grid_compare(wp->status_screen.grid, old.grid) == 0) {

    screen_free(&old);

    return (0);

  }

  screen_free(&old);

  return (1);

}