class Binder {
public:

	explicit Binder(sqlite3_stmt* _handle) {
		handle = _handle;
		param_count = sqlite3_bind_parameter_count(_handle);
		anon_index = 0;
		success = true;
	}

	bool Bind(NODE_ARGUMENTS info, int argc, Statement* stmt) {
		assert(anon_index == 0);
		Result result = BindArgs(info, argc, stmt);
		if (success && result.count != param_count) {
			if (result.count < param_count) {
				if (!result.bound_object && stmt->GetBindMap(OnlyIsolate)->GetSize()) {
					Fail(ThrowTypeError, "Missing named parameters");
				} else {
					Fail(ThrowRangeError, "Too few parameter values were provided");
				}
			} else {
				Fail(ThrowRangeError, "Too many parameter values were provided");
			}
		}
		return success;
	}

private:

	struct Result {
		int count;
		bool bound_object;
	};

	static bool IsPlainObject(v8::Isolate* isolate, v8::Local<v8::Object> obj) {
		v8::Local<v8::Value> proto = GET_PROTOTYPE(obj);
		v8::Local<v8::Context> ctx = obj->GetCreationContext().ToLocalChecked();
		ctx->Enter();
		v8::Local<v8::Value> baseProto = GET_PROTOTYPE(v8::Object::New(isolate));
		ctx->Exit();
		return proto->StrictEquals(baseProto) || proto->StrictEquals(v8::Null(isolate));
	}

	void Fail(void (*Throw)(const char* _), const char* message) {
		assert(success == true);
		assert((Throw == NULL) == (message == NULL));
		assert(Throw == ThrowError || Throw == ThrowTypeError || Throw == ThrowRangeError || Throw == NULL);
		if (Throw) Throw(message);
		success = false;
	}

	int NextAnonIndex() {
		while (sqlite3_bind_parameter_name(handle, ++anon_index) != NULL) {}
		return anon_index;
	}

	// Binds the value at the given index or throws an appropriate error.
	void BindValue(v8::Isolate* isolate, v8::Local<v8::Value> value, int index) {
		int status = Data::BindValueFromJS(isolate, handle, index, value);
		if (status != SQLITE_OK) {
			switch (status) {
				case -1:
					return Fail(ThrowTypeError, "SQLite3 can only bind numbers, strings, bigints, buffers, and null");
				case SQLITE_TOOBIG:
					return Fail(ThrowRangeError, "The bound string, buffer, or bigint is too big");
				case SQLITE_RANGE:
					return Fail(ThrowRangeError, "Too many parameter values were provided");
				case SQLITE_NOMEM:
					return Fail(ThrowError, "Out of memory");
				default:
					return Fail(ThrowError, "An unexpected error occured while trying to bind parameters");
			}
			assert(false);
		}
	}

	// Binds each value in the array or throws an appropriate error.
	// The number of successfully bound parameters is returned.
	int BindArray(v8::Isolate* isolate, v8::Local<v8::Array> arr) {
		UseContext;
		uint32_t length = arr->Length();
		if (length > INT_MAX) {
			Fail(ThrowRangeError, "Too many parameter values were provided");
			return 0;
		}
		int len = static_cast<int>(length);
		for (int i = 0; i < len; ++i) {
			v8::MaybeLocal<v8::Value> maybeValue = arr->Get(ctx, i);
			if (maybeValue.IsEmpty()) {
				Fail(NULL, NULL);
				return i;
			}
			BindValue(isolate, maybeValue.ToLocalChecked(), NextAnonIndex());
			if (!success) {
				return i;
			}
		}
		return len;
	}

	// Binds all named parameters using the values found in the given object.
	// The number of successfully bound parameters is returned.
	// If a named parameter is missing from the object, an error is thrown.
	// This should only be invoked once per instance.
	int BindObject(v8::Isolate* isolate, v8::Local<v8::Object> obj, Statement* stmt) {
		UseContext;
		BindMap* bind_map = stmt->GetBindMap(isolate);
		BindMap::Pair* pairs = bind_map->GetPairs();
		int len = bind_map->GetSize();

		for (int i = 0; i < len; ++i) {
			v8::Local<v8::String> key = pairs[i].GetName(isolate);

			// Check if the named parameter was provided.
			v8::Maybe<bool> has_property = obj->HasOwnProperty(ctx, key);
			if (has_property.IsNothing()) {
				Fail(NULL, NULL);
				return i;
			}
			if (!has_property.FromJust()) {
				v8::String::Utf8Value param_name(isolate, key);
				Fail(ThrowRangeError, (std::string("Missing named parameter \"") + *param_name + "\"").c_str());
				return i;
			}

			// Get the current property value.
			v8::MaybeLocal<v8::Value> maybeValue = obj->Get(ctx, key);
			if (maybeValue.IsEmpty()) {
				Fail(NULL, NULL);
				return i;
			}

			BindValue(isolate, maybeValue.ToLocalChecked(), pairs[i].GetIndex());
			if (!success) {
				return i;
			}
		}

		return len;
	}

	// Binds all parameters using the values found in the arguments object.
	// Anonymous parameter values can be directly in the arguments object or in an Array.
	// Named parameter values can be provided in a plain Object argument.
	// Only one plain Object argument may be provided.
	// If an error occurs, an appropriate error is thrown.
	// The return value is a struct indicating how many parameters were successfully bound
	// and whether or not it tried to bind an object.
	Result BindArgs(NODE_ARGUMENTS info, int argc, Statement* stmt) {
		UseIsolate;
		int count = 0;
		bool bound_object = false;

		for (int i = 0; i < argc; ++i) {
			v8::Local<v8::Value> arg = info[i];

			if (arg->IsArray()) {
				count += BindArray(isolate, arg.As<v8::Array>());
				if (!success) break;
				continue;
			}

			if (arg->IsObject() && !node::Buffer::HasInstance(arg)) {
				v8::Local<v8::Object> obj = arg.As<v8::Object>();
				if (IsPlainObject(isolate, obj)) {
					if (bound_object) {
						Fail(ThrowTypeError, "You cannot specify named parameters in two different objects");
						break;
					}
					bound_object = true;

					count += BindObject(isolate, obj, stmt);
					if (!success) break;
					continue;
				} else if (stmt->GetBindMap(isolate)->GetSize()) {
					Fail(ThrowTypeError, "Named parameters can only be passed within plain objects");
					break;
				}
			}

			BindValue(isolate, arg, NextAnonIndex());
			if (!success) break;
			count += 1;
		}

		return { count, bound_object };
	}

	sqlite3_stmt* handle;
	int param_count;
	int anon_index; // This value should only be used by NextAnonIndex()
	bool success; // This value should only be set by Fail()
};