/*

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

#include <assert.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,

                       unsigned mucnicklen);

#ifdef HAVE_ASPELL_H

#define ASPELLBADCHAR 5

AspellConfig *spell_config;

AspellSpeller *spell_checker;

#endif

typedef struct {

  char *status, *wildcard;

  int color;

  GPatternSpec *compiled;

} rostercolor;

static GSList *rostercolrules = NULL;

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

typedef struct {

  bool manual;//Manually set?

  int color;

} nickcolor;

static int nickcolcount = 0, *nickcols = NULL;

static muccoltype glob_muccol = MC_OFF;

/* 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 int get_user_color(const char *color)

{

  bool isbright = false;

  int cl;

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

    isbright = true;

    color += 6;

  }

  cl = color_to_color_fg(FindColorInternal(color));

  if (cl < 0)

    return cl;

  if (isbright)

    cl += COLOR_BLACK_BOLD_FG - COLOR_BLACK_FG;

  return cl;

}

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_MucColor(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, "*")) {

      ensure_string_htable(&muccolors, g_free);

      muccoltype *value = g_new(muccoltype, 1);

      *value = type;

      g_hash_table_replace(muccolors, muclow, value);

    } else {

      glob_muccol = type;

      g_free(muclow);

    }

  }

  //Need to redraw?

    scr_UpdateBuddyWindow();

}

// 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_MucNickColor(const char *nick, const char *color)

{

  bool need_update = false;

  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 if (!strcmp(color, "!")) {

    if (nickcolors) {

      g_free(g_hash_table_lookup(nickcolors, snick));

      g_hash_table_remove(nickcolors, snick);

      g_hash_table_remove(nickcolors, mnick);

    }

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

    g_free(mnick);

    need_update = true;

  } else {

    int cl = get_user_color(color);

    if (cl < 0) {

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

}

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