/*

 * screen.c     -- UI stuff

 *

 * Copyright (C) 2005 Mikael Berthe <bmikael@lists.lilotux.net>

 * Parts of this file come from the Cabber project <cabber@ajmacias.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or (at

 * your option) any later version.

 *

 * This program is distributed in the hope that it will be useful, but

 * WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307

 * USA

 */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <ncurses.h>

#include <panel.h>

#include <time.h>

#include <ctype.h>

#include <locale.h>

#include <langinfo.h>

#include "screen.h"

#include "hbuf.h"

#include "commands.h"

#include "compl.h"

#include "roster.h"

#include "histolog.h"

#include "settings.h"

#include "utils.h"

#include "list.h"

#define window_entry(n) list_entry(n, window_entry_t, list)

#define DEFAULT_LOG_WIN_HEIGHT (5+2)

#define CHAT_WIN_HEIGHT (maxY-1-Log_Win_Height)

char *LocaleCharSet = "C";

static unsigned short int Log_Win_Height;

static inline void check_offset(int);

LIST_HEAD(window_list);

typedef struct _window_entry_t {

  WINDOW *win;

  PANEL  *panel;

  char   *name;

  GList  *hbuf;

  GList  *top;      // If top is NULL, we'll display the last lines

  char    cleared;  // For ex, user has issued a /clear command...

  struct list_head list;

} window_entry_t;

static WINDOW *rosterWnd, *chatWnd, *inputWnd;

static WINDOW *logWnd, *logWnd_border;

static PANEL *rosterPanel, *chatPanel, *inputPanel;

static PANEL *logPanel, *logPanel_border;

static int maxY, maxX;

static window_entry_t *currentWindow;

static int chatmode;

static int multimode;

static char *multiline;

int update_roster;

int utf8_mode = 0;

static bool Autoaway;

static bool Curses;

static char       inputLine[INPUTLINE_LENGTH+1];

static char      *ptr_inputline;

static short int  inputline_offset;

static int    completion_started;

static GList *cmdhisto;

static GList *cmdhisto_cur;

static char   cmdhisto_backup[INPUTLINE_LENGTH+1];

/* Functions */

static int scr_WindowWidth(WINDOW * win)

{

  int x, y;

  getmaxyx(win, y, x);

  return x;

}

static void scr_draw_box(WINDOW * win, int y, int x, int height, int width,

                         int Color, chtype box, chtype border)

{

  int i, j;

  wattrset(win, COLOR_PAIR(Color));

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

    wmove(win, y + i, x);

    for (j = 0; j < width; j++)

      if (!i && !j)

	waddch(win, border | ACS_ULCORNER);

      else if (i == height - 1 && !j)

	waddch(win, border | ACS_LLCORNER);

      else if (!i && j == width - 1)

	waddch(win, box | ACS_URCORNER);

      else if (i == height - 1 && j == width - 1)

	waddch(win, box | ACS_LRCORNER);

      else if (!i)

	waddch(win, border | ACS_HLINE);

      else if (i == height - 1)

	waddch(win, box | ACS_HLINE);

      else if (!j)

	waddch(win, border | ACS_VLINE);

      else if (j == width - 1)

	waddch(win, box | ACS_VLINE);

      else

	waddch(win, box | ' ');

  }

}

static int FindColor(const char *name)

{

  if (!strcmp(name, "default"))

    return -1;

  if (!strcmp(name, "black"))

    return COLOR_BLACK;

  if (!strcmp(name, "red"))

    return COLOR_RED;

  if (!strcmp(name, "green"))

    return COLOR_GREEN;

  if (!strcmp(name, "yellow"))

    return COLOR_YELLOW;

  if (!strcmp(name, "blue"))

    return COLOR_BLUE;

  if (!strcmp(name, "magenta"))

    return COLOR_MAGENTA;

  if (!strcmp(name, "cyan"))

    return COLOR_CYAN;

  if (!strcmp(name, "white"))

    return COLOR_WHITE;

  return -1;

}

static void ParseColors(void)

{

  const char *colors[8] = {

    "", "",

    "general",

    "newmsg",

    "rosterselect",

    "rosternormal",

    NULL

  };

  char *tmp = g_new(char, 512);

  const char *color;

  const char *background   = settings_opt_get("color_background");

  const char *backselected = settings_opt_get("color_backselected");

  int i = 0;

  // Default values

  if (!background)   background   = "blue";

  if (!backselected) backselected = "cyan";

  while (colors[i]) {

    snprintf(tmp, 512, "color_%s", colors[i]);

    color = settings_opt_get(tmp);

    switch (i + 1) {

    case 1:

      init_pair(1, COLOR_BLACK, COLOR_WHITE);

      break;

    case 2:

      init_pair(2, COLOR_WHITE, COLOR_BLACK);

      break;

    case 3:

      init_pair(3, ((color) ? FindColor(color) : COLOR_WHITE),

                FindColor(background));

      break;

    case 4:

      init_pair(4, ((color) ? FindColor(color) : COLOR_RED),

                FindColor(background));

      break;

    case 5:

      init_pair(5, ((color) ? FindColor(color) : COLOR_BLACK),

                FindColor(backselected));

      break;

    case 6:

      init_pair(6, ((color) ? FindColor(color) : COLOR_MAGENTA),

                FindColor(background));

      break;

    }

    i++;

  }

}

void scr_InitCurses(void)

{

  initscr();

  raw();

  noecho();

  nonl();

  intrflush(stdscr, FALSE);

  start_color();

  use_default_colors();

  Curses = TRUE;

  ParseColors();

  getmaxyx(stdscr, maxY, maxX);

  Log_Win_Height = DEFAULT_LOG_WIN_HEIGHT;

  // Note scr_DrawMainWindow() should be called early after scr_InitCurses()

  // to update Log_Win_Height and set max{X,Y}

  inputLine[0] = 0;

  ptr_inputline = inputLine;

  setlocale(LC_CTYPE, "");

  LocaleCharSet = nl_langinfo(CODESET);

  utf8_mode = (strcmp(LocaleCharSet, "UTF-8") == 0);

  return;

}

void scr_TerminateCurses(void)

{

  if (!Curses) return;

  clear();

  refresh();

  endwin();

  Curses = FALSE;

  return;

}

inline void scr_Beep(void)

{

  beep();

}

//  scr_LogPrint(...)

// Display a message in the log window.

void scr_LogPrint(unsigned int flag, const char *fmt, ...)

{

  time_t timestamp;

  char *buffer, *b2;

  va_list ap;

  if (!flag) return;

  buffer = g_new(char, 5184);

  timestamp = time(NULL);

  strftime(buffer, 48, "[%H:%M:%S] ", localtime(&timestamp));

  for (b2 = buffer ; *b2 ; b2++)

    ;

  va_start(ap, fmt);

  vsnprintf(b2, 5120, fmt, ap);

  va_end(ap);

  if (flag & LPRINT_NORMAL) {

    if (Curses) {

      wprintw(logWnd, "\n%s", buffer);

      update_panels();

      doupdate();

    } else {

      printf("%s\n", buffer);

    }

  }

  if (flag & (LPRINT_LOG|LPRINT_DEBUG)) {

    char *buffer2 = g_new(char, 5184);

    strftime(buffer2, 23, "[%Y-%m-%d %H:%M:%S] ", localtime(&timestamp));

    strcat(buffer2, b2);

    strcat(buffer2, "\n");

    ut_WriteLog(flag, buffer2);

    g_free(buffer2);

  }

  g_free(buffer);

}

static window_entry_t *scr_CreateBuddyPanel(const char *title, int dont_show)

{

  int x;

  int y;

  int lines;

  int cols;

  window_entry_t *tmp;

  tmp = g_new0(window_entry_t, 1);

  // Dimensions

  x = ROSTER_WIDTH;

  y = 0;

  lines = CHAT_WIN_HEIGHT;

  cols = maxX - ROSTER_WIDTH;

  tmp->win = newwin(lines, cols, y, x);

  while (!tmp->win) {

    safe_usleep(250);

    tmp->win = newwin(lines, cols, y, x);

  }

  wbkgd(tmp->win, COLOR_PAIR(COLOR_GENERAL));

  tmp->panel = new_panel(tmp->win);

  tmp->name = g_strdup(title);

  if (!dont_show) {

    currentWindow = tmp;

  } else {

    if (currentWindow)

      top_panel(currentWindow->panel);

    else

      top_panel(chatPanel);

  }

  update_panels();

  // Load buddy history from file (if enabled)

  hlog_read_history(title, &tmp->hbuf, maxX - ROSTER_WIDTH - PREFIX_WIDTH);

  list_add_tail(&tmp->list, &window_list);

  return tmp;

}

static window_entry_t *scr_SearchWindow(const char *winId)

{

  struct list_head *pos, *n;

  window_entry_t *search_entry = NULL;

  if (!winId) return NULL;

  list_for_each_safe(pos, n, &window_list) {

    search_entry = window_entry(pos);

    if (search_entry->name) {

      if (!strcasecmp(search_entry->name, winId)) {

	return search_entry;

      }

    }

  }

  return NULL;

}

bool scr_BuddyBufferExists(const char *jid)

{

  return (scr_SearchWindow(jid) != NULL);

}

//  scr_UpdateWindow()

// (Re-)Display the given chat window.

static void scr_UpdateWindow(window_entry_t *win_entry)

{

  int n;

  int width;

  hbb_line **lines, *line;

  GList *hbuf_head;

  char date[32];

  width = scr_WindowWidth(win_entry->win);

  // Should the window be empty?

  if (win_entry->cleared) {

    werase(win_entry->win);

    return;

  }

  // win_entry->top is the top message of the screen.  If it set to NULL, we

  // are displaying the last messages.

  // We will show the last CHAT_WIN_HEIGHT lines.

  // Let's find out where it begins.

  if (!win_entry->top ||

      (g_list_position(g_list_first(win_entry->hbuf), win_entry->top) == -1)) {

    // Move up CHAT_WIN_HEIGHT lines

    win_entry->hbuf = g_list_last(win_entry->hbuf);

    hbuf_head = win_entry->hbuf;

    win_entry->top = NULL; // (Just to make sure)

    n = 0;

    while (hbuf_head && (n < CHAT_WIN_HEIGHT-1) && g_list_previous(hbuf_head)) {

      hbuf_head = g_list_previous(hbuf_head);

      n++;

    }

  } else

    hbuf_head = win_entry->top;

  // Get the last CHAT_WIN_HEIGHT lines.