/*
 * Copyright (C) 2010 Igalia, S.L.
 * 
 * Author: Joaquim Rocha <jrocha@igalia.com>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <glib.h>
#include <string>
#include <iostream>
#include "presage.h"
#ifdef __cplusplus
extern "C" 
{
#include "text-predictor.h"
}
#endif

static gchar *string_to_gchar (std::string str);
GList *vector_string_to_glist (std::vector<std::string> string_vector);


class PredictCallback : public PresageCallback
{
 public:
  PredictCallback(gchar* new_contents, gint cursor_pos)
  { 
    contents = std::string(new_contents);
    cursor_position = cursor_pos;
  }

  void set_contents (gchar *new_contents, gint cursor_pos)
  {
    cursor_position = cursor_pos;
    contents = std::string(new_contents);
  }
  std::string get_past_stream () const
  {
    gint length = 0;
    if (cursor_position > 0)
    {
      length = cursor_position;
    }
    return contents.substr(0, length);
  }
  std::string get_future_stream () const
  {
    gint length = contents.length();
    gint position = 0;
    if (cursor_position > 0)
    {
      position = cursor_position;
    }
    return contents.substr(position, length);
  }

 private:
  std::string contents;
  gint cursor_position;
};

struct _TextPredictor
{
  PredictCallback *callback;
  Presage *presage;
};

void
text_predictor_free (TextPredictor *text_predictor)
{
  delete text_predictor->presage;
  delete text_predictor->callback;
  g_free (text_predictor);
}

gchar *
text_predictor_get_single_candidate_for_surrounding (TextPredictor *tp,
						     gchar *surrounding,
						     guint cursor_pos)
{
  tp->callback->set_contents (surrounding, cursor_pos);
  std::vector<std::string> predictions = tp->presage->predict();

  if (predictions.size() > 0)
  {
    return string_to_gchar (predictions[0]);
  }
  return NULL;
}

GList *
text_predictor_get_candidates_for_surrounding (TextPredictor *tp,
					       gchar *surrounding,
					       guint cursor_pos)
{
  tp->callback->set_contents (surrounding, cursor_pos);
  std::vector<std::string> predictions = tp->presage->predict();

  return vector_string_to_glist (predictions);
}

TextPredictor *
text_predictor_new (void)
{
  TextPredictor *tp = g_new0 (TextPredictor, 1);
  tp->callback = new PredictCallback((gchar *) "", -1);
  tp->presage = new Presage(tp->callback);
  return tp;
}

static gchar *
string_to_gchar (std::string str)
{
  const char *c_str = str.c_str();
  return g_strdup (c_str);
}

GList *
vector_string_to_glist (std::vector<std::string> string_vector)
{
  GList *list = NULL;
  size_t i;

  for (size_t i = 0; i < string_vector.size(); i++)
  {
    if (string_vector[i].length())
    {
      list = g_list_append (list, g_strdup ((gchar *) string_vector[i].c_str()));
    }
  }

  return list;
}