#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 "screen.h"

#include "hbuf.h"

#include "commands.h"

#include "compl.h"

#include "roster.h"

#include "histolog.h"

#include "parsecfg.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;

int update_roster;

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

{

  char *colors[11] = {

    "", "",

    "borderlines",

    "jidonline",

    "newmsg",

    "jidofflineselected",

    "jidoffline",

    "text",

    NULL

  };

  char *tmp = malloc(1024);

  char *color1;

  char *background = cfg_read("color_background");

  char *backselected = cfg_read("color_backselected");

  int i = 0;

  while (colors[i]) {

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

    color1 = cfg_read(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, FindColor(color1), FindColor(background));

      break;

    case 4:

      init_pair(4, FindColor(color1), FindColor(backselected));

      break;

    case 5:

      init_pair(5, FindColor(color1), FindColor(background));

      break;

    case 6:

      init_pair(6, FindColor(color1), FindColor(backselected));

      break;

    case 7:

      init_pair(7, FindColor(color1), FindColor(background));

      break;

    case 8:

      init_pair(8, FindColor(color1), 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)

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

    if (line) {

      if (line->timestamp) {

      } else

      if (line->flags & HBB_PREFIX_IN)

      else if (line->flags & HBB_PREFIX_OUT)

      else {

      }

      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;

  else

    jid = CURRENT_JID;

  if (!jid) {

    top_panel(chatPanel);

    top_panel(inputPanel);

    currentWindow = NULL;

    return;

  }

  scr_ShowWindow(jid);

}

//  scr_WriteInWindow()

// Write some text in the winId window (this usually is a jid).

// Lines are splitted when they are too long to fit in the chat window.

// If this window doesn't exist, it is created.

void scr_WriteInWindow(const char *winId, const char *text, time_t timestamp,

        unsigned int prefix_flags, int force_show)

{

  window_entry_t *win_entry;

  int dont_show = FALSE;

  // Look for the window entry.

  win_entry = scr_SearchWindow(winId);

  // Do we have to really show the window?

  if (!chatmode)

    dont_show = TRUE;

  else if ((!force_show) && ((!currentWindow || (currentWindow != win_entry))))

    dont_show = TRUE;

  // If the window entry doesn't exist yet, let's create it.

  if (win_entry == NULL) {

    win_entry = scr_CreateBuddyPanel(winId, dont_show);

  }

  hbuf_add_line(&win_entry->hbuf, text, timestamp, prefix_flags,

  if (win_entry->cleared) {

    win_entry->cleared = 0; // The message must be displayed

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