#pragma once

#include "LibLsp/lsp/lsAny.h"
#include "LibLsp/JsonRpc/RequestInMessage.h"
#include "LibLsp/JsonRpc/lsResponseMessage.h"
#include "LibLsp/lsp/symbol.h"
#include "LibLsp/lsp/lsTextDocumentPositionParams.h"
#include "LibLsp/lsp/lsRange.h"

enum class SymbolTag
{
    Deprecated = 1
};
MAKE_REFLECT_TYPE_PROXY(SymbolTag)

struct CallHierarchyPrepareParams
{
    lsTextDocumentIdentifier textDocument;
    lsPosition position;

    MAKE_SWAP_METHOD(CallHierarchyPrepareParams, textDocument, position)
};
MAKE_REFLECT_STRUCT(CallHierarchyPrepareParams, textDocument, position)

/// Represents programming constructs like functions or constructors
/// in the context of call hierarchy.
struct CallHierarchyItem
{
    /// The name of this item.
    std::string name;

    /// The kind of this item.
    SymbolKind kind;

    /// Tags for this item.
    optional<std::vector<SymbolTag>> tags;

    /// More detaill for this item, e.g. the signature of a function.
    optional<std::string> detail;

    /// The resource identifier of this item.
    lsDocumentUri uri;

    /**
         * The range enclosing this symbol not including leading/trailing whitespace
         * but everything else, e.g. comments and code.
         */
    lsRange range;

    /**
         * The range that should be selected and revealed when this symbol is being
         * picked, e.g. the name of a function. Must be contained by the
         * [`range`](#CallHierarchyItem.range).
         */
    lsRange selectionRange;

    /**
         * A data entry field that is preserved between a call hierarchy prepare and
         * incoming calls or outgoing calls requests.
         */
    optional<lsp::Any> data;
    MAKE_SWAP_METHOD(CallHierarchyItem, name, kind, tags, detail, uri, range, selectionRange, data)
};
MAKE_REFLECT_STRUCT(CallHierarchyItem, name, kind, tags, detail, uri, range, selectionRange, data)

/// The parameter of a `callHierarchy/incomingCalls` request.
struct CallHierarchyIncomingCallsParams
{
    CallHierarchyItem item;
    MAKE_SWAP_METHOD(CallHierarchyIncomingCallsParams, item)
};
MAKE_REFLECT_STRUCT(CallHierarchyIncomingCallsParams, item)

/// Represents an incoming call, e.g. a caller of a method or constructor.
struct CallHierarchyIncomingCall
{
    /// The item that makes the call.
    CallHierarchyItem from;

    /// The range at which the calls appear.
    /// This is relative to the caller denoted by `From`.
    std::vector<lsRange> fromRanges;
    MAKE_SWAP_METHOD(CallHierarchyIncomingCall, from, fromRanges)
};
MAKE_REFLECT_STRUCT(CallHierarchyIncomingCall, from, fromRanges)

/// The parameter of a `callHierarchy/outgoingCalls` request.
struct CallHierarchyOutgoingCallsParams
{
    CallHierarchyItem item;
    MAKE_SWAP_METHOD(CallHierarchyOutgoingCallsParams, item)
};
MAKE_REFLECT_STRUCT(CallHierarchyOutgoingCallsParams, item)

/// Represents an outgoing call, e.g. calling a getter from a method or
/// a method from a constructor etc.
struct CallHierarchyOutgoingCall
{
    /// The item that is called.
    CallHierarchyItem to;

    /// The range at which this item is called.
    /// This is the range relative to the caller, and not `To`.
    std::vector<lsRange> fromRanges;
    MAKE_SWAP_METHOD(CallHierarchyOutgoingCall, to, fromRanges)
};
MAKE_REFLECT_STRUCT(CallHierarchyOutgoingCall, to, fromRanges)

DEFINE_REQUEST_RESPONSE_TYPE(
    td_prepareCallHierarchy, CallHierarchyPrepareParams, optional<std::vector<CallHierarchyItem>>,
    "textDocument/prepareCallHierarchy"
)

DEFINE_REQUEST_RESPONSE_TYPE(
    td_incomingCalls, CallHierarchyIncomingCallsParams, optional<std::vector<CallHierarchyIncomingCall>>,
    "callHierarchy/incomingCalls"
)

DEFINE_REQUEST_RESPONSE_TYPE(
    td_outgoingCalls, CallHierarchyOutgoingCallsParams, optional<std::vector<CallHierarchyOutgoingCall>>,
    "callHierarchy/CallHierarchyOutgoingCall"
)