BOOL LaunchedFromConsole(void) {
  if (!AttachConsole(ATTACH_PARENT_PROCESS)) {
    return FALSE;
  } else {
    return TRUE;
  }
}

int APIENTRY
WinMain(HINSTANCE hInstance1,
	HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    static char name0[256];
    static char *argv[256];
    int argc = 1;
    int i;

    GetModuleFileName(hInstance1, name0, 256);
    /* Allocate everything virtually - be on the safe side */
    argv[0] = strdup(name0);
    lpCmdLine = strdup(lpCmdLine);

    for (i = 0; lpCmdLine[i]; i++) {
	if (lpCmdLine[i] == ' ' || lpCmdLine[i] == '\t')
	    lpCmdLine[i] = 0;
	else if (!i || !lpCmdLine[i - 1])
	    argv[argc] = lpCmdLine + i, argc++;
    }

    /* Attach to parent console if available so output will be visible */
    if (AttachConsole(ATTACH_PARENT_PROCESS)) {
	/* make sure stdout is not already redirected before redefining */
	if (_fileno(stdout) == -1 || _get_osfhandle(fileno(stdout)) == -1)
	    freopen("CON", "w", stdout);
    }

    hInstance = hInstance1;
    return XaoS_main(argc, argv);
}

static void attach_parent_console()
{
	BOOL outRedirected, errRedirected;

	outRedirected = IsHandleRedirected(STD_OUTPUT_HANDLE);
	errRedirected = IsHandleRedirected(STD_ERROR_HANDLE);

	if (outRedirected && errRedirected) {
		/* Both standard output and error handles are redirected.
		 * There is no point in attaching to parent process console.
		 */
		return;
	}

	if (AttachConsole(ATTACH_PARENT_PROCESS) == 0) {
		/* Console attach failed. */
		return;
	}

	/* Console attach succeeded */
	if (outRedirected == FALSE) {
		freopen("CONOUT$", "w", stdout);
	}

	if (errRedirected == FALSE) {
		freopen("CONOUT$", "w", stderr);
	}
}

void attach_console()
{
   bool attached = AttachConsole(ATTACH_PARENT_PROCESS) != 0;

   // Only force attach when running a debug build
#if !defined(NDEBUG)

   if (!attached)
   {
      attached = AllocConsole() != 0;
   }

#endif

   // re-open standard file streams.
   // Note, that due to a known bug in the Windows CRT these streams cannot
   // be redirected on the command line using the > operator. This is a known
   // bug in the Windows CRT and is NOT a defect of this application!
   if (attached)
   {
      freopen("CON", "w", stdout);
      freopen("CON", "r", stdin);
      freopen("CON", "w", stderr);
   }
}

int terminal_init(void)
{
    if (AttachConsole(ATTACH_PARENT_PROCESS)) {
        // We have been started by something with a console window.
        // Redirect output streams to that console's low-level handles,
        // so we can actually use WriteConsole later on.

        int hConHandle;

        hConHandle = _open_osfhandle((intptr_t)hSTDOUT, _O_TEXT);
        *stdout = *_fdopen(hConHandle, "w");
        setvbuf(stdout, NULL, _IONBF, 0);

        hConHandle = _open_osfhandle((intptr_t)hSTDERR, _O_TEXT);
        *stderr = *_fdopen(hConHandle, "w");
        setvbuf(stderr, NULL, _IONBF, 0);
    }

    CONSOLE_SCREEN_BUFFER_INFO cinfo;
    DWORD cmode = 0;
    GetConsoleMode(hSTDOUT, &cmode);
    cmode |= (ENABLE_PROCESSED_OUTPUT | ENABLE_WRAP_AT_EOL_OUTPUT);
    SetConsoleMode(hSTDOUT, cmode);
    SetConsoleMode(hSTDERR, cmode);
    GetConsoleScreenBufferInfo(hSTDOUT, &cinfo);
    stdoutAttrs = cinfo.wAttributes;
    return 0;
}

int WINAPI wWinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpstrCmdLine, int nCmdShow )
{
	AttachConsole(ATTACH_PARENT_PROCESS);

	int argc;
	wchar_t *const *argv=CommandLineToArgvW(lpstrCmdLine,&argc);
	if (!argv) return 1;

	if (argc==3)
	{
		if (_wcsicmp(argv[0],L"extract")==0)
		{
			// extract DLL, CSV
			// extracts the string table, the dialog text, and the L10N text from a DLL and stores it in a CSV
			return ExtractStrings(argv[1],argv[2]);
		}

		if (_wcsicmp(argv[0],L"import")==0)
		{
			// import DLL, CSV
			// replaces the string table in the DLL with the text from the CSV
			return ImportStrings(argv[1],argv[2]);
		}
	}
	return 0;
}

bool SDLAppAttachToConsole() {
    if(using_parent_console)      return true;
    if(gSDLAppConsoleWindow != 0) return false;

    // if TERM is set to msys, try and attach to console
    // could possibly add other supported TERMs here if there are any

    char* term = getenv("TERM");
    if(!term || strcmp(term, "msys")!=0) return false;

    if(AttachConsole(ATTACH_PARENT_PROCESS)) {

        // send stdout to console unless already redirected
        if (_fileno(stdout) == -1 || _get_osfhandle(fileno(stdout)) == -1) {
            freopen("conout$","w", stdout);
        }

        // send stderr to console unless already redirected
        if (_fileno(stderr) == -1 || _get_osfhandle(fileno(stderr)) == -1) {
            freopen("conout$","w", stderr);
        }

        using_parent_console = true;
    }

    return using_parent_console;
}

int AppMain(int argc, char **argv)
{
    CharacterMode = RGui;
    if(strcmp(getDLLVersion(), getRVersion()) != 0) {
	MessageBox(0, "R.DLL version does not match", "Terminating",
		   MB_TASKMODAL | MB_ICONSTOP | MB_OK);
	exit(1);
    }
    cmdlineoptions(argc, argv);
    if (!setupui()) {
        MessageBox(0, "Error setting up console.  Try --vanilla option.",
                      "Terminating", MB_TASKMODAL | MB_ICONSTOP | MB_OK);
        GA_exitapp();
    }

/* C writes to stdout/stderr get set to the launching terminal (if
   there was one).  Needs XP, and works for C but not Fortran. */

    if (AttachConsole(ATTACH_PARENT_PROCESS))
    {
	freopen("CONIN$", "r", stdin);
	freopen("CONOUT$", "w", stdout);
	freopen("CONOUT$", "w", stderr);
    }

    Rf_mainloop();
    /* NOTREACHED */
    return 0;
}

void AttachToRLLog::tryConsoleConnection()
{
    if (!consoleConnected) {
        consoleConnected = false;
        RLProcID = searchForProcess(RL);
        linesRead = 0;
        if (threadFound) {
            std::cout << "AttachToRLLog::tryConsoleConnection - attaching to console" << std::endl;
            if (AttachConsole(RLProcID))
            {
                    hConsole = CreateFile(L"CONOUT$",
                        GENERIC_READ | GENERIC_WRITE,
                        0, 0, OPEN_EXISTING, 0, 0);
                    consoleConnected = true;
                    emit rocketLeagueRunning(true);
                    scanLogTimer = new QTimer(this);
                    connect(scanLogTimer, SIGNAL(timeout()), this, SLOT(readLatest()));
                    scanLogTimer->start(100);
            }
            else
            {
                std::cout << "AttachToRLLOG: connection to console failed" << std::endl;
                QTimer::singleShot(1000, Qt::CoarseTimer, this, SLOT(tryConsoleConnection()));
            }
        } else {
            QTimer::singleShot(1000, Qt::CoarseTimer, this, SLOT(tryConsoleConnection()));
        }
    }

}

void Drive::Umount(HWND)
{
	// check mounted
	CheckMounted();
//	if (GetDriveType(mnt) == DRIVE_NO_ROOT_DIR)
//		mounted = false;
	if (!mounted)
		throw truntime_error(_T("Cannot unmount a not mounted drive"));

	// unmount
	fuse_unmount(wchar_to_utf8_cstr(mnt).c_str(), NULL);

	if (subProcess) {
		// attach console to allow sending ctrl-c
		AttachConsole(subProcess->pid);

		// disable ctrl-c to not exit this process
		SetConsoleCtrlHandler(HandlerRoutine, TRUE);

		if (!GenerateConsoleCtrlEvent(CTRL_C_EVENT, subProcess->pid)
		    && !GenerateConsoleCtrlEvent(CTRL_BREAK_EVENT, subProcess->pid))
			TerminateProcess(subProcess->hProcess, 0);

		// force exit
		if (WaitForSingleObject(subProcess->hProcess, 2000) == WAIT_TIMEOUT)
			TerminateProcess(subProcess->hProcess, 0);
			
		// close the console
		FreeConsole();
		SetConsoleCtrlHandler(HandlerRoutine, FALSE);
	}
	CheckMounted();
}

bool lConsole::Initialize(void *FileHandle, void *Stream, uint32_t ScreenbufferSize)
{
    // Allocate a console if we don't have one.
    if (!strstr(GetCommandLineA(), "-nocon"))
    {
        AllocConsole();

        // Take ownership of it.
        AttachConsole(GetCurrentProcessId());

        // Set the standard streams to use the console.
        freopen("CONOUT$", "w", (FILE *)Stream);

        // Start the update thread.
        if (!UpdateThread.joinable())
        {
            UpdateThread = std::thread(&lConsole::Int_UpdateThread, this);
            UpdateThread.detach();
        }
    }

    // Fill our properties.
    ThreadSafe.lock();
    this->FileHandle = FileHandle;
    this->StreamHandle = Stream;
    this->ShouldPrintScrollback = ScreenbufferSize != 0;
    this->StartupTimestamp = GetTickCount64();
    this->LastTimestamp = this->StartupTimestamp;
    this->ScrollbackLineCount = ScreenbufferSize;
    this->ScrollbackLines = new lLine[this->ScrollbackLineCount]();
    this->ProgressbarCount = 0;
    ThreadSafe.unlock();

    return true;
}

void Log::CreateConsole(LPCSTR caption)
{
	AllocConsole();
	AttachConsole(GetCurrentProcessId());
	freopen("CON", "w", stdout); //-V530
	SetConsoleTitleA(caption);
}

bool MainThread()
{
	AllocConsole();
	AttachConsole( GetCurrentProcessId() );
	freopen( "CON", "w", stdout );

	gCVars.Initialize();
	gMenu.Initialize();

	printf("[Quake2 Engine Hook By Firehawk]\n");
	printf("ModelView: 0x%x, Viewport: 0x%x, Projection: 0x%x\n", &ModelView, &Viewport, &Projection);
	while ( !GameAPI )
		GameAPI = GameAPI_t::Get();

	while (!RenderAPI)
		RenderAPI = RenderAPI_t::Get();
	
	//Just to make sure it's hooked in the beginning
	hkGetGameAPI(GameAPI);
	hkGetRenderAPI(RenderAPI);

	g_Memory.ApplyPatches();
	printf("Memory patched!\n");

	return true;
}

		BOOL SysConsole::Open( int x, int y, int w, int h )
		{
			BOOL r = AllocConsole();

			if (!r)
				return r;
			AttachConsole(GetCurrentProcessId());
			MoveWindow(GetConsoleWindow(), x, y, w, h, true);
			m_cinbuf = std::cin.rdbuf();
			m_console_cin.open("CONIN$");
			std::cin.rdbuf(m_console_cin.rdbuf());
			m_coutbuf = std::cout.rdbuf();
			m_console_cout.open("CONOUT$");
			std::cout.rdbuf(m_console_cout.rdbuf());
			m_cerrbuf = std::cerr.rdbuf();
			m_console_cerr.open("CONOUT$");
			std::cerr.rdbuf(m_console_cerr.rdbuf());

			FILE *stream;
			freopen_s(&stream, "conin$", "r", stdin);
			freopen_s(&stream, "conout$", "w", stdout);
			freopen_s(&stream, "conout$", "w", stdout);

			return r;
		}

void VulkanBase::setupConsole(std::string title) {
	AllocConsole();
	AttachConsole(GetCurrentProcessId());
	freopen("CON", "w", stdout);
	SetConsoleTitle(TEXT(title.c_str()));
	if (enableValidation)
		std::cout << "Validation enabled\n";
}

void LogFileInitialize(const char* strFileName)
{
#ifndef DISABLE_LOG

    FILE* f = NULL;
    const char* logFilename;

    if (strFileName == NULL)
    {
        SP_strcpy(LogfilePath, SP_MAX_PATH, "c:\\splog.txt");
        logFilename = GetLogFilename();
    }
    else
    {
        logFilename = strFileName;
        SP_strcpy(LogfilePath, SP_MAX_PATH, strFileName);
    }

    // It is valid for there to be no Log File. However since this
    // is the only place where the log file is initialized, we flag
    // it as something to note in the console.

    if (logFilename != NULL)
    {
        // Open for writing - this will overwrite any previous logfile
#ifdef _WIN32
        fopen_s(&f, logFilename, "w+");    // read binary
#else
        f = fopen(logFilename, "w+");
#endif

        if (f != NULL)
        {
            fprintf(f, "Logging Started: %s\n\n", StringUtils::GetTimeString().c_str());
            fclose(f);
        }
        else
        {
            Log(logERROR, "Unable to open logfile %s for writing \n", logFilename);
        }
    }

#ifdef WIN32

    if (s_ConsoleAttached == false)
    {
        // ensure the log system is attached to a console
        // AttachConsole requires Win 2K or later.
        AttachConsole(ATTACH_PARENT_PROCESS);
        s_ConsoleAttached = true;
    }

#endif

#else
    SP_UNREFERENCED_PARAMETER(strFileName);
#endif   //DISABLE_LOG
}

int w__openConsole(lua_State *L)
{
	static bool is_open = false;

	if (is_open)
	{
		love::luax_pushboolean(L, is_open);
		return 1;
	}

	is_open = true;

	// FIXME: we don't call AttachConsole in Windows XP because it seems to
	// break later AllocConsole calls if it fails. A better workaround might be
	// possible, but it's hard to find a WinXP system to test on these days...
	if (!IsWindowsVistaOrGreater() || !AttachConsole(ATTACH_PARENT_PROCESS))
	{
		// Create our own console if we can't attach to an existing one.
		if (!AllocConsole())
		{
			is_open = false;
			love::luax_pushboolean(L, is_open);
			return 1;
		}

		SetConsoleTitle(TEXT("LOVE Console"));

		const int MAX_CONSOLE_LINES = 5000;
		CONSOLE_SCREEN_BUFFER_INFO console_info;

		// Set size.
		GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &console_info);
		console_info.dwSize.Y = MAX_CONSOLE_LINES;
		SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE), console_info.dwSize);
	}

	FILE *fp;

	// Redirect stdout.
	fp = freopen("CONOUT$", "w", stdout);
	if (L && fp == NULL)
		return luaL_error(L, "Console redirection of stdout failed.");

	// Redirect stdin.
	fp = freopen("CONIN$", "r", stdin);
	if (L && fp == NULL)
		return luaL_error(L, "Console redirection of stdin failed.");

	// Redirect stderr.
	fp = freopen("CONOUT$", "w", stderr);
	if (L && fp == NULL)
		return luaL_error(L, "Console redirection of stderr failed.");

	love::luax_pushboolean(L, is_open);
	return 1;
}

void Utils::AllocateConsole(LPCSTR pTitle)
{
	AllocConsole() ;
	AttachConsole(GetCurrentProcessId());
	freopen("CON", "w", stdout) ;
	SetConsoleTitleA(pTitle);
	COORD cordinates = {80, 32766};
	HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
	SetConsoleScreenBufferSize(handle, cordinates);
}

Console::Console()
{
	// Attach to the parent console if available, otherwise allocate one
	if(!AttachConsole(ATTACH_PARENT_PROCESS)) AllocConsole();

	// Get the input/output handles for the attached console
	m_stderr = GetStdHandle(STD_ERROR_HANDLE);
	m_stdin = GetStdHandle(STD_INPUT_HANDLE);
	m_stdout = GetStdHandle(STD_OUTPUT_HANDLE);
}

void Debug::Initialize()
{
	AllocConsole();
	AttachConsole(GetCurrentProcessId());
	consoleHandle = GetStdHandle(STD_OUTPUT_HANDLE);

#if _DEBUG
	Debug::Log("Debug Initialized");
#endif
}