#pragma once
#include <fc/thread/future.hpp>
#include <fc/io/buffered_iostream.hpp>
#include <vector>
#include <fc/string.hpp>
#include <fc/filesystem.hpp>

namespace fc
{
    /**
     *   @brief abstract interface for interacting with external processes
     *
     *   At the very least we have ssh::process and direct child processes, and
     *   there may be other processes that need to implement this protocol.
     */
    class iprocess
    {
       public:
         enum exec_opts {
           open_none   = 0,
           open_stdin  = 0x01, 
           open_stdout = 0x02, 
           open_stderr = 0x04,
           open_all    = open_stdin|open_stdout|open_stderr,
           suppress_console = 0x08
         };

          virtual ~iprocess(){}

          /**
           *  
           *  @return *this
           */
          virtual iprocess& exec( const path& exe, std::vector<std::string> args, 
                                  const path& work_dir = path(), int opts = open_all ) = 0;

          /**
           *  @return blocks until the process exits
           */
          virtual int result(const microseconds& timeout = microseconds::maximum()) = 0;


          /**
           *  Forcefully kills the process.
           */
          virtual void kill() = 0;
          
          /**
           *  @brief returns a stream that writes to the process' stdin
           */
          virtual buffered_ostream_ptr in_stream() = 0;
          
          /**
           *  @brief returns a stream that reads from the process' stdout
           */
          virtual buffered_istream_ptr out_stream() = 0;
          /**
           *  @brief returns a stream that reads from the process' stderr
           */
          virtual buffered_istream_ptr err_stream() = 0;

    };

    typedef std::shared_ptr<iprocess> iprocess_ptr;
    

} // namespace fc