/*
 * Copyright (c) 2020-2021, Andreas Kling <kling@serenityos.org>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#pragma once

#include <LibJS/AST.h>
#include <LibJS/Bytecode/Generator.h>
#include <LibJS/Runtime/FunctionObject.h>

namespace JS {

// 10.2 ECMAScript Function Objects, https://tc39.es/ecma262/#sec-ecmascript-function-objects
class ECMAScriptFunctionObject final : public FunctionObject {
    JS_OBJECT(ECMAScriptFunctionObject, FunctionObject);

public:
    enum class ConstructorKind : u8 {
        Base,
        Derived,
    };

    enum class ThisMode : u8 {
        Lexical,
        Strict,
        Global,
    };

    static ECMAScriptFunctionObject* create(GlobalObject&, FlyString name, Statement const& ecmascript_code, Vector<FunctionNode::Parameter> parameters, i32 m_function_length, Environment* parent_scope, PrivateEnvironment* private_scope, FunctionKind, bool is_strict, bool might_need_arguments_object = true, bool contains_direct_call_to_eval = true, bool is_arrow_function = false);

    ECMAScriptFunctionObject(FlyString name, Statement const& ecmascript_code, Vector<FunctionNode::Parameter> parameters, i32 m_function_length, Environment* parent_scope, PrivateEnvironment* private_scope, Object& prototype, FunctionKind, bool is_strict, bool might_need_arguments_object, bool contains_direct_call_to_eval, bool is_arrow_function);
    virtual void initialize(GlobalObject&) override;
    virtual ~ECMAScriptFunctionObject();

    virtual ThrowCompletionOr<Value> internal_call(Value this_argument, MarkedValueList arguments_list) override;
    virtual ThrowCompletionOr<Object*> internal_construct(MarkedValueList arguments_list, FunctionObject& new_target) override;

    Statement const& ecmascript_code() const { return m_ecmascript_code; }
    Vector<FunctionNode::Parameter> const& formal_parameters() const { return m_formal_parameters; };

    virtual const FlyString& name() const override { return m_name; };
    void set_name(const FlyString& name);

    void set_is_class_constructor() { m_is_class_constructor = true; };

    auto& bytecode_executable() const { return m_bytecode_executable; }

    Environment* environment() { return m_environment; }
    virtual Realm* realm() const override { return m_realm; }

    ConstructorKind constructor_kind() const { return m_constructor_kind; };
    void set_constructor_kind(ConstructorKind constructor_kind) { m_constructor_kind = constructor_kind; }

    ThisMode this_mode() const { return m_this_mode; }

    Object* home_object() const { return m_home_object; }
    void set_home_object(Object* home_object) { m_home_object = home_object; }

    struct InstanceField {
        Variant<PropertyKey, PrivateName> name;
        ECMAScriptFunctionObject* initializer { nullptr };
    };

    Vector<InstanceField> const& fields() const { return m_fields; }
    void add_field(Variant<PropertyKey, PrivateName> property_key, ECMAScriptFunctionObject* initializer);

    Vector<PrivateElement> const& private_methods() const { return m_private_methods; }
    void add_private_method(PrivateElement method) { m_private_methods.append(move(method)); };

    // This is for IsSimpleParameterList (static semantics)
    bool has_simple_parameter_list() const { return m_has_simple_parameter_list; }

    // Equivalent to absence of [[Construct]]
    virtual bool has_constructor() const override { return m_kind == FunctionKind::Regular && !m_is_arrow_function; }

    FunctionKind kind() const { return m_kind; }

protected:
    virtual bool is_strict_mode() const final { return m_strict; }

    virtual Completion ordinary_call_evaluate_body();

private:
    virtual bool is_ecmascript_function_object() const override { return true; }
    virtual void visit_edges(Visitor&) override;

    ThrowCompletionOr<void> prepare_for_ordinary_call(ExecutionContext& callee_context, Object* new_target);
    void ordinary_call_bind_this(ExecutionContext&, Value this_argument);

    void async_function_start(PromiseCapability const&);
    void async_block_start(PromiseCapability const&, ExecutionContext&);

    ThrowCompletionOr<void> function_declaration_instantiation(Interpreter*);

    // Internal Slots of ECMAScript Function Objects, https://tc39.es/ecma262/#table-internal-slots-of-ecmascript-function-objects
    Environment* m_environment { nullptr };                       // [[Environment]]
    PrivateEnvironment* m_private_environment { nullptr };        // [[PrivateEnvironment]]
    Vector<FunctionNode::Parameter> const m_formal_parameters;    // [[FormalParameters]]
    NonnullRefPtr<Statement> m_ecmascript_code;                   // [[ECMAScriptCode]]
    ConstructorKind m_constructor_kind { ConstructorKind::Base }; // [[ConstructorKind]]
    Realm* m_realm { nullptr };                                   // [[Realm]]
    ThisMode m_this_mode { ThisMode::Global };                    // [[ThisMode]]
    bool m_strict { false };                                      // [[Strict]]
    Object* m_home_object { nullptr };                            // [[HomeObject]]
    Vector<InstanceField> m_fields;                               // [[Fields]]
    Vector<PrivateElement> m_private_methods;                     // [[PrivateMethods]]
    bool m_is_class_constructor { false };                        // [[IsClassConstructor]]

    FlyString m_name;
    Optional<Bytecode::Executable> m_bytecode_executable;
    i32 m_function_length { 0 };
    FunctionKind m_kind { FunctionKind::Regular };
    bool m_might_need_arguments_object { true };
    bool m_contains_direct_call_to_eval { true };
    bool m_is_arrow_function { false };
    bool m_has_simple_parameter_list { false };
};

}