// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef SRC_LIB_LINE_INPUT_MODAL_LINE_INPUT_H_
#define SRC_LIB_LINE_INPUT_MODAL_LINE_INPUT_H_

#include "lib/fit/function.h"
#include "src/lib/line_input/line_input.h"

namespace line_input {

struct ModalPromptOptions {
  // When set, requires that the user press enter after typing. Otherwise, if the user has typed
  // an input that matches one of the options it will be implicitly accepted. Implicit enter
  // normally only makes sense for single-letter input ("y"/"n" type things).
  bool require_enter = true;

  // Compares a lower-case version of the user input to the option values. The option values must
  // be lower-case for this to work. The lower-cased version of the input will be passed to the
  // accept callback.
  bool case_sensitive = false;

  // Possible valid options that will cause the prompt to accept the input. If accepting case
  // insensitive input, these should be lower-case.
  std::vector<std::string> options;

  // When nonempty, this string input will be sent when control-C is pressed. This provides a way
  // for the caller to specify the behavior of Control-C without having another code path.
  //
  // This should be one of the |options| strings. It will be passed unvalidated to the callback.
  std::string cancel_option;
};

// Manages multiple line input objects to manage regular input and temporary modal input for
// questions. This is a base class, it delegates to a derived class to provide the line editor
// implementations for different I/O schemes.
class ModalLineInput : public LineInput {
 public:
  using Factory = std::function<std::unique_ptr<LineInput>(AcceptCallback accept_cb,
                                                           const std::string& prompt)>;

  // In response to this callback, the implementation should call EndModal() if modal input is
  // complete.
  using ModalCompletionCallback = fit::function<void(const std::string&)>;

  // Callback that the modal input is about to be shown. In the normal case where there is no
  // current modal prompt open, it will be called immediately from BeginModal(). But implementing
  // this allows the embedder to properly handle the nested modal prompt case.
  //
  // It is expected that embedders will use this to display text that would go above the modal
  // prompt.
  using WillShowModalCallback = fit::callback<void()>;

  // The constructor takes a factory function for the underlying LineInput types. These are used
  // to actually get input for the normal case and the modal input case. By default (null factory
  // function), a "stdout" line input will be used which is the expected behavior. Replacing the
  // line input implementation allows tests to use this class without using stdout.
  //
  // Must call Init() before using any functions.
  explicit ModalLineInput(Factory factory = Factory());
  virtual ~ModalLineInput() = default;

  // This can't be in the constructor because it needs to call virtual functions.
  void Init(AcceptCallback accept_cb, const std::string& prompt);

  // LineInput implementation.
  void SetAutocompleteCallback(AutocompleteCallback cb) override;
  void SetChangeCallback(ChangeCallback cb) override;
  void SetCancelCallback(CancelCallback cb) override;
  void SetEofCallback(EofCallback cb) override;
  void SetMaxCols(size_t max) override;
  const std::string& GetLine() const override;
  const std::deque<std::string>& GetHistory() const override;
  void OnInput(char c) override;
  void AddToHistory(const std::string& line) override;
  void Hide(
      InterruptHandlingBehavior behavior = InterruptHandlingBehavior::kHandleInterrupts) override;
  void Show() override;
  void SetCurrentInput(const std::string& input) override;

  // Higher-level version of BeginModal() and EndModal() that takes a list of possible options and
  // will call the callback only when the user enters a match for one of the options. The completion
  // callback should not need to call EndModal(), it will be done automatically when a valid input
  // is selected.
  void ModalGetOption(const ModalPromptOptions& options, const std::string& prompt,
                      ModalCompletionCallback cb,
                      WillShowModalCallback will_show = WillShowModalCallback());

  // Begins a modal question with the given prompt. The normal prompt will be hidden and replaced
  // with the given one. The callback (see definition above for implementation requirements) will be
  // called when the user presses enter. This callback should call EndModal() if the input is
  // accepted.
  //
  // There can be multiple callbacks happening at the same time. If there is a current modal input
  // active at the time of this call, the new one will be added to a queue and will be shown when
  // when the modal prompts before it have been completed.
  //
  // The "will show" callback may be called from within this function (see its definition above).
  void BeginModal(const std::string& prompt, ModalCompletionCallback cb,
                  WillShowModalCallback will_show = WillShowModalCallback());

  // Closes the current modal entry. If there is another modal prompt in the queue, it will be
  // shown. If there is none, the normal prompt will be shown again.
  //
  // Normally this will be called from within the completion callback of BeginModal() when the
  // input is accepted.
  void EndModal();

 private:
  // Called when there is a modal dialog to show at the front of modal_callbacks_.
  //
  // The normal input should be hidden before this call.
  void ShowNextModal();

  std::unique_ptr<LineInput> MakeAndSetupLineInput(AcceptCallback accept_cb,
                                                   const std::string& prompt);

  // Guaranteed non-null.
  Factory factory_;

  std::unique_ptr<LineInput> normal_input_;
  std::unique_ptr<LineInput> modal_input_;

  // Old modal input that should be deleted in the next call to OnInput(). This allows us to avoid
  // deleting it from withinn its own call stack (normally EndModal() is called from within its
  // accept callback).
  std::unique_ptr<LineInput> to_delete_;

  LineInput* current_input_ = nullptr;  // Points to either the normal or modal input.

  int max_cols_ = 0;

  bool hidden_ = true;

  EofCallback eof_callback_;

  // Will be nonempty when a modal question is being asked. front() is the current callback, with
  // later requests going toward the back().
  struct ModalRecord {
    std::string prompt;
    ModalCompletionCallback complete;
    WillShowModalCallback will_show;
  };
  std::deque<ModalRecord> modal_callbacks_;
};

}  // namespace line_input

#endif  // SRC_LIB_LINE_INPUT_MODAL_LINE_INPUT_H_