/*
 * PROJECT:     ReactOS API Test GUI
 * LICENSE:     GPL - See COPYING in the top level directory
 * FILE:        
 * PURPOSE:     main dialog implementation
 * COPYRIGHT:   Copyright 2008 Ged Murphy <gedmurphy@reactos.org>
 *
 */

#include <precomp.h>
#include <io.h>

#define BUFSIZE 4096

HINSTANCE hInstance;

WCHAR szPipeName[] = L"\\\\.\\pipe\\winetest_pipe";

typedef int (_cdecl *RUNTEST)(char **);

DWORD WINAPI
PipeReadThread(LPVOID lpParam)
{
    PMAIN_WND_INFO pInfo;
    HWND hList, hEdit;
    DWORD dwRead;
    CHAR chBuf[BUFSIZE];
    BOOL bSuccess = FALSE;
    LVITEMA item;
    INT count;

    pInfo = (PMAIN_WND_INFO)lpParam;

    hList = GetDlgItem(pInfo->hMainWnd, IDC_LIST);
    hEdit = GetDlgItem(pInfo->hMainWnd, IDC_OUTPUT);

    ZeroMemory(&item, sizeof(LVITEMA));
    item.mask = LVIF_TEXT;

    while (TRUE)
    {
        dwRead = 0;
        bSuccess = ReadFile(pInfo->hStdOutRd,
                            chBuf,
                            BUFSIZE,
                            &dwRead,
                            NULL);
        if(!bSuccess || dwRead == 0)
            break;

        chBuf[dwRead] = 0;

        count = GetWindowTextLengthA(hEdit);
        SendMessageA(hEdit, EM_SETSEL, (WPARAM)count, (LPARAM)count);
        SendMessageA(hEdit, EM_REPLACESEL, 0, (LPARAM)chBuf);

        //item.iItem = ListView_GetItemCount(hList);
        //item.pszText = chBuf;
        //SendMessage(hEdit, LVM_INSERTITEMA, 0, (LPARAM)&item);
    }

    return 0;
}


DWORD WINAPI
CreateClientProcess(PMAIN_WND_INFO pInfo)
{
    SECURITY_ATTRIBUTES sa;
    STARTUPINFO si;
    PROCESS_INFORMATION pi;
    BOOL bSuccess = FALSE;

    //
    // Set up the security attributes
    //
    sa.nLength= sizeof(SECURITY_ATTRIBUTES);
    sa.lpSecurityDescriptor = NULL;
    sa.bInheritHandle = TRUE;

    //
    // Create a pipe for the child process's STDOUT
    //
    if (!CreatePipe(&pInfo->hStdOutRd,
                    &pInfo->hStdOutWr,
                    &sa,
                    0))
    {
        return FALSE;
    }

    //
    // Ensure the read handle to the pipe for STDOUT is not inherited
    //
    if (!SetHandleInformation(pInfo->hStdOutRd,
                              HANDLE_FLAG_INHERIT,
                              0))
    {
        return FALSE;
    }

    ZeroMemory(&si, sizeof(STARTUPINFO));
    si.cb = sizeof(STARTUPINFO);
    si.hStdError = pInfo->hStdOutWr;
    si.hStdOutput = pInfo->hStdOutWr;
    si.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
    si.dwFlags |= STARTF_USESTDHANDLES;

    ZeroMemory(&pi, sizeof(PROCESS_INFORMATION));

    bSuccess = CreateProcessW(pInfo->lpCmdLine,
                              NULL,
                              NULL,
                              NULL,
                              TRUE,
                              0,//CREATE_SUSPENDED,
                              NULL,
                              NULL,
                              &si,
                              &pi);
    if (bSuccess)
    {
        //
        // Create thread to handle pipe input from child processes
        //
        pInfo->hPipeThread = CreateThread(NULL,
                                          0,
                                          PipeReadThread,
                                          pInfo,
                                          0,
                                          NULL);

        WaitForSingleObject(pi.hProcess, INFINITE);

        CloseHandle(pi.hProcess);
        CloseHandle(pi.hThread);
    }

    return bSuccess;
}


static BOOL
OnInitMainDialog(HWND hDlg,
                 LPARAM lParam)
{
    PMAIN_WND_INFO pInfo;

    pInfo = (PMAIN_WND_INFO)lParam;

    /* Initialize the main window context */
    pInfo->hMainWnd = hDlg;

    SetWindowLongPtr(hDlg,
                     GWLP_USERDATA,
                     (LONG_PTR)pInfo);

    pInfo->hSmIcon = LoadImageW(hInstance,
                                MAKEINTRESOURCEW(IDI_ICON),
                                IMAGE_ICON,
                                16,
                                16,
                                0);
    if (pInfo->hSmIcon)
    {
         SendMessageW(hDlg,
                      WM_SETICON,
                      ICON_SMALL,
                      (LPARAM)pInfo->hSmIcon);
    }

    pInfo->hBgIcon = LoadImageW(hInstance,
                                MAKEINTRESOURCEW(IDI_ICON),
                                IMAGE_ICON,
                                32,
                                32,
                                0);
    if (pInfo->hBgIcon)
    {
        SendMessageW(hDlg,
                     WM_SETICON,
                     ICON_BIG,
                     (LPARAM)pInfo->hBgIcon);
    }

    return TRUE;
}

static VOID
RunSelectedTest(PMAIN_WND_INFO pInfo)
{
    HWND hRunCmd;
    WCHAR szTextCmd[MAX_RUN_CMD];
    INT sel;

    hRunCmd = GetDlgItem(pInfo->hMainWnd, IDC_TESTSELECTION);

    sel = SendMessageW(hRunCmd,
                       CB_GETCURSEL,
                       0,
                       0);
    if (sel != CB_ERR)
    {
        if (SendMessageW(hRunCmd,
                         CB_GETLBTEXT,
                         sel,
                         (LPARAM)szTextCmd) != CB_ERR)
        {
            pInfo->lpCmdLine = (LPWSTR)SendMessage(hRunCmd,
                                                   CB_GETITEMDATA,
                                                   0,
                                                   0);
            if (pInfo->lpCmdLine)
            {
                //
                // Create a new thread to create the client process
                // and receive any ouput via stdout
                //
                CreateThread(NULL,
                             0,
                             CreateClientProcess,
                             pInfo,
                             0,
                             NULL);
            }
        }
    }
}

static VOID
AddTestToCombo(PMAIN_WND_INFO pInfo)
{
    HWND hRunCmd;
    LPWSTR lpExePath;
    INT len;

    hRunCmd = GetDlgItem(pInfo->hMainWnd, IDC_TESTSELECTION);
    if (hRunCmd)
    {
        SendMessageW(hRunCmd,
                     CB_INSERTSTRING,
                     0,
                     (LPARAM)pInfo->SelectedTest.szName);

        len = (wcslen(pInfo->SelectedTest.szRunCmd) + 1) * sizeof(WCHAR);
        lpExePath = HeapAlloc(GetProcessHeap(), 0, len);
        if (lpExePath)
        {
            wcsncpy(lpExePath,
                    pInfo->SelectedTest.szRunCmd,
                    len / sizeof(WCHAR));
        }

        SendMessageW(hRunCmd,
                     CB_SETITEMDATA,
                     0,
                     (LPARAM)lpExePath);
        SendMessageW(hRunCmd,
                     CB_SETCURSEL,
                     0,
                     0);
    }
}

static VOID
FreeTestCmdStrings(PMAIN_WND_INFO pInfo)
{
    HWND hRunCmd;
    LPWSTR lpExePath;
    INT cnt, i;

    hRunCmd = GetDlgItem(pInfo->hMainWnd, IDC_TESTSELECTION);

    cnt = SendMessageW(hRunCmd,
                       CB_GETCOUNT,
                       0,
                       0);
    if (cnt != CB_ERR)
    {
        for (i = 0; i < cnt; i++)
        {
            lpExePath = (LPWSTR)SendMessage(hRunCmd,
                                            CB_GETITEMDATA,
                                            i,
                                            0);
            if (lpExePath)
            {
                HeapFree(GetProcessHeap(), 0, lpExePath);
            }
        }
    }
}

static BOOL CALLBACK
MainDlgProc(HWND hDlg,
            UINT Message,
            WPARAM wParam,
            LPARAM lParam)
{
    PMAIN_WND_INFO pInfo;

    /* Get the window context */
    pInfo = (PMAIN_WND_INFO)GetWindowLongPtr(hDlg,
                                             GWLP_USERDATA);
    if (pInfo == NULL && Message != WM_INITDIALOG)
    {
        goto HandleDefaultMessage;
    }

    switch(Message)
    {
        case WM_INITDIALOG:
            return OnInitMainDialog(hDlg, lParam);

        case WM_COMMAND:
        {
            switch(LOWORD(wParam))
            {
                case IDC_BROWSE:
                {
                    INT_PTR ret;

                    ret = DialogBoxParamW(hInstance,
                                          MAKEINTRESOURCEW(IDD_TESTBROWSER),
                                          hDlg,
                                          (DLGPROC)BrowseDlgProc,
                                          (LPARAM)pInfo);
                    if (ret == IDOK)
                    {
                        AddTestToCombo(pInfo);
                    }

                    break;
                }
                case IDC_OPTIONS:
                    DialogBoxParamW(hInstance,
                                    MAKEINTRESOURCEW(IDD_OPTIONS),
                                    hDlg,
                                    (DLGPROC)OptionsDlgProc,
                                    (LPARAM)pInfo);
                    break;

                case IDC_RUN:
                    RunSelectedTest(pInfo);
                    break;

                case IDOK:
                    EndDialog(hDlg, 0);
                    break;
            }
        }
        break;

        case WM_CLOSE:
            EndDialog(hDlg, 0);
            break;

        case WM_DESTROY:
             if (pInfo->hSmIcon)
                DestroyIcon(pInfo->hSmIcon);
            if (pInfo->hBgIcon)
                DestroyIcon(pInfo->hBgIcon);

            FreeTestCmdStrings(pInfo);

            break;

HandleDefaultMessage:
        default:
            return FALSE;
    }

    return FALSE;
}


INT WINAPI
wWinMain(HINSTANCE hInst,
         HINSTANCE hPrev,
         LPWSTR Cmd,
         int iCmd)
{
    INITCOMMONCONTROLSEX iccx;
    PMAIN_WND_INFO pInfo;
    INT Ret = -1;

    UNREFERENCED_PARAMETER(hPrev);
    UNREFERENCED_PARAMETER(Cmd);
    UNREFERENCED_PARAMETER(iCmd); 

    hInstance = hInst;

    ZeroMemory(&iccx, sizeof(INITCOMMONCONTROLSEX));
    iccx.dwSize = sizeof(INITCOMMONCONTROLSEX);
    iccx.dwICC = ICC_TAB_CLASSES;
    InitCommonControlsEx(&iccx);

    pInfo = HeapAlloc(GetProcessHeap(),
                      0,
                      sizeof(MAIN_WND_INFO));
    if (pInfo)
    {
        Ret = (DialogBoxParamW(hInstance,
                               MAKEINTRESOURCEW(IDD_WINETESTGUI),
                               NULL,
                               (DLGPROC)MainDlgProc,
                               (LPARAM)pInfo) == IDOK);

        HeapFree(GetProcessHeap(),
                 0,
                 pInfo);
    }

    return Ret;
}