// Copyright (c) Microsoft Corporation.
// Licensed under the MIT license.

#include "precomp.h"
#include "readDataCooked.hpp"
#include "dbcs.h"
#include "stream.h"
#include "misc.h"
#include "_stream.h"
#include "inputBuffer.hpp"
#include "cmdline.h"
#include "../types/inc/GlyphWidth.hpp"
#include "../types/inc/convert.hpp"

#include "..\interactivity\inc\ServiceLocator.hpp"

#define LINE_INPUT_BUFFER_SIZE (256 * sizeof(WCHAR))

// Routine Description:
// - Constructs cooked read data class to hold context across key presses while a user is modifying their 'input line'.
// Arguments:
// - pInputBuffer - Buffer that data will be read from.
// - pInputReadHandleData - Context stored across calls from the same input handle to return partial data appropriately.
// - screenInfo - Output buffer that will be used for 'echoing' the line back to the user so they can see/manipulate it
// - BufferSize -
// - BytesRead -
// - CurrentPosition -
// - BufPtr -
// - BackupLimit -
// - UserBufferSize - The byte count of the buffer presented by the client
// - UserBuffer - The buffer that was presented by the client for filling with input data on read conclusion/return from server/host.
// - OriginalCursorPosition -
// - NumberOfVisibleChars
// - CtrlWakeupMask - Special client parameter to interrupt editing, end the wait, and return control to the client application
// - CommandHistory -
// - Echo -
// - InsertMode -
// - Processed -
// - Line -
// - pTempHandle - A handle to the output buffer to prevent it from being destroyed while we're using it to present 'edit line' text.
// - initialData - any text data that should be prepopulated into the buffer
// Return Value:
// - THROW: Throws E_INVALIDARG for invalid pointers.
COOKED_READ_DATA::COOKED_READ_DATA(_In_ InputBuffer* const pInputBuffer,
 _In_ INPUT_READ_HANDLE_DATA* const pInputReadHandleData,
 SCREEN_INFORMATION& screenInfo,
 _In_ size_t UserBufferSize,
 _In_ PWCHAR UserBuffer,
 _In_ ULONG CtrlWakeupMask,
 _In_ CommandHistory* CommandHistory,
 const std::wstring_view exeName,
 const std::string_view initialData
) :
 ReadData(pInputBuffer, pInputReadHandleData),
 _screenInfo{ screenInfo },
 _bytesRead{ 0 },
 _currentPosition{ 0 },
 _userBufferSize{ UserBufferSize },
 _userBuffer{ UserBuffer },
 _tempHandle{ nullptr },
 _exeName{ exeName },
 _pdwNumBytes{ nullptr },

 _commandHistory{ CommandHistory },
 _controlKeyState{ 0 },
 _ctrlWakeupMask{ CtrlWakeupMask },
 _visibleCharCount{ 0 },
 _originalCursorPosition{ -1, -1 },
 _beforeDialogCursorPosition{ 0, 0 },

 _echoInput{ WI_IsFlagSet(pInputBuffer->InputMode, ENABLE_ECHO_INPUT) },
 _lineInput{ WI_IsFlagSet(pInputBuffer->InputMode, ENABLE_LINE_INPUT) },
 _processedInput{ WI_IsFlagSet(pInputBuffer->InputMode, ENABLE_PROCESSED_INPUT) },
 _insertMode{ ServiceLocator::LocateGlobals().getConsoleInformation().GetInsertMode() },
 _unicode{ false }
{
#ifndef UNIT_TESTING
 THROW_IF_FAILED(screenInfo.GetMainBuffer().AllocateIoHandle(ConsoleHandleData::HandleType::Output,
 GENERIC_WRITE,
 FILE_SHARE_READ | FILE_SHARE_WRITE,
 _tempHandle));
#endif

 // to emulate OS/2 KbdStringIn, we read into our own big buffer
 // (256 bytes) until the user types enter. then return as many
 // chars as will fit in the user's buffer.
 _bufferSize = std::max(UserBufferSize, LINE_INPUT_BUFFER_SIZE);
 _buffer = std::make_unique<byte[]>(_bufferSize);
 _backupLimit = reinterpret_cast<wchar_t*>(_buffer.get());
 _bufPtr = reinterpret_cast<wchar_t*>(_buffer.get());

 // Initialize the user's buffer to spaces. This is done so that
 // moving in the buffer via cursor doesn't do strange things.
 std::fill_n(_bufPtr, _bufferSize / sizeof(wchar_t), UNICODE_SPACE);

 if (!initialData.empty())
 {
 memcpy_s(_bufPtr, _bufferSize, initialData.data(), initialData.size());

 _bytesRead += initialData.size();

 const size_t cchInitialData = initialData.size() / sizeof(wchar_t);
 VisibleCharCount() = cchInitialData;
 _bufPtr += cchInitialData;
 _currentPosition = cchInitialData;

 OriginalCursorPosition() = screenInfo.GetTextBuffer().GetCursor().GetPosition();
 OriginalCursorPosition().X -= (SHORT)_currentPosition;

 const SHORT sScreenBufferSizeX = screenInfo.GetBufferSize().Width();
 while (OriginalCursorPosition().X < 0)
 {
 OriginalCursorPosition().X += sScreenBufferSizeX;
 OriginalCursorPosition().Y -= 1;
 }
 }

 // TODO MSFT:11285829 find a better way to manage the lifetime of this object in relation to gci
}

// Routine Description:
// - Destructs a read data class.
// - Decrements count of readers waiting on the given handle.
COOKED_READ_DATA::~COOKED_READ_DATA()
{
 CommandLine::Instance().EndAllPopups();
}

gsl::span<wchar_t> COOKED_READ_DATA::SpanWholeBuffer()
{
 return gsl::make_span(_backupLimit, (_bufferSize / sizeof(wchar_t)));
}

gsl::span<wchar_t> COOKED_READ_DATA::SpanAtPointer()
{
 auto wholeSpan = SpanWholeBuffer();
 return wholeSpan.subspan(_bufPtr - _backupLimit);
}

bool COOKED_READ_DATA::HasHistory() const noexcept
{
 return _commandHistory != nullptr;
}

CommandHistory& COOKED_READ_DATA::History() noexcept
{
 return *_commandHistory;
}

const size_t& COOKED_READ_DATA::VisibleCharCount() const noexcept
{
 return _visibleCharCount;
}

size_t& COOKED_READ_DATA::VisibleCharCount() noexcept
{
 return _visibleCharCount;
}

SCREEN_INFORMATION& COOKED_READ_DATA::ScreenInfo() noexcept
{
 return _screenInfo;
}

const COORD& COOKED_READ_DATA::OriginalCursorPosition() const noexcept
{
 return _originalCursorPosition;
}

COORD& COOKED_READ_DATA::OriginalCursorPosition() noexcept
{
 return _originalCursorPosition;
}

COORD& COOKED_READ_DATA::BeforeDialogCursorPosition() noexcept
{
 return _beforeDialogCursorPosition;
}

bool COOKED_READ_DATA::IsEchoInput() const noexcept
{
 return _echoInput;
}

bool COOKED_READ_DATA::IsInsertMode() const noexcept
{
 return _insertMode;
}

void COOKED_READ_DATA::SetInsertMode(const bool mode) noexcept
{
 _insertMode = mode;
}

bool COOKED_READ_DATA::IsUnicode() const noexcept
{
 return _unicode;
}

// Routine Description:
// - gets the size of the user buffer
// Return Value:
// - the size of the user buffer in bytes
size_t COOKED_READ_DATA::UserBufferSize() const noexcept
{
 return _userBufferSize;
}

// Routine Description:
// - gets a pointer to the beginning of the prompt storage
// Return Value:
// - pointer to the first char in the internal prompt storage array
wchar_t* COOKED_READ_DATA::BufferStartPtr() noexcept
{
 return _backupLimit;
}

// Routine Description:
// - gets a pointer to where the next char will be inserted into the prompt storage
// Return Value:
// - pointer to the current insertion point of the prompt storage array
wchar_t* COOKED_READ_DATA::BufferCurrentPtr() noexcept
{
 return _bufPtr;
}

// Routine Description:
// - Set the location of the next char insert into the prompt storage to be at
// ptr. ptr must point into a valid portion of the internal prompt storage array
// Arguments:
// - ptr - the new char insertion location
void COOKED_READ_DATA::SetBufferCurrentPtr(wchar_t* ptr) noexcept
{
 _bufPtr = ptr;
}

// Routine Description:
// - gets the number of bytes read so far into the prompt buffer
// Return Value:
// - the number of bytes read
const size_t& COOKED_READ_DATA::BytesRead() const noexcept
{
 return _bytesRead;
}

// Routine Description:
// - gets the number of bytes read so far into the prompt buffer
// Return Value:
// - the number of bytes read
size_t& COOKED_READ_DATA::BytesRead() noexcept
{
 return _bytesRead;
}

// Routine Description:
// - gets the index for the current insertion point of the prompt
// Return Value:
// - the index of the current insertion point
const size_t& COOKED_READ_DATA::InsertionPoint() const noexcept
{
 return _currentPosition;
}

// Routine Description:
// - gets the index for the current insertion point of the prompt
// Return Value:
// - the index of the current insertion point
size_t& COOKED_READ_DATA::InsertionPoint() noexcept
{
 return _currentPosition;
}

// Routine Description:
// - sets the number of bytes that will be reported when this read block completes its read
// Arguments:
// - count - the number of bytes to report
void COOKED_READ_DATA::SetReportedByteCount(const size_t count) noexcept
{
 FAIL_FAST_IF_NULL(_pdwNumBytes);
 *_pdwNumBytes = count;
}

// Routine Description:
// - resets the prompt to be as if it was erased
void COOKED_READ_DATA::Erase() noexcept
{
 _bufPtr = _backupLimit;
 _bytesRead = 0;
 _currentPosition = 0;
 _visibleCharCount = 0;

}

// Routine Description:
// - This routine is called to complete a cooked read that blocked in ReadInputBuffer.
// - The context of the read was saved in the CookedReadData structure.
// - This routine is called when events have been written to the input buffer.
// - It is called in the context of the writing thread.
// - It may be called more than once.
// Arguments:
// - TerminationReason - if this routine is called because a ctrl-c or ctrl-break was seen, this argument
// contains CtrlC or CtrlBreak. If the owning thread is exiting, it will have ThreadDying. Otherwise 0.
// - fIsUnicode - Whether to convert the final data to A (using Console Input CP) at the end or treat everything as Unicode (UCS-2)
// - pReplyStatus - The status code to return to the client application that originally called the API (before it was queued to wait)
// - pNumBytes - The number of bytes of data that the server/driver will need to transmit back to the client process
// - pControlKeyState - For certain types of reads, this specifies which modifier keys were held.
// - pOutputData - not used
// Return Value:
// - true if the wait is done and result buffer/status code can be sent back to the client.
// - false if we need to continue to wait until more data is available.
bool COOKED_READ_DATA::Notify(const WaitTerminationReason TerminationReason,
 const bool fIsUnicode,
 _Out_ NTSTATUS* const pReplyStatus,
 _Out_ size_t* const pNumBytes,
 _Out_ DWORD* const pControlKeyState,
 _Out_ void* const /*pOutputData*/)
{
 CONSOLE_INFORMATION& gci = ServiceLocator::LocateGlobals().getConsoleInformation();

 // this routine should be called by a thread owning the same
 // lock on the same console as we're reading from.
 FAIL_FAST_IF(!gci.IsConsoleLocked());

 *pNumBytes = 0;
 *pControlKeyState = 0;

 *pReplyStatus = STATUS_SUCCESS;

 FAIL_FAST_IF(_pInputReadHandleData->IsInputPending());

 // this routine should be called by a thread owning the same lock on the same console as we're reading from.
 FAIL_FAST_IF(_pInputReadHandleData->GetReadCount() == 0);

 // if ctrl-c or ctrl-break was seen, terminate read.
 if (WI_IsAnyFlagSet(TerminationReason, (WaitTerminationReason::CtrlC | WaitTerminationReason::CtrlBreak)))
 {
 *pReplyStatus = STATUS_ALERTED;
 gci.SetCookedReadData(nullptr);
 return true;
 }

 // See if we were called because the thread that owns this wait block is exiting.
 if (WI_IsFlagSet(TerminationReason, WaitTerminationReason::ThreadDying))
 {
 *pReplyStatus = STATUS_THREAD_IS_TERMINATING;
 gci.SetCookedReadData(nullptr);
 return true;
 }

 // We must see if we were woken up because the handle is being closed. If
 // so, we decrement the read count. If it goes to zero, we wake up the
 // close thread. Otherwise, we wake up any other thread waiting for data.

 if (WI_IsFlagSet(TerminationReason, WaitTerminationReason::HandleClosing))
 {
 *pReplyStatus = STATUS_ALERTED;
 gci.SetCookedReadData(nullptr);
 return true;
 }

 // If we get to here, this routine was called either by the input thread
 // or a write routine. Both of these callers grab the current console
 // lock.

 // MSFT:13994975 This is REALLY weird.
 // When we're doing cooked reading for popups, we come through this method
 // twice. Once when we press F7 to bring up the popup, then again when we
 // press enter to input the selected command.
 // The first time, there is no popup, and we go to CookedRead. We pass into
 // CookedRead `pNumBytes`, which is passed to us as the address of the
 // stack variable dwNumBytes, in ConsoleWaitBlock::Notify.
 // CookedRead sets this->_pdwNumBytes to that value, and starts the popup,
 // which returns all the way up, and pops the ConsoleWaitBlock::Notify
 // stack frame containing the address we're pointing at.
 // Then on the second time through this function, we hit this if block,
 // because there is a popup to get input from.
 // However, pNumBytes is now the address of a different stack frame, and not
 // necessarily the same as before (presumably not at all). The
 // Callback would try and write the number of bytes read to the
 // value in _pdwNumBytes, and then we'd return up to ConsoleWaitBlock::Notify,
 // who's dwNumBytes had nothing in it.
 // To fix this, when we hit this with a popup, we're going to make sure to
 // refresh the value of _pdwNumBytes to the current address we want to put
 // the out value into.
 // It's still really weird, but limits the potential fallout of changing a
 // piece of old spaghetti code.
 if (_commandHistory)
 {
 if (CommandLine::Instance().HasPopup())
 {
 // (see above comment, MSFT:13994975)
 // Make sure that the popup writes the dwNumBytes to the right place
 if (pNumBytes)
 {
 _pdwNumBytes = pNumBytes;
 }

 auto& popup = CommandLine::Instance().GetPopup();
 *pReplyStatus = popup.Process(*this);
 if (*pReplyStatus == CONSOLE_STATUS_READ_COMPLETE ||
 (*pReplyStatus != CONSOLE_STATUS_WAIT && *pReplyStatus != CONSOLE_STATUS_WAIT_NO_BLOCK))
 {
 *pReplyStatus = S_OK;
 gci.SetCookedReadData(nullptr);
 return true;
 }
 return false;
 }
 }

 *pReplyStatus = Read(fIsUnicode, *pNumBytes, *pControlKeyState);
 if (*pReplyStatus != CONSOLE_STATUS_WAIT)
 {
 gci.SetCookedReadData(nullptr);
 return true;
 }
 else
 {
 return false;
 }
}

bool COOKED_READ_DATA::AtEol() const noexcept
{
 return _bytesRead == (_currentPosition * 2);
}

// Routine Description:
// - Method that actually retrieves a character/input record from the buffer (key press form)
// and determines the next action based on the various possible cooked read modes.
// - Mode options include the F-keys popup menus, keyboard manipulation of the edit line, etc.
// - This method also does the actual copying of the final manipulated data into the return buffer.
// Arguments:
// - isUnicode - Treat as UCS-2 unicode or use Input CP to convert when done.
// - numBytes - On in, the number of bytes available in the client
// buffer. On out, the number of bytes consumed in the client buffer.
// - controlKeyState - For some types of reads, this is the modifier key state with the last button press.
[[nodiscard]]
HRESULT COOKED_READ_DATA::Read(const bool isUnicode,
 size_t& numBytes,
 ULONG& controlKeyState) noexcept
{
 controlKeyState = 0;

 NTSTATUS Status = _readCharInputLoop(isUnicode, numBytes);

 // if the read was completed (status != wait), free the cooked read
 // data. also, close the temporary output handle that was opened to
 // echo the characters read.
 if (Status != CONSOLE_STATUS_WAIT)
 {
 Status = _handlePostCharInputLoop(isUnicode, numBytes, controlKeyState);
 }

 return Status;
}

void COOKED_READ_DATA::ProcessAliases(DWORD& lineCount)
{
 Alias::s_MatchAndCopyAliasLegacy(_backupLimit,
 _bytesRead,
 _backupLimit,
 _bufferSize,
 _bytesRead,
 _exeName,
 lineCount);
}

// Routine Description:
// - This method handles the various actions that occur on the edit line like pressing keys left/right/up/down, paging, and
// the final ENTER key press that will end the wait and finally return the data.
// Arguments:
// - pCookedReadData - Pointer to cooked read data information (edit line, client buffer, etc.)
// - wch - The most recently pressed/retrieved character from the input buffer (keystroke)
// - keyState - Modifier keys/state information with the pressed key/character
// - status - The return code to pass to the client
// Return Value:
// - true if read is completed. false if we need to keep waiting and be called again with the user's next keystroke.
bool COOKED_READ_DATA::ProcessInput(const wchar_t wchOrig,
 const DWORD keyState,
 NTSTATUS& status)
{
 const CONSOLE_INFORMATION& gci = ServiceLocator::LocateGlobals().getConsoleInformation();
 size_t NumSpaces = 0;
 SHORT ScrollY = 0;
 size_t NumToWrite;
 WCHAR wch = wchOrig;
 bool fStartFromDelim;

 status = STATUS_SUCCESS;
 if (_bytesRead >= (_bufferSize - (2 * sizeof(WCHAR))) && wch != UNICODE_CARRIAGERETURN && wch != UNICODE_BACKSPACE)
 {
 return false;
 }

 if (_ctrlWakeupMask != 0 && wch < L' ' && (_ctrlWakeupMask & (1 << wch)))
 {
 *_bufPtr = wch;
 _bytesRead += sizeof(WCHAR);
 _bufPtr += 1;
 _currentPosition += 1;
 _controlKeyState = keyState;
 return true;
 }

 if (wch == EXTKEY_ERASE_PREV_WORD)
 {
 wch = UNICODE_BACKSPACE;
 }

 if (AtEol())
 {
 // If at end of line, processing is relatively simple. Just store the character and write it to the screen.
 if (wch == UNICODE_BACKSPACE2)
 {
 wch = UNICODE_BACKSPACE;
 }

 if (wch != UNICODE_BACKSPACE || _bufPtr != _backupLimit)
 {
 fStartFromDelim = IsWordDelim(_bufPtr[-1]);

 bool loop = true;
 while (loop)
 {
 loop = false;
 if (_echoInput)
 {
 NumToWrite = sizeof(WCHAR);
 status = WriteCharsLegacy(_screenInfo,
 _backupLimit,
 _bufPtr,
 &wch,
 &NumToWrite,
 &NumSpaces,
 _originalCursorPosition.X,
 WC_DESTRUCTIVE_BACKSPACE | WC_KEEP_CURSOR_VISIBLE | WC_ECHO,
 &ScrollY);
 if (NT_SUCCESS(status))
 {
 _originalCursorPosition.Y += ScrollY;
 }
 else
 {
 RIPMSG1(RIP_WARNING, "WriteCharsLegacy failed %x", status);
 }
 }

 _visibleCharCount += NumSpaces;
 if (wch == UNICODE_BACKSPACE && _processedInput)
 {
 _bytesRead -= sizeof(WCHAR);
 #pragma prefast(suppress:__WARNING_POTENTIAL_BUFFER_OVERFLOW_HIGH_PRIORITY, "This access is fine")
 *_bufPtr = (WCHAR)' ';
 _bufPtr -= 1;
 _currentPosition -= 1;

 // Repeat until it hits the word boundary
 if (wchOrig == EXTKEY_ERASE_PREV_WORD &&
 _bufPtr != _backupLimit &&
 fStartFromDelim ^ !IsWordDelim(_bufPtr[-1]))
 {
 loop = true;
 }
 }
 else
 {
 *_bufPtr = wch;
 _bytesRead += sizeof(WCHAR);
 _bufPtr += 1;
 _currentPosition += 1;
 }
 }
 }
 }
 else
 {
 bool CallWrite = true;
 const SHORT sScreenBufferSizeX = _screenInfo.GetBufferSize().Width();

 // processing in the middle of the line is more complex:

 // calculate new cursor position
 // store new char
 // clear the current command line from the screen
 // write the new command line to the screen
 // update the cursor position

 if (wch == UNICODE_BACKSPACE && _processedInput)
 {
 // for backspace, use writechars to calculate the new cursor position.
 // this call also sets the cursor to the right position for the
 // second call to writechars.

 if (_bufPtr != _backupLimit)
 {

 fStartFromDelim = IsWordDelim(_bufPtr[-1]);

 bool loop = true;
 while (loop)
 {
 loop = false;
 // we call writechar here so that cursor position gets updated
 // correctly. we also call it later if we're not at eol so
 // that the remainder of the string can be updated correctly.

 if (_echoInput)
 {
 NumToWrite = sizeof(WCHAR);
 status = WriteCharsLegacy(_screenInfo,
 _backupLimit,
 _bufPtr,
 &wch,
 &NumToWrite,
 nullptr,
 _originalCursorPosition.X,
 WC_DESTRUCTIVE_BACKSPACE | WC_KEEP_CURSOR_VISIBLE | WC_ECHO,
 nullptr);
 if (!NT_SUCCESS(status))
 {
 RIPMSG1(RIP_WARNING, "WriteCharsLegacy failed %x", status);
 }
 }
 _bytesRead -= sizeof(WCHAR);
 _bufPtr -= 1;
 _currentPosition -= 1;
 memmove(_bufPtr,
 _bufPtr + 1,
 _bytesRead - (_currentPosition * sizeof(WCHAR)));
 {
 PWCHAR buf = (PWCHAR)((PBYTE)_backupLimit + _bytesRead);
 *buf = (WCHAR)' ';
 }
 NumSpaces = 0;

 // Repeat until it hits the word boundary
 if (wchOrig == EXTKEY_ERASE_PREV_WORD &&
 _bufPtr != _backupLimit &&
 fStartFromDelim ^ !IsWordDelim(_bufPtr[-1]))
 {
 loop = true;
 }
 }
 }
 else
 {
 CallWrite = false;
 }
 }
 else
 {
 // store the char
 if (wch == UNICODE_CARRIAGERETURN)
 {
 _bufPtr = (PWCHAR)((PBYTE)_backupLimit + _bytesRead);
 *_bufPtr = wch;
 _bufPtr += 1;
 _bytesRead += sizeof(WCHAR);
 _currentPosition += 1;
 }
 else
 {
 bool fBisect = false;

 if (_echoInput)
 {
 if (CheckBisectProcessW(_screenInfo,
 _backupLimit,
 _currentPosition + 1,
 sScreenBufferSizeX - _originalCursorPosition.X,
 _originalCursorPosition.X,
 TRUE))
 {
 fBisect = true;
 }
 }

 if (_insertMode)
 {
 memmove(_bufPtr + 1,
 _bufPtr,
 _bytesRead - (_currentPosition * sizeof(WCHAR)));
 _bytesRead += sizeof(WCHAR);
 }
 *_bufPtr = wch;
 _bufPtr += 1;
 _currentPosition += 1;

 // calculate new cursor position
 if (_echoInput)
 {
 NumSpaces = RetrieveNumberOfSpaces(_originalCursorPosition.X,
 _backupLimit,
 _currentPosition - 1);
 if (NumSpaces > 0 && fBisect)
 NumSpaces--;
 }
 }
 }

 if (_echoInput && CallWrite)
 {
 COORD CursorPosition;

 // save cursor position
 CursorPosition = _screenInfo.GetTextBuffer().GetCursor().GetPosition();
 CursorPosition.X = (SHORT)(CursorPosition.X + NumSpaces);

 // clear the current command line from the screen
#pragma prefast(suppress:__WARNING_BUFFER_OVERFLOW, "Not sure why prefast doesn't like this call.")
 DeleteCommandLine(*this, FALSE);

 // write the new command line to the screen
 NumToWrite = _bytesRead;

 DWORD dwFlags = WC_DESTRUCTIVE_BACKSPACE | WC_ECHO;
 if (wch == UNICODE_CARRIAGERETURN)
 {
 dwFlags |= WC_KEEP_CURSOR_VISIBLE;
 }
 status = WriteCharsLegacy(_screenInfo,
 _backupLimit,
 _backupLimit,
 _backupLimit,
 &NumToWrite,
 &_visibleCharCount,
 _originalCursorPosition.X,
 dwFlags,
 &ScrollY);
 if (!NT_SUCCESS(status))
 {
 RIPMSG1(RIP_WARNING, "WriteCharsLegacy failed 0x%x", status);
 _bytesRead = 0;
 return true;
 }

 // update cursor position
 if (wch != UNICODE_CARRIAGERETURN)
 {
 if (CheckBisectProcessW(_screenInfo,
 _backupLimit,
 _currentPosition + 1,
 sScreenBufferSizeX - _originalCursorPosition.X,
 _originalCursorPosition.X, TRUE))
 {
 if (CursorPosition.X == (sScreenBufferSizeX - 1))
 {
 CursorPosition.X++;
 }
 }

 // adjust cursor position for WriteChars
 _originalCursorPosition.Y += ScrollY;
 CursorPosition.Y += ScrollY;
 status = AdjustCursorPosition(_screenInfo, CursorPosition, TRUE, nullptr);
 if (!NT_SUCCESS(status))
 {
 _bytesRead = 0;
 return true;
 }
 }
 }
 }

 // in cooked mode, enter (carriage return) is converted to
 // carriage return linefeed (0xda). carriage return is always
 // stored at the end of the buffer.
 if (wch == UNICODE_CARRIAGERETURN)
 {
 if (_processedInput)
 {
 if (_bytesRead < _bufferSize)
 {
 *_bufPtr = UNICODE_LINEFEED;
 if (_echoInput)
 {
 NumToWrite = sizeof(WCHAR);
 status = WriteCharsLegacy(_screenInfo,
 _backupLimit,
 _bufPtr,
 _bufPtr,
 &NumToWrite,
 nullptr,
 _originalCursorPosition.X,
 WC_DESTRUCTIVE_BACKSPACE | WC_KEEP_CURSOR_VISIBLE | WC_ECHO,
 nullptr);
 if (!NT_SUCCESS(status))
 {
 RIPMSG1(RIP_WARNING, "WriteCharsLegacy failed 0x%x", status);
 }
 }
 _bytesRead += sizeof(WCHAR);
 _bufPtr++;
 _currentPosition += 1;
 }
 }
 // reset the cursor back to 25% if necessary
 if (_lineInput)
 {
 if (_insertMode != gci.GetInsertMode())
 {
 // Make cursor small.
 LOG_IF_FAILED(CommandLine::Instance().ProcessCommandLine(*this, VK_INSERT, 0));
 }

 status = STATUS_SUCCESS;
 return true;
 }
 }

 return false;
}

// Routine Description:
// - Writes string to current position in prompt line. can overwrite text to the right of the cursor.
// Arguments:
// - wstr - the string to write
// Return Value:
// - The number of chars written
size_t COOKED_READ_DATA::Write(const std::wstring_view wstr)
{
 auto end = wstr.end();
 const size_t charsRemaining = (_bufferSize / sizeof(wchar_t)) - (_bufPtr - _backupLimit);
 if (wstr.size() > charsRemaining)
 {
 end = std::next(wstr.begin(), charsRemaining);
 }

 std::copy(wstr.begin(), end, _bufPtr);
 const size_t charsInserted = end - wstr.begin();
 size_t bytesInserted = charsInserted * sizeof(wchar_t);
 _currentPosition += charsInserted;
 _bytesRead += bytesInserted;


 if (IsEchoInput())
 {
 size_t NumSpaces = 0;
 SHORT ScrollY = 0;

 FAIL_FAST_IF_NTSTATUS_FAILED(WriteCharsLegacy(ScreenInfo(),
 _backupLimit,
 _bufPtr,
 _bufPtr,
 &bytesInserted,
 &NumSpaces,
 OriginalCursorPosition().X,
 WC_DESTRUCTIVE_BACKSPACE | WC_KEEP_CURSOR_VISIBLE | WC_ECHO,
 &ScrollY));
 OriginalCursorPosition().Y += ScrollY;
 VisibleCharCount() += NumSpaces;
 }
 _bufPtr += charsInserted;

 return charsInserted;
}

// Routine Description:
// - saves data in the prompt buffer to the outgoing user buffer
// Arguments:
// - cch - the number of chars to write to the user buffer
// Return Value:
// - the number of bytes written to the user buffer
size_t COOKED_READ_DATA::SavePromptToUserBuffer(const size_t cch)
{
 size_t bytesToWrite = 0;
 const HRESULT hr = SizeTMult(cch, sizeof(wchar_t), &bytesToWrite);
 if (FAILED(hr))
 {
 return 0;
 }

 memmove(_userBuffer, _backupLimit, bytesToWrite);

 if (!IsUnicode())
 {
 try
 {
 const auto& gci = ServiceLocator::LocateGlobals().getConsoleInformation();
 const std::wstring wstr = ConvertToW(gci.CP, { reinterpret_cast<char*>(_userBuffer), cch });
 const size_t copyAmount = std::min(wstr.size(), _userBufferSize / sizeof(wchar_t));
 std::copy_n(wstr.begin(), copyAmount, _userBuffer);
 return copyAmount * sizeof(wchar_t);
 }
 CATCH_LOG();
 }
 return bytesToWrite;
}

// Routine Description:
// - saves data in the prompt buffer as pending input
// Arguments:
// - index - the index of what wchar to start the saving
// - multiline - whether the pending input should be saved as multiline or not
void COOKED_READ_DATA::SavePendingInput(const size_t index, const bool multiline)
{
 INPUT_READ_HANDLE_DATA& inputReadHandleData = *GetInputReadHandleData();
 const std::wstring_view pending{ _backupLimit + index,
 BytesRead() / sizeof(wchar_t) - index};
 if (multiline)
 {
 inputReadHandleData.SaveMultilinePendingInput(pending);
 }
 else
 {
 inputReadHandleData.SavePendingInput(pending);
 }
}

// Routine Description:
// - saves data in the prompt buffer as pending input
// Arguments:
// - isUnicode - Treat as UCS-2 unicode or use Input CP to convert when done.
// - numBytes - On in, the number of bytes available in the client
// buffer. On out, the number of bytes consumed in the client buffer.
// Return Value:
// - Status code that indicates success, wait, etc.
[[nodiscard]]
NTSTATUS COOKED_READ_DATA::_readCharInputLoop(const bool isUnicode, size_t& numBytes) noexcept
{
 NTSTATUS Status = STATUS_SUCCESS;

 while (_bytesRead < _bufferSize)
 {
 wchar_t wch = UNICODE_NULL;
 bool commandLineEditingKeys = false;
 DWORD keyState = 0;

 // This call to GetChar may block.
 Status = GetChar(_pInputBuffer,
 &wch,
 true,
 &commandLineEditingKeys,
 nullptr,
 &keyState);
 if (!NT_SUCCESS(Status))
 {
 if (Status != CONSOLE_STATUS_WAIT)
 {
 _bytesRead = 0;
 }
 break;
 }

 // we should probably set these up in GetChars, but we set them
 // up here because the debugger is multi-threaded and calls
 // read before outputting the prompt.

 if (_originalCursorPosition.X == -1)
 {
 _originalCursorPosition = _screenInfo.GetTextBuffer().GetCursor().GetPosition();
 }

 if (commandLineEditingKeys)
 {
 // TODO: this is super weird for command line popups only
 _unicode = isUnicode;

 _pdwNumBytes = &numBytes;

 Status = CommandLine::Instance().ProcessCommandLine(*this, wch, keyState);
 if (Status == CONSOLE_STATUS_READ_COMPLETE || Status == CONSOLE_STATUS_WAIT)
 {
 break;
 }
 if (!NT_SUCCESS(Status))
 {
 if (Status == CONSOLE_STATUS_WAIT_NO_BLOCK)
 {
 Status = CONSOLE_STATUS_WAIT;
 }
 else
 {
 _bytesRead = 0;
 }
 break;
 }
 }
 else
 {
 if (ProcessInput(wch, keyState, Status))
 {
 CONSOLE_INFORMATION& gci = ServiceLocator::LocateGlobals().getConsoleInformation();
 gci.Flags |= CONSOLE_IGNORE_NEXT_KEYUP;
 break;
 }
 }
 }
 return Status;
}

// Routine Description:
// - handles any tasks that need to be completed after the read input loop finishes
// Arguments:
// - isUnicode - Treat as UCS-2 unicode or use Input CP to convert when done.
// - numBytes - On in, the number of bytes available in the client
// buffer. On out, the number of bytes consumed in the client buffer.
// - controlKeyState - For some types of reads, this is the modifier key state with the last button press.
// Return Value:
// - Status code that indicates success, out of memory, etc.
[[nodiscard]]
NTSTATUS COOKED_READ_DATA::_handlePostCharInputLoop(const bool isUnicode, size_t& numBytes, ULONG& controlKeyState) noexcept
{
 DWORD LineCount = 1;

 if (_echoInput)
 {
 // Figure out where real string ends (at carriage return or end of buffer).
 PWCHAR StringPtr = _backupLimit;
 size_t StringLength = _bytesRead;
 bool FoundCR = false;
 for (size_t i = 0; i < (_bytesRead / sizeof(WCHAR)); i++)
 {
 if (*StringPtr++ == UNICODE_CARRIAGERETURN)
 {
 StringLength = i * sizeof(WCHAR);
 FoundCR = true;
 break;
 }
 }

 if (FoundCR)
 {
 if (_commandHistory)
 {
 // add to command line recall list if we have a history list.
 CONSOLE_INFORMATION& gci = ServiceLocator::LocateGlobals().getConsoleInformation();
 LOG_IF_FAILED(_commandHistory->Add({ _backupLimit, StringLength / sizeof(wchar_t) },
 WI_IsFlagSet(gci.Flags, CONSOLE_HISTORY_NODUP)));
 }

 // check for alias
 ProcessAliases(LineCount);
 }
 }

 bool fAddDbcsLead = false;
 size_t NumBytes = 0;
 // at this point, a->NumBytes contains the number of bytes in
 // the UNICODE string read. UserBufferSize contains the converted
 // size of the app's buffer.
 if (_bytesRead > _userBufferSize || LineCount > 1)
 {
 if (LineCount > 1)
 {
 PWSTR Tmp;
 if (!isUnicode)
 {
 if (_pInputBuffer->IsReadPartialByteSequenceAvailable())
 {
 fAddDbcsLead = true;
 std::unique_ptr<IInputEvent> event = GetInputBuffer()->FetchReadPartialByteSequence(false);
 const KeyEvent* const pKeyEvent = static_cast<const KeyEvent* const>(event.get());
 *_userBuffer = static_cast<char>(pKeyEvent->GetCharData());
 _userBuffer++;
 _userBufferSize -= sizeof(wchar_t);
 }

 NumBytes = 0;
 for (Tmp = _backupLimit;
 *Tmp != UNICODE_LINEFEED && _userBufferSize / sizeof(WCHAR) > NumBytes;
 Tmp++)
 {
 NumBytes += IsGlyphFullWidth(*Tmp) ? 2 : 1;
 }
 }

#pragma prefast(suppress:__WARNING_BUFFER_OVERFLOW, "LineCount > 1 means there's a UNICODE_LINEFEED")
 for (Tmp = _backupLimit; *Tmp != UNICODE_LINEFEED; Tmp++)
 {
 FAIL_FAST_IF(!(Tmp < (_backupLimit + _bytesRead)));
 }

 numBytes = (ULONG)(Tmp - _backupLimit + 1) * sizeof(*Tmp);
 }
 else
 {
 if (!isUnicode)
 {
 PWSTR Tmp;

 if (_pInputBuffer->IsReadPartialByteSequenceAvailable())
 {
 fAddDbcsLead = true;
 std::unique_ptr<IInputEvent> event = GetInputBuffer()->FetchReadPartialByteSequence(false);
 const KeyEvent* const pKeyEvent = static_cast<const KeyEvent* const>(event.get());
 *_userBuffer = static_cast<char>(pKeyEvent->GetCharData());
 _userBuffer++;
 _userBufferSize -= sizeof(wchar_t);
 }
 NumBytes = 0;
 size_t NumToWrite = _bytesRead;
 for (Tmp = _backupLimit;
 NumToWrite && _userBufferSize / sizeof(WCHAR) > NumBytes;
 Tmp++, NumToWrite -= sizeof(WCHAR))
 {
 NumBytes += IsGlyphFullWidth(*Tmp) ? 2 : 1;
 }
 }
 numBytes = _userBufferSize;
 }

 __analysis_assume(numBytes <= _userBufferSize);
 memmove(_userBuffer, _backupLimit, numBytes);

 INPUT_READ_HANDLE_DATA* const pInputReadHandleData = GetInputReadHandleData();
 const std::wstring_view pending{ _backupLimit + (numBytes / sizeof(wchar_t)), (_bytesRead - numBytes) / sizeof(wchar_t) };
 if (LineCount > 1)
 {
 pInputReadHandleData->SaveMultilinePendingInput(pending);
 }
 else
 {
 pInputReadHandleData->SavePendingInput(pending);
 }
 }
 else
 {
 if (!isUnicode)
 {
 PWSTR Tmp;

 if (_pInputBuffer->IsReadPartialByteSequenceAvailable())
 {
 fAddDbcsLead = true;
 std::unique_ptr<IInputEvent> event = GetInputBuffer()->FetchReadPartialByteSequence(false);
 const KeyEvent* const pKeyEvent = static_cast<const KeyEvent* const>(event.get());
 *_userBuffer = static_cast<char>(pKeyEvent->GetCharData());
 _userBuffer++;
 _userBufferSize -= sizeof(wchar_t);

 if (_userBufferSize == 0)
 {
 numBytes = 1;
 return STATUS_SUCCESS;
 }
 }
 NumBytes = 0;
 size_t NumToWrite = _bytesRead;
 for (Tmp = _backupLimit;
 NumToWrite && _userBufferSize / sizeof(WCHAR) > NumBytes;
 Tmp++, NumToWrite -= sizeof(WCHAR))
 {
 NumBytes += IsGlyphFullWidth(*Tmp) ? 2 : 1;
 }
 }

 numBytes = _bytesRead;

 if (numBytes > _userBufferSize)
 {
 return STATUS_BUFFER_OVERFLOW;
 }

 memmove(_userBuffer, _backupLimit, numBytes);
 }
 controlKeyState = _controlKeyState;

 if (!isUnicode)
 {
 // if ansi, translate string.
 std::unique_ptr<char[]> tempBuffer;
 try
 {
 tempBuffer = std::make_unique<char[]>(NumBytes);
 }
 catch (...)
 {
 return STATUS_NO_MEMORY;
 }

 std::unique_ptr<IInputEvent> partialEvent;
 numBytes = TranslateUnicodeToOem(_userBuffer,
 gsl::narrow<ULONG>(numBytes / sizeof(wchar_t)),
 tempBuffer.get(),
 gsl::narrow<ULONG>(NumBytes),
 partialEvent);

 if (partialEvent.get())
 {
 GetInputBuffer()->StoreReadPartialByteSequence(std::move(partialEvent));
 }


 if (numBytes > _userBufferSize)
 {
 return STATUS_BUFFER_OVERFLOW;
 }

 memmove(_userBuffer, tempBuffer.get(), numBytes);
 if (fAddDbcsLead)
 {
 numBytes++;
 }
 }
 return STATUS_SUCCESS;
}