/*

Copyright (C) 2007,2008,2009 John P. Swensen
Copyright (C) 2010, 2011 Jacob Dawid

Octave 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, or (at your option) any
later version.

Octave 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 Octave; see the file COPYING.  If not, write to the Free
Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.

*/

// Born July 13, 2007.

#include "OctaveLink.h"

OctaveLink
  OctaveLink::m_singleton;


OctaveLink::OctaveLink ():QObject (), m_previousHistoryLength (0)
{
  m_symbolTableSemaphore = new QSemaphore (1);
  m_historySemaphore = new QSemaphore (1);
}

OctaveLink::~OctaveLink ()
{
}

int
OctaveLink::readlineEventHook ()
{
  OctaveLink::instance ()->processOctaveServerData ();
  return 0;
}

QString
OctaveLink::octaveValueAsQString (OctaveValue octaveValue)
{
  // Convert single qouted string.
  if (octaveValue.is_sq_string ())
    {
      return QString ("\'%1\'").arg (octaveValue.string_value ().c_str ());

      // Convert double qouted string.
    }
  else if (octaveValue.is_dq_string ())
    {
      return QString ("\"%1\"").arg (octaveValue.string_value ().c_str ());

      // Convert real scalar.
    }
  else if (octaveValue.is_real_scalar ())
    {
      return QString ("%1").arg (octaveValue.scalar_value ());

      // Convert complex scalar.
    }
  else if (octaveValue.is_complex_scalar ())
    {
      return QString ("%1 + %2i").arg (octaveValue.scalar_value ()).
	arg (octaveValue.complex_value ().imag ());

      // Convert range.
    }
  else if (octaveValue.is_range ())
    {
      return QString ("%1 : %2 : %3").arg (octaveValue.range_value ().
					   base ()).arg (octaveValue.
							 range_value ().
							 inc ()).
	arg (octaveValue.range_value ().limit ());

      // Convert real matrix.
    }
  else if (octaveValue.is_real_matrix ())
    {
      // TODO: Convert real matrix into a string.
      return QString ("{matrix}");

      // Convert complex matrix.
    }
  else if (octaveValue.is_complex_matrix ())
    {
      // TODO: Convert complex matrix into a string.
      return QString ("{complex matrix}");

      // If everything else does not fit, we could not recognize the type.
    }
  else
    {
      return QString ("<Type not recognized>");
    }
}

void
OctaveLink::fetchSymbolTable ()
{
  m_symbolTableSemaphore->acquire ();
  m_symbolTableBuffer.clear ();
  std::list < SymbolRecord > allVariables = symbol_table::all_variables ();
  std::list < SymbolRecord >::iterator iterator;
  for (iterator = allVariables.begin (); iterator != allVariables.end ();
       iterator++)
    m_symbolTableBuffer.append (iterator->dup ());
  m_symbolTableSemaphore->release ();
  emit symbolTableChanged ();
}


void
OctaveLink::fetchHistory ()
{
  int currentLen = command_history::length ();
  if (currentLen != m_previousHistoryLength)
    {
      m_historySemaphore->acquire ();
      for (int i = m_previousHistoryLength; i < currentLen; i++)
	{
	  m_historyBuffer.append (command_history::get_entry (i));
	}
      m_historySemaphore->release ();
      m_previousHistoryLength = currentLen;
      emit historyChanged ();
    }
}

QList < SymbolRecord > OctaveLink::currentSymbolTable ()
{
  QList < SymbolRecord > m_symbolTableCopy;

  // Generate a deep copy of the current symbol table.
  m_symbolTableSemaphore->acquire ();
  foreach (SymbolRecord symbolRecord, m_symbolTableBuffer)
    m_symbolTableCopy.append (symbolRecord.dup ());
  m_symbolTableSemaphore->release ();

  return m_symbolTableCopy;
}

string_vector
OctaveLink::currentHistory ()
{
  m_historySemaphore->acquire ();
  string_vector retval (m_historyBuffer);
  m_historyBuffer = string_vector ();
  m_historySemaphore->release ();
  return retval;
}

void
OctaveLink::processOctaveServerData ()
{
  fetchSymbolTable ();
  fetchHistory ();
}