//===-- EditlineTest.cpp ----------------------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#ifndef LLDB_DISABLE_LIBEDIT

#define EDITLINE_TEST_DUMP_OUTPUT 0

#include <stdio.h>
#include <unistd.h>

#include <memory>
#include <thread>

#include "gtest/gtest.h"

#include "lldb/Core/Error.h"
#include "lldb/Core/StringList.h"
#include "lldb/Host/Editline.h"
#include "lldb/Host/Pipe.h"
#include "lldb/Utility/PseudoTerminal.h"

namespace
{
    const size_t TIMEOUT_MILLIS = 5000;
}

class FilePointer
{
public:

    FilePointer () = delete;

    FilePointer (const FilePointer&) = delete;

    FilePointer (FILE *file_p)
    : _file_p (file_p)
    {
    }

    ~FilePointer ()
    {
        if (_file_p != nullptr)
        {
            const int close_result = fclose (_file_p);
            EXPECT_EQ(0, close_result);
        }
    }

    operator FILE* ()
    {
        return _file_p;
    }

private:

    FILE *_file_p;

};

/**
 Wraps an Editline class, providing a simple way to feed
 input (as if from the keyboard) and receive output from Editline.
 */
class EditlineAdapter
{
public:

    EditlineAdapter ();

    void
    CloseInput ();

    bool
    IsValid () const
    {
        return _editline_sp.get () != nullptr;
    }

    lldb_private::Editline&
    GetEditline ()
    {
        return *_editline_sp;
    }

    bool
    SendLine (const std::string &line);

    bool
    SendLines (const std::vector<std::string> &lines);

    bool
    GetLine (std::string &line, bool &interrupted, size_t timeout_millis);

    bool
    GetLines (lldb_private::StringList &lines, bool &interrupted, size_t timeout_millis);

    void
    ConsumeAllOutput ();

private:

    static bool
    IsInputComplete (
        lldb_private::Editline * editline,
        lldb_private::StringList & lines,
        void * baton);

    std::unique_ptr<lldb_private::Editline> _editline_sp;

    lldb_utility::PseudoTerminal _pty;
    int _pty_master_fd;
    int _pty_slave_fd;

    std::unique_ptr<FilePointer> _el_slave_file;
};

EditlineAdapter::EditlineAdapter () :
    _editline_sp (),
    _pty (),
    _pty_master_fd (-1),
    _pty_slave_fd (-1),
    _el_slave_file ()
{
    lldb_private::Error error;

    // Open the first master pty available.
    char error_string[256];
    error_string[0] = '\0';
    if (!_pty.OpenFirstAvailableMaster (O_RDWR, error_string, sizeof (error_string)))
    {
        fprintf(stderr, "failed to open first available master pty: '%s'\n", error_string);
        return;
    }

    // Grab the master fd.  This is a file descriptor we will:
    // (1) write to when we want to send input to editline.
    // (2) read from when we want to see what editline sends back.
    _pty_master_fd = _pty.GetMasterFileDescriptor();

    // Open the corresponding slave pty.
    if (!_pty.OpenSlave (O_RDWR, error_string, sizeof (error_string)))
    {
        fprintf(stderr, "failed to open slave pty: '%s'\n", error_string);
        return;
    }
    _pty_slave_fd = _pty.GetSlaveFileDescriptor();

    _el_slave_file.reset (new FilePointer (fdopen (_pty_slave_fd, "rw")));
    EXPECT_FALSE (nullptr == *_el_slave_file);
    if (*_el_slave_file == nullptr)
        return;

    // Create an Editline instance.
    _editline_sp.reset (new lldb_private::Editline("gtest editor", *_el_slave_file, *_el_slave_file, *_el_slave_file, false));
    _editline_sp->SetPrompt ("> ");

    // Hookup our input complete callback.
    _editline_sp->SetIsInputCompleteCallback(IsInputComplete, this);
}

void
EditlineAdapter::CloseInput ()
{
    if (_el_slave_file != nullptr)
        _el_slave_file.reset (nullptr);
}

bool
EditlineAdapter::SendLine (const std::string &line)
{
    // Ensure we're valid before proceeding.
    if (!IsValid ())
        return false;

    // Write the line out to the pipe connected to editline's input.
    ssize_t input_bytes_written =
        ::write (_pty_master_fd,
                 line.c_str(),
                 line.length() * sizeof (std::string::value_type));

    const char *eoln = "\n";
    const size_t eoln_length = strlen(eoln);
    input_bytes_written =
        ::write (_pty_master_fd,
                 eoln,
                 eoln_length * sizeof (char));

    EXPECT_NE(-1, input_bytes_written) << strerror(errno);
    EXPECT_EQ (eoln_length * sizeof (char), size_t(input_bytes_written));
    return eoln_length * sizeof (char) == size_t(input_bytes_written);
}

bool
EditlineAdapter::SendLines (const std::vector<std::string> &lines)
{
    for (auto &line : lines)
    {
#if EDITLINE_TEST_DUMP_OUTPUT
        printf ("<stdin> sending line \"%s\"\n", line.c_str());
#endif
        if (!SendLine (line))
            return false;
    }
    return true;
}

// We ignore the timeout for now.
bool
EditlineAdapter::GetLine (std::string &line, bool &interrupted, size_t /* timeout_millis */)
{
    // Ensure we're valid before proceeding.
    if (!IsValid ())
        return false;

    _editline_sp->GetLine (line, interrupted);
    return true;
}

bool
EditlineAdapter::GetLines (lldb_private::StringList &lines, bool &interrupted, size_t /* timeout_millis */)
{
    // Ensure we're valid before proceeding.
    if (!IsValid ())
        return false;
    
    _editline_sp->GetLines (1, lines, interrupted);
    return true;
}

bool
EditlineAdapter::IsInputComplete (
        lldb_private::Editline * editline,
        lldb_private::StringList & lines,
        void * baton)
{
    // We'll call ourselves complete if we've received a balanced set of braces.
    int start_block_count = 0;
    int brace_balance = 0;

    for (size_t i = 0; i < lines.GetSize (); ++i)
    {
        for (auto ch : lines[i])
        {
            if (ch == '{')
            {
                ++start_block_count;
                ++brace_balance;
            }
            else if (ch == '}')
                --brace_balance;
        }
    }

    return (start_block_count > 0) && (brace_balance == 0);
}

void
EditlineAdapter::ConsumeAllOutput ()
{
    FilePointer output_file (fdopen (_pty_master_fd, "r"));

    int ch;
    while ((ch = fgetc(output_file)) != EOF)
    {
#if EDITLINE_TEST_DUMP_OUTPUT
        char display_str[] = { 0, 0, 0 };
        switch (ch)
        {
            case '\t':
                display_str[0] = '\\';
                display_str[1] = 't';
                break;
            case '\n':
                display_str[0] = '\\';
                display_str[1] = 'n';
                break;
            case '\r':
                display_str[0] = '\\';
                display_str[1] = 'r';
                break;
            default:
                display_str[0] = ch;
                break;
        }
        printf ("<stdout> 0x%02x (%03d) (%s)\n", ch, ch, display_str);
        // putc(ch, stdout);
#endif
    }
}

class EditlineTestFixture : public ::testing::Test
{
private:
    EditlineAdapter _el_adapter;
    std::shared_ptr<std::thread> _sp_output_thread;

public:
    void SetUp()
    {
        // We need a TERM set properly for editline to work as expected.
        setenv("TERM", "vt100", 1);

        // Validate the editline adapter.
        EXPECT_TRUE(_el_adapter.IsValid());
        if (!_el_adapter.IsValid())
            return;

        // Dump output.
        _sp_output_thread.reset(new std::thread([&] { _el_adapter.ConsumeAllOutput(); }));
    }

    void TearDown()
    {
        _el_adapter.CloseInput();
        if (_sp_output_thread)
            _sp_output_thread->join();
    }

    EditlineAdapter &GetEditlineAdapter() { return _el_adapter; }
};

TEST_F(EditlineTestFixture, EditlineReceivesSingleLineText)
{
    // Send it some text via our virtual keyboard.
    const std::string input_text ("Hello, world");
    EXPECT_TRUE(GetEditlineAdapter().SendLine(input_text));

    // Verify editline sees what we put in.
    std::string el_reported_line;
    bool input_interrupted = false;
    const bool received_line = GetEditlineAdapter().GetLine(el_reported_line, input_interrupted, TIMEOUT_MILLIS);

    EXPECT_TRUE (received_line);
    EXPECT_FALSE (input_interrupted);
    EXPECT_EQ (input_text, el_reported_line);
}

TEST_F(EditlineTestFixture, EditlineReceivesMultiLineText)
{
    // Send it some text via our virtual keyboard.
    std::vector<std::string> input_lines;
    input_lines.push_back ("int foo()");
    input_lines.push_back ("{");
    input_lines.push_back ("printf(\"Hello, world\");");
    input_lines.push_back ("}");
    input_lines.push_back ("");

    EXPECT_TRUE(GetEditlineAdapter().SendLines(input_lines));

    // Verify editline sees what we put in.
    lldb_private::StringList el_reported_lines;
    bool input_interrupted = false;

    EXPECT_TRUE(GetEditlineAdapter().GetLines(el_reported_lines, input_interrupted, TIMEOUT_MILLIS));
    EXPECT_FALSE (input_interrupted);

    // Without any auto indentation support, our output should directly match our input.
    EXPECT_EQ (input_lines.size (), el_reported_lines.GetSize ());
    if (input_lines.size () == el_reported_lines.GetSize ())
    {
        for (size_t i = 0; i < input_lines.size(); ++i)
            EXPECT_EQ (input_lines[i], el_reported_lines[i]);
    }
}

#endif