/*

 * screen.c     -- UI stuff

 *

 * Copyright (C) 2005-2007 Mikael Berthe <mikael@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 <time.h>

#include <ctype.h>

#include <locale.h>

#include <langinfo.h>

#include <config.h>

#ifdef HAVE_ASPELL_H

# include <aspell.h>

#endif

#include "screen.h"

#include "utf8.h"

#include "hbuf.h"

#include "commands.h"

#include "compl.h"

#include "roster.h"

#include "histolog.h"

#include "settings.h"

#include "utils.h"

#define get_color(col)  (COLOR_PAIR(col)|COLOR_ATTRIB[col])

#define DEFAULT_LOG_WIN_HEIGHT (5+2)

#define DEFAULT_ROSTER_WIDTH    24

#define CHAT_WIN_HEIGHT (maxY-1-Log_Win_Height)

char *LocaleCharSet = "C";

static unsigned short int Log_Win_Height;

static unsigned short int Roster_Width;

static inline void check_offset(int);

static void scr_cancel_current_completion(void);

static void scr_end_current_completion(void);

static void scr_insert_text(const char*);

static void scr_handle_tab(void);

#ifdef HAVE_ASPELL_H

static void spellcheck(char *, char *);

#endif

static GHashTable *winbufhash;

typedef struct {

  GList  *hbuf;

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

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

  char    lock;

} buffdata;

typedef struct {

  WINDOW *win;

  PANEL  *panel;

  buffdata *bd;

} winbuf;

struct dimensions {

  int l;

  int c;

};

static WINDOW *rosterWnd, *chatWnd, *activechatWnd, *inputWnd, *logWnd;

static WINDOW *mainstatusWnd, *chatstatusWnd;

static PANEL *rosterPanel, *chatPanel, *activechatPanel, *inputPanel;

static PANEL *mainstatusPanel, *chatstatusPanel;

static PANEL *logPanel;

static int maxY, maxX;

static int prev_chatwidth;

static winbuf *statusWindow;

static winbuf *currentWindow;

static GList  *statushbuf;

static int roster_hidden;

static int chatmode;

static int multimode;

static char *multiline, *multimode_subj;

int update_roster;

int utf8_mode = 0;

static bool Curses;

static bool log_win_on_top;

static bool roster_win_on_right;

static time_t LastActivity;

static char       inputLine[INPUTLINE_LENGTH+1];

#ifdef HAVE_ASPELL_H

static char       maskLine[INPUTLINE_LENGTH+1];

#endif

static char      *ptr_inputline;

static short int  inputline_offset;

static int    completion_started;

static GList *cmdhisto;

static GList *cmdhisto_cur;

static guint  cmdhisto_nblines;

static char   cmdhisto_backup[INPUTLINE_LENGTH+1];

static int    chatstate; /* (0=active, 1=composing, 2=paused) */

static bool   lock_chatstate;

static time_t chatstate_timestamp;

int chatstates_disabled;

#define MAX_KEYSEQ_LENGTH 8

typedef struct {

  char *seqstr;

  guint mkeycode;

  gint  value;

} keyseq;

GSList *keyseqlist;

static void add_keyseq(char *seqstr, guint mkeycode, gint value);

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

                       unsigned int prefix_flags, int force_show);

#ifdef HAVE_ASPELL_H

#define ASPELLBADCHAR 5

AspellConfig *spell_config;

AspellSpeller *spell_checker;

#endif

typedef struct {

  char *status, *wildcard;

  int color;

  GPatternSpec *compiled;

} rostercolor;

GSList *rostercolrules = NULL;

/* Functions */

static int color_conv_table[] = {

  COLOR_BLACK,

  COLOR_RED,

  COLOR_GREEN,

  COLOR_YELLOW,

  COLOR_BLUE,

  COLOR_MAGENTA,

  COLOR_CYAN,

  COLOR_WHITE

};

static int color_conv_table_fg[] = {

  COLOR_BLACK_FG,

  COLOR_RED_FG,

  COLOR_GREEN_FG,

  COLOR_YELLOW_FG,

  COLOR_BLUE_FG,

  COLOR_MAGENTA_FG,

  COLOR_CYAN_FG,

  COLOR_WHITE_FG

};

static int color_to_color_fg(int color)

{

  unsigned i = 0;

  for ( ; i < sizeof color_conv_table / sizeof *color_conv_table; i++)

    if (color == color_conv_table[i])

      return color_conv_table_fg[i];

  return -1;

}

static int color_fg_to_color(int color)

{

  unsigned i = 0;

  if (color >= COLOR_BLACK_BOLD_FG)

    color -= COLOR_BLACK_BOLD_FG - COLOR_BLACK_FG;

  for ( ; i < sizeof color_conv_table_fg / sizeof *color_conv_table_fg; i++)

    if (color == color_conv_table_fg[i])

      return color_conv_table[i];

  return -1;

}

static int FindColorInternal(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 -2;

}

static int FindColor(const char *name)

{

  int result = FindColorInternal(name);

  if (result != -2)

    return result;

  scr_LogPrint(LPRINT_LOGNORM, "ERROR: Wrong color: %s", name);

  return -1;

}

static void free_rostercolrule(rostercolor *col)

{

  g_free(col->status);

  g_free(col->wildcard);

  g_pattern_spec_free(col->compiled);

  g_free(col);

}

// Removes all roster coloring rules

void scr_RosterClearColor(void)

{

  GSList *head;

  for (head = rostercolrules; head; head = g_slist_next(head)) {

    free_rostercolrule(head->data);

  }

  g_slist_free(rostercolrules);

  rostercolrules = NULL;

}

// Adds, modifies or removes roster coloring rule

// color set to "-" removes the rule,

// otherwise it is modified (if exists) or added

//

// Returns weather it was successfull (therefore the roster should be

// redrawed) or not. If it failed, for example because of invalid color

// name, it also prints the error.

bool scr_RosterColor(const char *status, const char *wildcard,

                     const char *color)

{

  GSList *head;

  GSList *found = NULL;

  for (head = rostercolrules; head; head = g_slist_next(head)) {

    rostercolor *rc = head->data;

    if ((!strcmp(status, rc->status)) && (!strcmp(wildcard, rc->wildcard))) {

      found = head;

      break;

    }

  }

  if (!strcmp(color,"-")) {//Delete the rule

    if (found) {

      free_rostercolrule(found->data);

      rostercolrules = g_slist_delete_link(rostercolrules, found);

      return TRUE;

    } else {

      scr_LogPrint(LPRINT_NORMAL, "No such color rule, nothing removed");

      return FALSE;

    }

  } else {

    bool isbright = false;

    int cl;

    if (!strncmp(color, "bright", 6)) {

      isbright = true;

      color += 6;

    }

    cl = color_to_color_fg(FindColorInternal(color));

    if (isbright)

      cl += COLOR_BLACK_BOLD_FG - COLOR_BLACK_FG;

    if (cl < 0 ) {

      scr_LogPrint(LPRINT_NORMAL, "No such color name");

      return FALSE;

    }

    if (found) {

      rostercolor *rc = found->data;

      rc->color = cl;

    } else {

      rostercolor *rc = g_new(rostercolor, 1);

      rc->status = g_strdup(status);

      rc->wildcard = g_strdup(wildcard);

      rc->compiled = g_pattern_spec_new(wildcard);

      rc->color = cl;

      rostercolrules = g_slist_prepend(rostercolrules, rc);

    }

    return TRUE;

  }

}

static void ParseColors(void)

{

  const char *colors[] = {

    "", "",

    "general",

    "msgout",

    "msghl",

    "status",

    "roster",

    "rostersel",

    "rosterselmsg",

    "rosternewmsg",

    "info",

    "msgin",

    NULL

  };

  const char *color;

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

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

  const char *backstatus   = settings_opt_get("color_bgstatus");

  char *tmp;

  int i;

  // Initialize color attributes

  memset(COLOR_ATTRIB, 0, sizeof(COLOR_ATTRIB));

  // Default values

  if (!background)   background   = "black";

  if (!backselected) backselected = "cyan";

  if (!backstatus)   backstatus   = "blue";

  for (i=0; colors[i]; i++) {

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

    color = settings_opt_get(tmp);

    g_free(tmp);

    if (color) {

      if (!strncmp(color, "bright", 6)) {

        COLOR_ATTRIB[i+1] = A_BOLD;

        color += 6;

      }

    }

    switch (i + 1) {

      case 1:

          init_pair(1, COLOR_BLACK, COLOR_WHITE);

          break;

      case 2:

          init_pair(2, COLOR_WHITE, COLOR_BLACK);

          break;

      case COLOR_GENERAL:

          init_pair(i+1, ((color) ? FindColor(color) : COLOR_WHITE),

                    FindColor(background));

          break;

      case COLOR_MSGOUT:

          init_pair(i+1, ((color) ? FindColor(color) : COLOR_CYAN),

                    FindColor(background));

          break;

      case COLOR_MSGHL:

          init_pair(i+1, ((color) ? FindColor(color) : COLOR_YELLOW),

                    FindColor(background));

          break;

      case COLOR_STATUS:

          init_pair(i+1, ((color) ? FindColor(color) : COLOR_WHITE),

                    FindColor(backstatus));

          break;

      case COLOR_ROSTER:

          init_pair(i+1, ((color) ? FindColor(color) : COLOR_GREEN),

                    FindColor(background));

          break;

      case COLOR_ROSTERSEL:

          init_pair(i+1, ((color) ? FindColor(color) : COLOR_BLUE),

                    FindColor(backselected));

          break;

      case COLOR_ROSTERSELNMSG:

          init_pair(i+1, ((color) ? FindColor(color) : COLOR_RED),

                    FindColor(backselected));

          break;

      case COLOR_ROSTERNMSG:

          init_pair(i+1, ((color) ? FindColor(color) : COLOR_RED),

                    FindColor(background));

          break;

      case COLOR_INFO:

          init_pair(i+1, ((color) ? FindColor(color) : COLOR_WHITE),