from _pydevd_bundle._debug_adapter.pydevd_schema import InitializeRequest, \
    InitializeRequestArguments, InitializeResponse, Capabilities
from _pydevd_bundle._debug_adapter import pydevd_schema, pydevd_base_schema
from _pydevd_bundle._debug_adapter.pydevd_schema import ThreadsResponse


def test_schema():

    json_msg = '''
{
    "arguments": {
        "adapterID": "pydevd",
        "clientID": "vscode",
        "clientName": "Visual Studio Code",
        "columnsStartAt1": true,
        "linesStartAt1": true,
        "locale": "en-us",
        "pathFormat": "path",
        "supportsRunInTerminalRequest": true,
        "supportsVariablePaging": true,
        "supportsVariableType": true
    },
    "command": "initialize",
    "seq": 1,
    "type": "request"
}'''

    initialize_request = pydevd_base_schema.from_json(json_msg)
    assert initialize_request.__class__ == InitializeRequest
    assert initialize_request.arguments.__class__ == InitializeRequestArguments
    assert initialize_request.arguments.adapterID == 'pydevd'
    assert initialize_request.command == 'initialize'
    assert initialize_request.type == 'request'
    assert initialize_request.seq == 1

    response = pydevd_base_schema.build_response(initialize_request)
    assert response.__class__ == InitializeResponse
    assert response.seq == -1  # Must be set before sending
    assert response.command == 'initialize'
    assert response.type == 'response'
    assert response.body.__class__ == Capabilities

    assert response.to_dict() == {
        "seq":-1,
        "type": "response",
        "request_seq": 1,
        "success": True,
        "command": "initialize",
        "body": {}
    }

    capabilities = response.body  # : :type capabilities: Capabilities
    capabilities.supportsCompletionsRequest = True
    assert response.to_dict() == {
        "seq":-1,
        "type": "response",
        "request_seq": 1,
        "success": True,
        "command": "initialize",
        "body": {'supportsCompletionsRequest':True}
    }

    initialize_event = pydevd_schema.InitializedEvent()
    assert initialize_event.to_dict() == {
        "seq":-1,
        "type": "event",
        "event": "initialized"
    }


def test_schema_translation_frame():
    pydevd_base_schema.BaseSchema.initialize_ids_translation()
    stack_trace_arguments = pydevd_schema.StackTraceArguments(threadId=1)
    stack_trace_request = pydevd_schema.StackTraceRequest(stack_trace_arguments)

    stackFrames = [
        pydevd_schema.StackFrame(id=2 ** 45, name='foo', line=1, column=1).to_dict(),
        pydevd_schema.StackFrame(id=2 ** 46, name='bar', line=1, column=1).to_dict(),
    ]
    body = pydevd_schema.StackTraceResponseBody(stackFrames)
    stack_trace_response = pydevd_base_schema.build_response(stack_trace_request, kwargs=dict(body=body))
    as_dict = stack_trace_response.to_dict(update_ids_to_dap=True)
    assert as_dict == {
        'type': 'response',
        'request_seq':-1,
        'success': True,
        'command': 'stackTrace',
        'body': {'stackFrames': [
            {'id': 1, 'name': 'foo', 'line': 1, 'column': 1, 'source': {}},
            {'id': 2, 'name': 'bar', 'line': 1, 'column': 1, 'source': {}},
        ]},
        'seq':-1}

    reconstructed = pydevd_base_schema.from_dict(as_dict, update_ids_from_dap=True)
    assert reconstructed.to_dict() == {
        'type': 'response',
        'request_seq':-1,
        'success': True,
        'command': 'stackTrace',
        'body': {'stackFrames': [
            {'id': 2 ** 45, 'name': 'foo', 'line': 1, 'column': 1, 'source': {}},
            {'id': 2 ** 46, 'name': 'bar', 'line': 1, 'column': 1, 'source': {}}
        ]},
        'seq':-1
    }


def test_schema_translation_thread():
    from _pydevd_bundle._debug_adapter.pydevd_schema import ThreadsRequest
    pydevd_base_schema.BaseSchema.initialize_ids_translation()

    threads = [
        pydevd_schema.Thread(id=2 ** 45, name='foo').to_dict(),
        pydevd_schema.Thread(id=2 ** 46, name='bar').to_dict(),
    ]
    body = pydevd_schema.ThreadsResponseBody(threads)
    threads_request = ThreadsRequest()
    threads_response = pydevd_base_schema.build_response(threads_request, kwargs=dict(body=body))
    as_dict = threads_response.to_dict(update_ids_to_dap=True)
    assert as_dict == {
        'type': 'response',
        'request_seq':-1,
        'success': True,
        'command': 'threads',
        'body': {'threads': [
            {'id': 1, 'name': 'foo'},
            {'id': 2, 'name': 'bar'},
        ]},
        'seq':-1}

    reconstructed = pydevd_base_schema.from_dict(as_dict, update_ids_from_dap=True)
    assert reconstructed.to_dict() == {
        'type': 'response',
        'request_seq':-1,
        'success': True,
        'command': 'threads',
        'body': {'threads': [
            {'id': 2 ** 45, 'name': 'foo'},
            {'id': 2 ** 46, 'name': 'bar'}
        ]},
        'seq':-1
    }