/***************************************************************************
 *   Copyright (c) 2004 Werner Mayer <wmayer[at]users.sourceforge.net>     *
 *                                                                         *
 *   This file is part of the FreeCAD CAx development system.              *
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Library General Public           *
 *   License as published by the Free Software Foundation; either          *
 *   version 2 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 Library General Public License for more details.                  *
 *                                                                         *
 *   You should have received a copy of the GNU Library General Public     *
 *   License along with this library; see the file COPYING.LIB. If not,    *
 *   write to the Free Software Foundation, Inc., 59 Temple Place,         *
 *   Suite 330, Boston, MA  02111-1307, USA                                *
 *                                                                         *
 ***************************************************************************/


#include "PreCompiled.h"
#ifndef _PreComp_
# include <QByteArray>
# include <QInputDialog>
# include <QEventLoop>
# include <QTimer>
#endif

#include "PythonConsolePy.h"
#include "PythonConsole.h"
#include "MainWindow.h"

#include <Base/Console.h>
#include <Base/Exception.h>

using namespace Gui;

void PythonStdout::init_type()
{
    behaviors().name("PythonStdout");
    behaviors().doc("Redirection of stdout to FreeCAD's Python console window");
    // you must have overwritten the virtual functions
    behaviors().supportRepr();
    add_varargs_method("write",&PythonStdout::write,"write()");
    add_varargs_method("flush",&PythonStdout::flush,"flush()");
}

PythonStdout::PythonStdout(PythonConsole *pc)
  : pyConsole(pc)
{
}

PythonStdout::~PythonStdout()
{
}

Py::Object PythonStdout::getattr(const char *name)
{
    if (strcmp(name, "softspace") == 0) {
        int i=0;
        return Py::Int(i);
    }
    return getattr_methods(name);
}

Py::Object PythonStdout::repr()
{
    std::string s;
    std::ostringstream s_out;
    s_out << "PythonStdout";
    return Py::String(s_out.str());
}

Py::Object PythonStdout::write(const Py::Tuple& args)
{
    try {
        Py::Object output(args[0]);
        if (PyUnicode_Check(output.ptr())) {
            PyObject* unicode = PyUnicode_AsEncodedObject(output.ptr(), "utf-8", "strict");
            if (unicode) {
                const char* string = PyString_AsString(unicode);
                int maxlen = qstrlen(string) > 10000 ? 10000 : -1;
                pyConsole->insertPythonOutput(QString::fromUtf8(string, maxlen));
                Py_DECREF(unicode);
            }
        }
        else {
            Py::String text(args[0]);
            std::string string = (std::string)text;
            int maxlen = string.size() > 10000 ? 10000 : -1;
            pyConsole->insertPythonOutput(QString::fromUtf8(string.c_str(), maxlen));
        }
    }
    catch (Py::Exception& e) {
        // Do not provoke error messages 
        e.clear();
    }

    return Py::None();
}

Py::Object PythonStdout::flush(const Py::Tuple&)
{
    return Py::None();
}

// -------------------------------------------------------------------------

void PythonStderr::init_type()
{
    behaviors().name("PythonStderr");
    behaviors().doc("Redirection of stdout to FreeCAD's Python console window");
    // you must have overwritten the virtual functions
    behaviors().supportRepr();
    add_varargs_method("write",&PythonStderr::write,"write()");
    add_varargs_method("flush",&PythonStderr::flush,"flush()");
}

PythonStderr::PythonStderr(PythonConsole *pc)
  : pyConsole(pc)
{
}

PythonStderr::~PythonStderr()
{
}

Py::Object PythonStderr::getattr(const char *name)
{
    if (strcmp(name, "softspace") == 0) {
        int i=0;
        return Py::Int(i);
    }
    return getattr_methods(name);
}

Py::Object PythonStderr::repr()
{
    std::string s;
    std::ostringstream s_out;
    s_out << "PythonStderr";
    return Py::String(s_out.str());
}

Py::Object PythonStderr::write(const Py::Tuple& args)
{
    try {
        Py::Object output(args[0]);
        if (PyUnicode_Check(output.ptr())) {
            PyObject* unicode = PyUnicode_AsEncodedObject(output.ptr(), "utf-8", "strict");
            if (unicode) {
                const char* string = PyString_AsString(unicode);
                int maxlen = qstrlen(string) > 10000 ? 10000 : -1;
                pyConsole->insertPythonError(QString::fromUtf8(string, maxlen));
                Py_DECREF(unicode);
            }
        }
        else {
            Py::String text(args[0]);
            std::string string = (std::string)text;
            int maxlen = string.size() > 10000 ? 10000 : -1;
            pyConsole->insertPythonError(QString::fromUtf8(string.c_str(), maxlen));
        }
    }
    catch (Py::Exception& e) {
        // Do not provoke error messages
        e.clear();
    }

    return Py::None();
}

Py::Object PythonStderr::flush(const Py::Tuple&)
{
    return Py::None();
}

// -------------------------------------------------------------------------

void OutputStdout::init_type()
{
    behaviors().name("OutputStdout");
    behaviors().doc("Redirection of stdout to FreeCAD's output window");
    // you must have overwritten the virtual functions
    behaviors().supportRepr();
    add_varargs_method("write",&OutputStdout::write,"write()");
    add_varargs_method("flush",&OutputStdout::flush,"flush()");
}

OutputStdout::OutputStdout()
{
}

OutputStdout::~OutputStdout()
{
}

Py::Object OutputStdout::getattr(const char *name)
{
    if (strcmp(name, "softspace") == 0) {
        int i=0;
        return Py::Int(i);
    }
    return getattr_methods(name);
}

Py::Object OutputStdout::repr()
{
    std::string s;
    std::ostringstream s_out;
    s_out << "OutputStdout";
    return Py::String(s_out.str());
}

Py::Object OutputStdout::write(const Py::Tuple& args)
{
    try {
        Py::Object output(args[0]);
        if (PyUnicode_Check(output.ptr())) {
            PyObject* unicode = PyUnicode_AsEncodedObject(output.ptr(), "utf-8", "strict");
            if (unicode) {
                const char* string = PyString_AsString(unicode);
                Base::Console().Message("%s",string);
                Py_DECREF(unicode);
            }
        }
        else {
            Py::String text(args[0]);
            std::string string = (std::string)text;
            Base::Console().Message("%s",string.c_str());
        }
    }
    catch (Py::Exception& e) {
        // Do not provoke error messages
        e.clear();
    }

    return Py::None();
}

Py::Object OutputStdout::flush(const Py::Tuple&)
{
    return Py::None();
}

// -------------------------------------------------------------------------

void OutputStderr::init_type()
{
    behaviors().name("OutputStderr");
    behaviors().doc("Redirection of stdout to FreeCAD's output window");
    // you must have overwritten the virtual functions
    behaviors().supportRepr();
    add_varargs_method("write",&OutputStderr::write,"write()");
    add_varargs_method("flush",&OutputStderr::flush,"flush()");
}

OutputStderr::OutputStderr()
{
}

OutputStderr::~OutputStderr()
{
}

Py::Object OutputStderr::getattr(const char *name)
{
    if (strcmp(name, "softspace") == 0) {
        int i=0;
        return Py::Int(i);
    }
    return getattr_methods(name);
}

Py::Object OutputStderr::repr()
{
    std::string s;
    std::ostringstream s_out;
    s_out << "OutputStderr";
    return Py::String(s_out.str());
}

Py::Object OutputStderr::write(const Py::Tuple& args)
{
    try {
        Py::Object output(args[0]);
        if (PyUnicode_Check(output.ptr())) {
            PyObject* unicode = PyUnicode_AsEncodedObject(output.ptr(), "utf-8", "strict");
            if (unicode) {
                const char* string = PyString_AsString(unicode);
                Base::Console().Error("%s",string);
                Py_DECREF(unicode);
            }
        }
        else {
            Py::String text(args[0]);
            std::string string = (std::string)text;
            Base::Console().Error("%s",string.c_str());
        }
    }
    catch (Py::Exception& e) {
        // Do not provoke error messages
        e.clear();
    }

    return Py::None();
}

Py::Object OutputStderr::flush(const Py::Tuple&)
{
    return Py::None();
}

// -------------------------------------------------------------------------

void PythonStdin::init_type()
{
    behaviors().name("PythonStdin");
    behaviors().doc("Redirection of stdin to FreeCAD to open an input dialog");
    // you must have overwritten the virtual functions
    behaviors().supportRepr();
    add_varargs_method("readline",&PythonStdin::readline,"readline()");
}

PythonStdin::PythonStdin(PythonConsole *pc)
  : pyConsole(pc)
{
}

PythonStdin::~PythonStdin()
{
}

Py::Object PythonStdin::repr()
{
    std::string s;
    std::ostringstream s_out;
    s_out << "PythonStdin";
    return Py::String(s_out.str());
}

Py::Object PythonStdin::readline(const Py::Tuple& args)
{
    return Py::String( (const char *)pyConsole->readline().toLatin1() );
}