Php::Value DI::get(Php::Parameters &params)
	{
		try {
			Php::Value name = params.at(0);
			Php::Value parameters = params.size() > 1 ? params.at(1) : Php::Value(nullptr);
		} catch (const std::out_of_range& e) {
			throw Php::Exception("Invalid number of parameters supplied");
		}

		return this;
	}

	Php::Value DI::set(Php::Parameters &params)
	{
		try {
			Php::Value name = params.at(0);
			Php::Value definition = params.at(1);
			Php::Value shared = params.size() > 2 ? params.at(2) : Php::Value(false);
		} catch (const std::out_of_range& e) {
			throw Php::Exception("Invalid number of parameters supplied");
		}

		return this;
	}

void CRowsPhpBridge::pushBack(Php::Parameters &params)
{
    if(params.size() > 0) {
        if(Php::Type::Object == params.at(0).type()) {
            if(params.at(0).implementation()){
                CRowPhpBridge *pRowPhpBridge = dynamic_cast<CRowPhpBridge*>(params.at(0).implementation());
                if(pRowPhpBridge) {
                    SYNOPSIS_DBG_ERR_LOG("CRowsPhpBridge::pushBack\n");
                    m_Rows.push_back(pRowPhpBridge->daoRow());
                }
            }
        }
    }
}

Php::Value Database::Open(Php::Parameters &params)
{
	if(IsOpen())
	{
		m_last_error = ErrorMessages::AlreadyActiveConnection;
		return false;
	}

	bool create_if_missing = false;

	if(params.empty() || !params[0].isBool())
		create_if_missing = false;
	else
		create_if_missing = params[0].boolValue();

	rocksdb::Options options;
	options.create_if_missing = create_if_missing;

	rocksdb::Status status = rocksdb::DB::Open(options, m_db_path, &m_rdb);

	if(!status.ok())
	{
		m_last_error = status.ToString();
		m_is_open = false;
		return false;
	}

	m_is_open = true;

	return true;
}

/**
 *  Assign a variable to the javascript context
 *
 *  @param  params  array of parameters:
 *                  -   string  name of property to assign  required
 *                  -   mixed   property value to assign    required
 *                  -   integer property attributes         optional
 *
 *  The property attributes can be one of the following values
 *
 *  - ReadOnly
 *  - DontEnum
 *  - DontDelete
 *
 *  If not specified, the property will be writable, enumerable and
 *  deletable.
 */
void Context::assign(Php::Parameters &params)
{
    // create a local "scope" and "enter" our context
    v8::HandleScope         scope(isolate());
    v8::Context::Scope      contextScope(_context);

    // retrieve the global object from the context
    v8::Local<v8::Object>   global(_context->Global());

    // the attribute for the newly assigned property
    v8::PropertyAttribute   attribute(v8::None);

    // if an attribute was given, assign it
    if (params.size() > 2)
    {
        // check the attribute that was selected
        switch ((int16_t)params[2])
        {
            case v8::None:          attribute = v8::None;       break;
            case v8::ReadOnly:      attribute = v8::ReadOnly;   break;
            case v8::DontDelete:    attribute = v8::DontDelete; break;
            case v8::DontEnum:      attribute = v8::DontEnum;   break;
        }
    }

    // and store the value
    global->ForceSet(value(params[0]), value(params[1]), attribute);
}

Php::Value FastImage::resize(Php::Parameters &parameters)
{
	Php::Value self(this);

	int width  = parameters[0];
	int height = parameters[1];
	bool save_ascpect_ratio = true;

	if (parameters.size() == 3) {
		save_ascpect_ratio =  parameters[2];
	}

	if (save_ascpect_ratio) {
	   std::vector<int> calculated_size = calculateResizedImageSize(width, height);
	   width  = calculated_size[0];
	   height = calculated_size[1];
	}

	cv::Mat resizedImage;
	if (width > 0 && height > 0) {
	  cv::Size new_size;
	  new_size.width = width;
	  new_size.height = height;
	  cv::resize(cvImage, resizedImage, new_size);
	} else {
		throwToSmallException("FastImage::resize");
	}

	cvImage = resizedImage;
	resizedImage.release();

	return self;
}

/**
 *  my_with_defined_object_parameters_function()
 *  The use of objects is not yet implemented.
 *  @param Php::Parameters      the given parameters
 */
void my_with_defined_object_parameters_function(Php::Parameters &params)
{
    for (unsigned int i = 0; i < params.size(); i++)
    {
        cout << params[i] << endl;
    }
}

Php::Value GtkDialog_::new_with_buttons(Php::Parameters &parameters)
{
	std::string s_title = parameters[0];
	gchar *title = (gchar *)s_title.c_str();

	GtkWindow *parent;
	if(parameters.size() > 1) {
		Php::Value object_parent = parameters[1];
		GtkWindow_ *phpgtk_parent = (GtkWindow_ *)object_parent.implementation();
		parent = GTK_WINDOW(phpgtk_parent->get_instance());
	}

	int int_flags = (int)parameters[2];
	GtkDialogFlags flags = (GtkDialogFlags)int_flags;

	// std::string s_first_button_text = parameters[3];
	// gchar *first_button_text = (gchar *)s_first_button_text.c_str();

	// Create object
	GtkDialog_ *dialog = new GtkDialog_();
	// dialog->__construct();

	// gtk_window_set_title(GTK_WINDOW(dialog->instance), title);
	// gtk_widget_set_parent(GTK_WIDGET(dialog->instance), GTK_WIDGET(parent));
	// gtk_dialog_add_button(GTK_DIALOG(dialog->instance), "OK", GTK_RESPONSE_OK);
	// gtk_dialog_add_button(GTK_DIALOG(dialog->instance), "Cancel", GTK_RESPONSE_CANCEL);

	dialog->set_instance((gpointer *)gtk_dialog_new_with_buttons(title, GTK_WINDOW(parent), flags, "OK", GTK_RESPONSE_OK, "Cancel", GTK_RESPONSE_CANCEL, NULL));


	return Php::Object("GtkDialog", dialog);
}

void Database::__construct(Php::Parameters &params)
{
	if(params.empty() || !params[0].isString())
		Php::ThrowError(ErrorMessages::InvalidParamExpectedString);

	m_db_path = params[0].stringValue();
}

/**
 *  my_with_undefined_parameters_function()
 *  @param  Php:Parameters  the given parameters
 */
void my_with_undefined_parameters_function(Php::Parameters &params)
{
    for (unsigned int i = 0; i < params.size(); i++)
    {
        cout << "Parameter " << i << ": " << params[i] << endl;
    }
}

Php::Value Database::Put(Php::Parameters &params)
{
	if(params.empty() || params.size() < 2)
		Php::ThrowError(ErrorMessages::ExpectedTwoParamters);

	if(!IsOpen())
	{
		m_last_error = ErrorMessages::NoActiveConnection;
		return false;
	}

	std::string key = params[0].stringValue();
	std::string value = params[1].stringValue();

	m_rdb->Put(rocksdb::WriteOptions(), key, value);

	return true;
}

	void DI::setDefault(Php::Parameters &params)
	{
		try {
			Php::Value value = params.at(0);
			_default = (DI *) value.implementation();
		} catch (const std::out_of_range& e) {
			throw Php::Exception("Invalid number of parameters supplied");
		}
	}

/**
 *  my_with_defined_parameters_function()
 *  @param  Php::Parameters     the given parameters
 *  @return Php::Value          Param[0] and Param[1] added
 */
Php::Value my_with_defined_parameters_function(Php::Parameters &params)
{
    for (unsigned int i = 0; i < params.size(); i++)
    {
        cout << "Parameter " << i << ": " << params[i] << endl;
    }
    
    return params[0] + params[1];
}

 void __construct(Php::Parameters &params) {
     if (params.size() == 2) {
         r = params[0];
         i = params[1];
     } else {
         r = 0;
         i = 0;
     }
 }

void GtkClipboard_::set_image(Php::Parameters &parameters)
{
	GdkPixbuf *pixbuf;
	if(parameters.size() > 0) {
		Php::Value object_pixbuf = parameters[0];
		GdkPixbuf_ *phpgtk_pixbuf = (GdkPixbuf_ *)object_pixbuf.implementation();
		pixbuf = phpgtk_pixbuf->get_instance();
	}

	gtk_clipboard_set_image (GTK_CLIPBOARD(instance), pixbuf);

}

void GtkFileChooserDialog_::set_filter(Php::Parameters &parameters)
{
	GtkFileFilter *filter;
	if(parameters.size() > 0) {
		Php::Value object_filter = parameters[0];
		GtkFileFilter_ *phpgtk_filter = (GtkFileFilter_ *)object_filter.implementation();
		filter = GTK_FILE_FILTER(phpgtk_filter->get_instance());
	}

	gtk_file_chooser_set_filter (GTK_FILE_CHOOSER(instance), filter);

}

void GtkTextTagTable_::remove(Php::Parameters &parameters)
{
	GtkTextTag *tag;
	if(parameters.size() > 0) {
		Php::Value object_tag = parameters[0];
		GtkTextTag_ *phpgtk_tag = (GtkTextTag_ *)object_tag.implementation();
		tag = (phpgtk_tag->get_tag());
	}

	gtk_text_tag_table_remove (GTK_TEXT_TAG_TABLE(instance), tag);

}

void GtkFileChooserDialog_::set_extra_widget(Php::Parameters &parameters)
{
	GtkWidget *extra_widget;
	if(parameters.size() > 0) {
		Php::Value object_extra_widget = parameters[0];
		GtkWidget_ *phpgtk_extra_widget = (GtkWidget_ *)object_extra_widget.implementation();
		extra_widget = GTK_WIDGET(phpgtk_extra_widget->get_instance());
	}

	gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER(instance), extra_widget);

}

void GtkMenuItem_::set_submenu(Php::Parameters &parameters)
{
	GtkWidget *submenu;
	if(parameters.size() > 0) {
		Php::Value object_submenu = parameters[0];
		GtkWidget_ *phpgtk_submenu = (GtkWidget_ *)object_submenu.implementation();
		submenu = GTK_WIDGET(phpgtk_submenu->get_instance());
	}

	gtk_menu_item_set_submenu (GTK_MENU_ITEM(instance), submenu);

}

void GtkLabel_::set_mnemonic_widget(Php::Parameters &parameters)
{
	GtkWidget *widget;
	if(parameters.size() > 0) {
		Php::Value object_widget = parameters[0];
		GtkWidget_ *phpgtk_widget = (GtkWidget_ *)object_widget.implementation();
		widget = GTK_WIDGET(phpgtk_widget->get_instance());
	}

	gtk_label_set_mnemonic_widget (GTK_LABEL(instance), widget);

}