module createprocess; 

import windows; 

import std.string;
import std.signals;
import globals;


/// run new program as child process and return the exit code of the program when it's finished
uint execProcess(char[] program, char[] args, bool requireExitCode=true)
{
    uint retcode; 
    
    LPCTSTR lpApplicationName = .toStringz(program);
    LPCTSTR lpCommandLine = .toStringz(" " ~ args);  
    LPCTSTR lpCurrentDirectory = .toStringz(globals.programDir); 

    // collect startup info 
    STARTUPINFOA startup;
    GetStartupInfoA(&startup);
    startup.dwFlags = STARTF_USESTDHANDLES;
    startup.cb = STARTUPINFOA.sizeof;
    
    PROCESS_INFORMATION* info = new PROCESS_INFORMATION();

    if (CreateProcessA(lpApplicationName, lpCommandLine, 
                        null,    null, false, 
                        CREATE_NEW_CONSOLE, null,null,
                        &startup,
                        info) != 0)
    {
        GetExitCodeProcess(info.hProcess, &retcode);
        
        // wait for the program to finish to get the exit code of the program 
        if (requireExitCode)
        {
            // while loop until program is done
            while (retcode == STILL_ACTIVE)
            {
                GetExitCodeProcess(info.hProcess, &retcode);
                Sleep(100);
            }
        }
            
        CloseHandle(info.hProcess);
        CloseHandle(info.hThread);
        
        return retcode; 
    }
    
    return 0; 
}


// Hook ChildProcess up to a timer so that process is called once every .5 seconds, 
// which the only thing it will really do is to call the return code emitter if it is found
class ChildProcesses
{
    // process all processes
    void process()
    {
        // process each process to emit the return code if it has it
        foreach(char[] key; processes.keys)
        {
            uint retcode = 0; 
            
            // get the state of the process
            GetExitCodeProcess(processes[key].process.info.hProcess, &retcode);
            
            // if the process is still running, just let it run
            if (retcode == STILL_ACTIVE)
            {
                processes[key].running = true; 
            }
            // process is done running and we havn't gotten the return code, get the return code  
            else if (!processes[key].hasRetCode)
            {
                processes[key].running = false; 
                processes[key].process.emit(retcode);  
                processes[key].hasRetCode = true; 
                processes[key].started = false;
                processes[key].retCode = retcode; 
                
                // close program handles
                CloseHandle(processes[key].process.info.hProcess);
                CloseHandle(processes[key].process.info.hThread);
            }
        }
    }
    
    // start process identified by program name with arguments
    void start(char[] progName, char[] args, void delegate(int) retCodeCall)
    {
        // our key will be combo of program and arg names 
        char[] key = progName ~ args; 
        
        Process p; 
        
        // store program name so we can easily kill it 
        p.programName = progName; 
        
        // init our class 
        p.process = new PHandle;

        // set program name, args, and current directory 
        p.process.lpApplicationName = .toStringz(progName);
        p.process.lpCommandLine = .toStringz(" " ~ args);
        p.process.lpCurrentDirectory = .toStringz(globals.programDir); 
        
        // get startup information
        GetStartupInfoA(&p.process.startup); 
        p.process.startup.dwFlags = STARTF_USESTDHANDLES;
        p.process.startup.cb = STARTUPINFOA.sizeof;
        
        // create new process information
        p.process.info = new PROCESS_INFORMATION();

        // start running the new process 
        CreateProcessA(p.process.lpApplicationName, 
                       p.process.lpCommandLine, 
                       null, null, false, CREATE_NEW_CONSOLE, null,null,
                       &p.process.startup,
                        p.process.info); 
        
        p.started = true; 
        
        // hook up code that will do something with our return function
        p.process.retCodeSignal.connect(retCodeCall); 
        p.hasRetCode = false;
        
        // add it to our associative array 
        processes[key] = p;
    }
    
    // simply terminate all running processes 
    void terminateAll()
    {
        foreach(char[] key; processes.keys)
        {
            terminate(key);
        }
    }
    
    // terminate process identified by program name with arguments 
    void terminate(char[] key)
    {
        uint retcode = 0;
        
        // get it's exit code and then terminate the process 
        GetExitCodeProcess(processes[key].process.info.hProcess, &retcode);
        TerminateProcess(processes[key].process.info.hProcess, retcode);

        // close program handles 
        CloseHandle(processes[key].process.info.hProcess);
        CloseHandle(processes[key].process.info.hThread);
    }

    // all information about a process is stored here
    class PHandle
    {
        LPCTSTR lpApplicationName;
        LPCTSTR lpCommandLine;
        LPCTSTR lpCurrentDirectory; 

        STARTUPINFOA startup;
        PROCESS_INFORMATION* info; 
        
        mixin Signal!(int) retCodeSignal; // signal emitted when found the return code 
    }

    struct Process
    {
        bool started = false; // whether or not process was started 
        bool running = false; // whether or not process is running
        int retCode=0; // return code of the process 
        bool hasRetCode = false; // whether or not process has the proper return code 
        PHandle process; // process information structure 
        char[] programName; 
    }
    
    // store in an assoc array
    Process[char[]] processes; 
}