/*

 * 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)

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 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 */

int scr_WindowWidth(WINDOW * win)

{

  int x, y;

  getmaxyx(win, y, x);

  return x;

}

void scr_clear_box(WINDOW *win, int y, int x, int height, int width, int Color)

{

  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++)

      wprintw(win, " ");

  }

}

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 | ' ');

  }

}

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;

}

void ParseColors(void)

{

  const char *colors[8] = {

    "", "",

    "general",

    "newmsg",

    "rosterselect",

    "rosternormal",

    NULL

  };

  char *tmp = malloc(1024);

  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]) {

    sprintf(tmp, "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++;

  }

}

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

{

  int x;

  int y;

  int lines;

  int cols;

  window_entry_t *tmp;

  do {

    tmp = calloc(1, sizeof(window_entry_t));

  } while (!tmp);

  // Dimensions

  x = ROSTER_WIDTH;

  y = 0;

  lines = CHAT_WIN_HEIGHT;

  cols = maxX - ROSTER_WIDTH;

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

  while (!tmp->win) {

    usleep(250);

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

  }

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

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

  tmp->name = (char *) calloc(1, 96);

  strncpy(tmp->name, title, 96);

  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;

}

window_entry_t *scr_SearchWindow(const char *winId)

{

  struct list_head *pos, *n;

  window_entry_t *search_entry = 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;

}

//  scr_UpdateWindow()

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

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.

  lines = hbuf_get_lines(hbuf_head, CHAT_WIN_HEIGHT);

  // Display these lines

  for (n = 0; n < CHAT_WIN_HEIGHT; n++) {

    wmove(win_entry->win, n, 0);

    line = *(lines+n);

    // NOTE: update PREFIX_WIDTH if you change the date format!!

    // You need to set it to the whole prefix length + 1

    if (line) {

      if (line->timestamp) {

        strftime(date, 35, "%m-%d %H:%M", localtime(&line->timestamp));

      } else

        strcpy(date, "           ");

      if (line->flags & HBB_PREFIX_INFO) {

        char dir = '*';

        if (line->flags & HBB_PREFIX_IN)

          dir = '<';

        else if (line->flags & HBB_PREFIX_OUT)

          dir = '>';

        wprintw(win_entry->win, "%.11s *%c* ", date, dir);

      } else if (line->flags & HBB_PREFIX_ERR) {

        char dir = '#';

        if (line->flags & HBB_PREFIX_IN)

          dir = '<';

        else if (line->flags & HBB_PREFIX_OUT)

          dir = '>';

        wprintw(win_entry->win, "%.11s #%c# ", date, dir);

      } else if (line->flags & HBB_PREFIX_IN)

        wprintw(win_entry->win, "%.11s <== ", date);

      else if (line->flags & HBB_PREFIX_OUT)

        wprintw(win_entry->win, "%.11s --> ", date);

      else {

        wprintw(win_entry->win, "%.11s     ", date);

      }

      wprintw(win_entry->win, "%s", line->text);      // line

      wclrtoeol(win_entry->win);

      g_free(line->text);

    } else {

      wclrtobot(win_entry->win);

      break;

    }

  }

  g_free(lines);

}

//  scr_ShowWindow()

// Display the chat window with the given identifier.

void scr_ShowWindow(const char *winId)

{

  window_entry_t *win_entry = scr_SearchWindow(winId);

  if (!win_entry)

    win_entry = scr_CreateBuddyPanel(winId, FALSE);

  top_panel(win_entry->panel);

  currentWindow = win_entry;

  chatmode = TRUE;

  roster_msg_setflag(winId, FALSE);

  roster_setflags(winId, ROSTER_FLAG_LOCK, TRUE);

  update_roster = TRUE;

  // Refresh the window

  scr_UpdateWindow(win_entry);

  // Finished :)

  update_panels();

  top_panel(inputPanel);

}

//  scr_ShowBuddyWindow()

// Display the chat window buffer for the current buddy.

void scr_ShowBuddyWindow(void)

{

  const gchar *jid;

  if (!current_buddy)

    jid = NULL;