/** 
 * @file updater.cpp
 * @brief Windows auto-updater
 *
 * $LicenseInfo:firstyear=2002&license=viewergpl$
 * 
 * Copyright (c) 2002-2009, Linden Research, Inc.
 * 
 * Second Life Viewer Source Code
 * The source code in this file ("Source Code") is provided by Linden Lab
 * to you under the terms of the GNU General Public License, version 2.0
 * ("GPL"), unless you have obtained a separate licensing agreement
 * ("Other License"), formally executed by you and Linden Lab.  Terms of
 * the GPL can be found in doc/GPL-license.txt in this distribution, or
 * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
 * 
 * There are special exceptions to the terms and conditions of the GPL as
 * it is applied to this Source Code. View the full text of the exception
 * in the file doc/FLOSS-exception.txt in this software distribution, or
 * online at
 * http://secondlifegrid.net/programs/open_source/licensing/flossexception
 * 
 * By copying, modifying or distributing this software, you acknowledge
 * that you have read and understood your obligations described above,
 * and agree to abide by those obligations.
 * 
 * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
 * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
 * COMPLETENESS OR PERFORMANCE.
 * $/LicenseInfo$
 */

//
// Usage: updater -url <url>
//

// We use dangerous fopen, strtok, mbstowcs, sprintf
// which generates warnings on VC2005.
// *TODO: Switch to fopen_s, strtok_s, etc.
#define _CRT_SECURE_NO_DEPRECATE

#	define WIN32_LEAN_AND_MEAN
#	include <winsock2.h>
#include <windows.h>
#include <wininet.h>
#include <stdio.h>
#include <string>
#include <iostream>
#include <stdexcept>
#include <sstream>
#include <fstream>

#define BUFSIZE 8192

int  gTotalBytesRead = 0;
DWORD gTotalBytes = -1;
HWND gWindow = NULL;
WCHAR gProgress[256];
char* gUpdateURL = NULL;

#if _DEBUG
std::ofstream logfile;
#define DEBUG(expr) logfile << expr << std::endl
#else
#define DEBUG(expr) /**/
#endif

char* wchars_to_utf8chars(const WCHAR* in_chars)
{
	int tlen = 0;
	const WCHAR* twc = in_chars;
	while (*twc++ != 0)
	{
		tlen++;
	}
	char* outchars = new char[tlen];
	char* res = outchars;
	for (int i=0; i<tlen; i++)
	{
		int cur_char = (int)(*in_chars++);
		if (cur_char < 0x80)
		{
			*outchars++ = (char)cur_char;
		}
		else
		{
			*outchars++ = '?';
		}
	}
	*outchars = 0;
	return res;
}

class Fetcher
{
public:
    Fetcher(const std::wstring& uri)
    {
        // These actions are broken out as separate methods not because it
        // makes the code clearer, but to avoid triggering AntiVir and
        // McAfee-GW-Edition virus scanners (DEV-31680).
        mInet = openInet();
        mDownload = openUrl(uri);
    }

    ~Fetcher()
    {
        DEBUG("Calling InternetCloseHandle");
        InternetCloseHandle(mDownload);
        InternetCloseHandle(mInet);
    }

    unsigned long read(char* buffer, size_t bufflen) const;

    DWORD getTotalBytes() const
    {
        DWORD totalBytes;
        DWORD sizeof_total_bytes = sizeof(totalBytes);
        HttpQueryInfo(mDownload, HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_NUMBER,
                      &totalBytes, &sizeof_total_bytes, NULL);
        return totalBytes;
    }

    struct InetError: public std::runtime_error
    {
        InetError(const std::string& what): std::runtime_error(what) {}
    };

private:
    // We test results from a number of different MS functions with different
    // return types -- but the common characteristic is that 0 (i.e. (! result))
    // means an error of some kind.
    template <typename RESULT>
    static RESULT check(const std::string& desc, RESULT result)
    {
        if (result)
        {
            // success, show caller
            return result;
        }
        DWORD err = GetLastError();
        std::ostringstream out;
        out << desc << " Failed: " << err;
        DEBUG(out.str());
        throw InetError(out.str());
    }

    HINTERNET openUrl(const std::wstring& uri) const;
    HINTERNET openInet() const;

    HINTERNET mInet, mDownload;
};

HINTERNET Fetcher::openInet() const
{
    DEBUG("Calling InternetOpen");
    // Init wininet subsystem
    return check("InternetOpen",
                 InternetOpen(L"LindenUpdater", INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0));
}

HINTERNET Fetcher::openUrl(const std::wstring& uri) const
{
    DEBUG("Calling InternetOpenUrl: " << wchars_to_utf8chars(uri.c_str()));
    return check("InternetOpenUrl",
                 InternetOpenUrl(mInet, uri.c_str(), NULL, 0, INTERNET_FLAG_NEED_FILE, NULL));
}

unsigned long Fetcher::read(char* buffer, size_t bufflen) const
{
    unsigned long bytes_read = 0;
    DEBUG("Calling InternetReadFile");
    check("InternetReadFile",
          InternetReadFile(mDownload, buffer, bufflen, &bytes_read));
    return bytes_read;
}

int WINAPI get_url_into_file(const std::wstring& uri, const std::string& path, int *cancelled)
{
	int success = FALSE;
	*cancelled = FALSE;

    DEBUG("Opening '" << path << "'");

	FILE* fp = fopen(path.c_str(), "wb");		/* Flawfinder: ignore */

	if (!fp)
	{
        DEBUG("Failed to open '" << path << "'");
		return success;
	}

    // Note, ctor can throw, since it uses check() function.
    Fetcher fetcher(uri);
    gTotalBytes = fetcher.getTotalBytes();

/*==========================================================================*|
    // nobody uses total_bytes?!? What's this doing here?
	DWORD total_bytes = 0;
	success = check("InternetQueryDataAvailable",
                    InternetQueryDataAvailable(hdownload, &total_bytes, 0, 0));
|*==========================================================================*/

	success = FALSE;
	while(!success && !(*cancelled))
	{
        char data[BUFSIZE];		/* Flawfinder: ignore */
        unsigned long bytes_read = fetcher.read(data, sizeof(data));

		if (!bytes_read)
		{
            DEBUG("InternetReadFile Read " << bytes_read << " bytes.");
		}

        DEBUG("Reading Data, bytes_read = " << bytes_read);
		
		if (bytes_read == 0)
		{
			// If InternetFileRead returns TRUE AND bytes_read == 0
			// we've successfully downloaded the entire file
			wsprintf(gProgress, L"Download complete.");
			success = TRUE;
		}
		else
		{
			// write what we've got, then continue
			fwrite(data, sizeof(char), bytes_read, fp);

			gTotalBytesRead += int(bytes_read);

			if (gTotalBytes != -1)
				wsprintf(gProgress, L"Downloaded: %d%%", 100 * gTotalBytesRead / gTotalBytes);
			else
				wsprintf(gProgress, L"Downloaded: %dK", gTotalBytesRead / 1024);

		}

        DEBUG("Calling InvalidateRect");
		
		// Mark the window as needing redraw (of the whole thing)
		InvalidateRect(gWindow, NULL, TRUE);

		// Do the redraw
        DEBUG("Calling UpdateWindow");
		UpdateWindow(gWindow);

        DEBUG("Calling PeekMessage");
		MSG msg;
		while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);

			if (msg.message == WM_QUIT)
			{
				// bail out, user cancelled
				*cancelled = TRUE;
			}
		}
	}

	fclose(fp);
	return success;
}

LRESULT CALLBACK WinProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
{
	HDC hdc;			// Drawing context
	PAINTSTRUCT ps;

	switch(message)
	{
	case WM_PAINT:
		{
			hdc = BeginPaint(hwnd, &ps);

			RECT rect;
			GetClientRect(hwnd, &rect);
			DrawText(hdc, gProgress, -1, &rect, 
				DT_SINGLELINE | DT_CENTER | DT_VCENTER);

			EndPaint(hwnd, &ps);
			return 0;
		}
	case WM_CLOSE:
	case WM_DESTROY:
		// Get out of full screen
		// full_screen_mode(false);
		PostQuitMessage(0);
		return 0;
	}
	return DefWindowProc(hwnd, message, wparam, lparam);
}

#define win_class_name L"FullScreen"

int parse_args(int argc, char **argv)
{
	int j;

	for (j = 1; j < argc; j++) 
	{
		if ((!strcmp(argv[j], "-url")) && (++j < argc)) 
		{
			gUpdateURL = argv[j];
		}
	}

	// If nothing was set, let the caller know.
	if (!gUpdateURL)
	{
		return 1;
	}
	return 0;
}
	
int WINAPI
WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
	// Parse the command line.
	LPSTR cmd_line_including_exe_name = GetCommandLineA();

	const int MAX_ARGS = 100;
	int argc = 0;
	char* argv[MAX_ARGS];		/* Flawfinder: ignore */

#if _DEBUG
	logfile.open("updater.log", std::ios_base::out);
    DEBUG("Parsing command arguments");
#endif
	
	char *token = NULL;
	if( cmd_line_including_exe_name[0] == '\"' )
	{
		// Exe name is enclosed in quotes
		token = strtok( cmd_line_including_exe_name, "\"" );
		argv[argc++] = token;
		token = strtok( NULL, " \t," );
	}
	else
	{
		// Exe name is not enclosed in quotes
		token = strtok( cmd_line_including_exe_name, " \t," );
	}

	while( (token != NULL) && (argc < MAX_ARGS) )
	{
		argv[argc++] = token;
		/* Get next token: */
		if (*(token + strlen(token) + 1) == '\"')		/* Flawfinder: ignore */
		{
			token = strtok( NULL, "\"");
		}
		else
		{
			token = strtok( NULL, " \t," );
		}
	}

	gUpdateURL = NULL;

	/////////////////////////////////////////
	//
	// Process command line arguments
	//

    DEBUG("Processing command arguments");
	
	//
	// Parse the command line arguments
	//
	int parse_args_result = parse_args(argc, argv);
	
	WNDCLASSEX wndclassex = { 0 };
	//DEVMODE dev_mode = { 0 };

	const int WINDOW_WIDTH = 250;
	const int WINDOW_HEIGHT = 100;

	wsprintf(gProgress, L"Connecting...");

	/* Init the WNDCLASSEX */
	wndclassex.cbSize = sizeof(WNDCLASSEX);
	wndclassex.style = CS_HREDRAW | CS_VREDRAW;
	wndclassex.hInstance = hInstance;
	wndclassex.lpfnWndProc = WinProc;
	wndclassex.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);
	wndclassex.lpszClassName = win_class_name;
	
	RegisterClassEx(&wndclassex);
	
	// Get the size of the screen
	//EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &dev_mode);
	
	gWindow = CreateWindowEx(NULL, win_class_name, 
		L"Second Life Updater",
		WS_OVERLAPPEDWINDOW, 
		CW_USEDEFAULT, 
		CW_USEDEFAULT, 
		WINDOW_WIDTH, 
		WINDOW_HEIGHT,
		NULL, NULL, hInstance, NULL);

	ShowWindow(gWindow, nShowCmd);
	UpdateWindow(gWindow);

	if (parse_args_result)
	{
		MessageBox(gWindow, 
				L"Usage: updater -url <url> [-name <window_title>] [-program <program_name>] [-silent]",
				L"Usage", MB_OK);
		return parse_args_result;
	}

	// Did we get a userserver to work with?
	if (!gUpdateURL)
	{
		MessageBox(gWindow, L"Please specify the download url from the command line",
			L"Error", MB_OK);
		return 1;
	}

	// Can't feed GetTempPath into GetTempFile directly
	char temp_path[MAX_PATH];		/* Flawfinder: ignore */
	if (0 == GetTempPathA(sizeof(temp_path), temp_path))
	{
		MessageBox(gWindow, L"Problem with GetTempPath()",
			L"Error", MB_OK);
		return 1;
	}
    std::string update_exec_path(temp_path);
	update_exec_path.append("Second_Life_Updater.exe");

	WCHAR update_uri[4096];
    mbstowcs(update_uri, gUpdateURL, sizeof(update_uri));

	int success = 0;
	int cancelled = 0;

	// Actually do the download
    try
    {
        DEBUG("Calling get_url_into_file");
        success = get_url_into_file(update_uri, update_exec_path, &cancelled);
    }
    catch (const Fetcher::InetError& e)
    {
        (void)e;
        success = FALSE;
        DEBUG("Caught: " << e.what());
    }

	// WinInet can't tell us if we got a 404 or not.  Therefor, we check
	// for the size of the downloaded file, and assume that our installer
	// will always be greater than 1MB.
	if (gTotalBytesRead < (1024 * 1024) && ! cancelled)
	{
		MessageBox(gWindow,
			L"The Imprudence auto-update has failed.\n"
			L"The problem may be caused by other software installed \n"
			L"on your computer, such as a firewall.\n"
			L"Please visit http://wiki.kokuaviewer.org/wiki/Imprudence:Downloads \n"
			L"to download the latest version of Imprudence.\n",
			NULL, MB_OK);
		return 1;
	}

	if (cancelled)
	{
		// silently exit
		return 0;
	}

	if (!success)
	{
		MessageBox(gWindow, 
			L"Imprudence download failed.\n"
			L"Please try again later.", 
			NULL, MB_OK);
		return 1;
	}

	// TODO: Make updates silent (with /S to NSIS)
	//char params[256];		/* Flawfinder: ignore */
	//sprintf(params, "/S");	/* Flawfinder: ignore */
	//MessageBox(gWindow, 
	//	L"Updating Second Life.\n\nSecond Life will automatically start once the update is complete.  This may take a minute...",
	//	L"Download Complete",
	//	MB_OK);
		
/*==========================================================================*|
    // DEV-31680: ShellExecuteA() causes McAfee-GW-Edition and AntiVir
    // scanners to flag this executable as a probable virus vector.
    // Less than or equal to 32 means failure
	if (32 >= (int) ShellExecuteA(gWindow, "open", update_exec_path.c_str(), NULL, 
		"C:\\", SW_SHOWDEFAULT))
|*==========================================================================*/
    // from http://msdn.microsoft.com/en-us/library/ms682512(VS.85).aspx
    STARTUPINFOA si;
    PROCESS_INFORMATION pi;
    ZeroMemory(&si, sizeof(si));
    si.cb = sizeof(si);
    ZeroMemory(&pi, sizeof(pi));

    if (! CreateProcessA(update_exec_path.c_str(), // executable file
                  NULL,                            // command line
                  NULL,             // process cannot be inherited
                  NULL,             // thread cannot be inherited
                  FALSE,            // do not inherit existing handles
                  0,                // process creation flags
                  NULL,             // inherit parent's environment
                  NULL,             // inherit parent's current dir
                  &si,              // STARTUPINFO
                  &pi))             // PROCESS_INFORMATION
	{
		MessageBox(gWindow, L"Update failed.  Please try again later.", NULL, MB_OK);
		return 1;
	}

	// Give installer some time to open a window
	Sleep(1000);

	return 0;
}