/*

 * screen.c     -- UI stuff

 *

 * Copyright (C) 2005-2014 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, see <http://www.gnu.org/licenses/>.

 */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

#include <ctype.h>

#include <config.h>

#include <locale.h>

#include <assert.h>

#ifdef USE_SIGWINCH

# include <sys/ioctl.h>

# include <termios.h>

# include <unistd.h>

#endif

#ifdef HAVE_LOCALCHARSET_H

# include <localcharset.h>

#else

# include <langinfo.h>

#endif

#ifdef WITH_ENCHANT

# include <enchant.h>

#else

# ifdef WITH_ASPELL

#  include <aspell.h>

# endif

#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"

#include "xmpp.h"

#include "main.h"

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

#define compose_color(col)  (COLOR_PAIR(col->color_pair)|col->color_attrib)

#define DEFAULT_LOG_WIN_HEIGHT (5+2)

#define DEFAULT_ROSTER_WIDTH    24

#define CHAT_WIN_HEIGHT (maxY-1-Log_Win_Height)

#define DEFAULT_ATTENTION_CHAR '!'

const char *LocaleCharSet = "C";

static unsigned short int Log_Win_Height;

static unsigned short int Roster_Width;

static gboolean colors_stalled = FALSE;

// Default attention sign trigger levels

static guint ui_attn_sign_prio_level_muc = ROSTER_UI_PRIO_MUC_HL_MESSAGE;

static guint ui_attn_sign_prio_level     = ROSTER_UI_PRIO_ATTENTION_MESSAGE;

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(gboolean fwd);

static void scr_glog_print(const gchar *log_domain, GLogLevelFlags log_level,

                           const gchar *message, gpointer user_data);

#ifdef XEP0085

static gboolean scr_chatstates_timeout();

#endif

#if defined(WITH_ENCHANT) || defined(WITH_ASPELL)

static void spellcheck(char *, char *);

#endif

static void open_chat_window(void);

static void clear_inputline(void);

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;

  char      refcount; // refcount > 0 if there are other users of this struct

                      // e.g. with symlinked history

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

static int roster_no_leading_space;

static bool Curses;

static bool log_win_on_top;

static bool roster_win_on_right;

static guint autoaway_source = 0;

static char       inputLine[INPUTLINE_LENGTH+1];

#if defined(WITH_ENCHANT) || defined(WITH_ASPELL)

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;

static guint  chatstate_timeout_id = 0;

int _update_roster;

int utf8_mode;

gboolean chatstates_disabled;

gboolean Autoaway;

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

static void scr_write_in_window(const char *winId, const char *text,

                                time_t timestamp, unsigned int prefix_flags,

                                int force_show, unsigned mucnicklen,

                                gpointer xep184);

static void scr_write_message(const char *bjid, const char *text,

                              time_t timestamp, guint prefix_flags,

                              unsigned mucnicklen, gpointer xep184);

inline void scr_update_buddy_window(void);

inline void scr_set_chatmode(int enable);

#define SPELLBADCHAR 5

#if defined(WITH_ENCHANT) || defined(WITH_ASPELL)

typedef struct {

#ifdef WITH_ENCHANT

  EnchantBroker *broker;

  EnchantDict *checker;

#endif

#ifdef WITH_ASPELL

  AspellConfig *config;

  AspellSpeller *checker;

#endif

} spell_checker;

GSList* spell_checkers = NULL;

#endif

typedef struct {

  int color_pair;

  int color_attrib;

} ccolor;

typedef struct {

  char *status, *wildcard;

  ccolor *color;

  GPatternSpec *compiled;

} rostercolor;

static GSList *rostercolrules = NULL;

static GHashTable *muccolors = NULL, *nickcolors = NULL;

typedef struct {

  bool manual; // Manually set?

  ccolor *color;

} nickcolor;

static int nickcolcount = 0;

static ccolor ** nickcols = NULL;

static muccoltype glob_muccol = MC_OFF;

/* Functions */

static int find_color(const char *name)

{

  int result;

  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;

  // Directly support 256-color values

  result = atoi(name);

  if (result > 0 && (result < COLORS || !Curses))

    return result;

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

  return -1;

}

static ccolor *get_user_color(const char *color)

{

  bool isbright = FALSE;

  int cl;

  ccolor *ccol;

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

    isbright = TRUE;

    color += 6;

  }

  cl = find_color(color);

  if (cl < 0)

    return NULL;

  ccol = g_new0(ccolor, 1);

  ccol->color_attrib = isbright ? A_BOLD : A_NORMAL;

  ccol->color_pair = cl + COLOR_max; // User colors come after the internal ones

  return ccol;

}

static void ensure_string_htable(GHashTable **table,

                                 GDestroyNotify value_destroy_func)

{

  if (*table) // Have it already

    return;

  *table = g_hash_table_new_full(g_str_hash, g_str_equal,

      g_free, value_destroy_func);

}

// Sets the coloring mode for given MUC

// The MUC room does not need to be in the roster at that time

// muc - the JID of room

// type - the new type

void scr_muc_color(const char *muc, muccoltype type)

{

  gchar *muclow = g_utf8_strdown(muc, -1);

  if (type == MC_REMOVE) { // Remove it

    if (strcmp(muc, "*")) {

      if (muccolors && g_hash_table_lookup(muccolors, muclow))

        g_hash_table_remove(muccolors, muclow);

    } else {

      scr_LogPrint(LPRINT_NORMAL, "Can not remove global coloring mode");

    }

    g_free(muclow);

  } else { // Add or overwrite

    if (strcmp(muc, "*")) {

      muccoltype *value = g_new(muccoltype, 1);

      *value = type;

      ensure_string_htable(&muccolors, g_free);

      g_hash_table_replace(muccolors, muclow, value);

    } else {

      glob_muccol = type;

      g_free(muclow);

    }

  }

  // Need to redraw?

  if (chatmode &&

      ((buddy_search_jid(muc) == current_buddy) || !strcmp(muc, "*")))

    scr_update_buddy_window();

}

// Sets the color for nick in MUC

// If color is "-", the color is marked as automaticly assigned and is

// not used if the room is in the "preset" mode

void scr_muc_nick_color(const char *nick, const char *color)

{

  char *snick, *mnick;

  bool need_update = FALSE;

  snick = g_strdup_printf("<%s>", nick);

  mnick = g_strdup_printf("*%s ", nick);

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

    if (nickcolors) {

      nickcolor *nc = g_hash_table_lookup(nickcolors, snick);

      if (nc) { // Have this nick already

        nc->manual = FALSE;

        nc = g_hash_table_lookup(nickcolors, mnick);

        assert(nc); // Must have both at the same time

        nc->manual = FALSE;

      }// Else -> no color saved, nothing to delete

    }

    g_free(snick); // They are not saved in the hash

    g_free(mnick);

    need_update = TRUE;

  } else {

    ccolor *cl = get_user_color(color);

    if (!cl) {

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

      g_free(snick);

      g_free(mnick);

    } else {

      nickcolor *nc = g_new(nickcolor, 1);

      ensure_string_htable(&nickcolors, NULL);

      nc->manual = TRUE;

      nc->color = cl;

      // Free the struct, if any there already

      g_free(g_hash_table_lookup(nickcolors, mnick));

      // Save the new ones

      g_hash_table_replace(nickcolors, mnick, nc);

      g_hash_table_replace(nickcolors, snick, nc);

      need_update = TRUE;

    }

  }

  if (need_update && chatmode &&

      (buddy_gettype(BUDDATA(current_buddy)) & ROSTER_TYPE_ROOM))

    scr_update_buddy_window();

}

static void free_rostercolrule(rostercolor *col)

{

  g_free(col->status);

  g_free(col->wildcard);

  g_free(col->color);

  g_pattern_spec_free(col->compiled);

  g_free(col);

}

// Removes all roster coloring rules

void scr_roster_clear_color(void)

{

  GSList *head;

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

    free_rostercolrule(head->data);

  }

  g_slist_free(rostercolrules);

  rostercolrules = NULL;

  scr_update_roster();

}

// Adds, modifies or removes roster coloring rule

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

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

//