#include "ruby.h"
#include "util.h"

#include "lsapilib.h"
#include <errno.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <signal.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <unistd.h>

/* RUBY_EXTERN VALUE ruby_errinfo; */
RUBY_EXTERN VALUE rb_stdin;
RUBY_EXTERN VALUE rb_stdout;
#if RUBY_VERSION_CODE < 180
RUBY_EXTERN VALUE rb_defout;
#endif

static VALUE orig_stdin;
static VALUE orig_stdout;
static VALUE orig_stderr;
#if RUBY_VERSION_CODE < 180
static VALUE orig_defout;
#endif

static VALUE orig_env;

static VALUE env_copy;

static VALUE lsapi_env;


/* static VALUE lsapi_objrefs; */

typedef struct lsapi_data
{
    LSAPI_Request * req;
    VALUE           env;
    int          (* fn_write)( LSAPI_Request *, const char * , int );
    
}lsapi_data;


static VALUE cLSAPI;

static VALUE s_req = Qnil;
static lsapi_data * s_req_data;

static VALUE s_req_stderr = Qnil;
static lsapi_data * s_stderr_data;

/*
static void lsapi_ruby_setenv(const char *name, const char *value)
{
    if (!name) return;

    if (value && *value)
	    ruby_setenv(name, value);
    else
        ruby_unsetenv(name);
}
*/


static void lsapi_mark( lsapi_data * data )
{
    rb_gc_mark( data->env );
}
/*
static void lsapi_free_data( lsapi_data * data )
{
   free( data );
}
*/
static int add_env_rails( const char * pKey, int keyLen, const char * pValue, int valLen,
                         void * arg )
{
    char * p;
    int len;
    /* Fixup some environment variables for rails */
    switch( *pKey )
    {
    case 'Q':
        if ( strcmp( pKey, "QUERY_STRING" ) == 0 )
        {
            if ( !*pValue )
                return 1;
        }
        break;
    case 'R':
        if (( *(pKey+8) == 'U' )&&( strcmp( pKey, "REQUEST_URI" ) == 0 ))
        {
            p = strchr( pValue, '?' );
            if ( p )
            {
                len = valLen - ( p - pValue ) - 1;
                /* 
                valLen = p - pValue;
                *p++ = 0;
                */
            }
            else
            {
                p = (char *)pValue + valLen;
                len = 0;
            }
            rb_hash_aset( lsapi_env,rb_tainted_str_new("PATH_INFO", 9),
                        rb_tainted_str_new(pValue, p - pValue));
            rb_hash_aset( lsapi_env,rb_tainted_str_new("REQUEST_PATH", 12),
                        rb_tainted_str_new(pValue, p - pValue));
            if ( *p == '?' )
                ++p;
            rb_hash_aset( lsapi_env,rb_tainted_str_new("QUERY_STRING", 12),
                        rb_tainted_str_new(p, len));
        }
        break;
    case 'S':
        if ( strcmp( pKey, "SCRIPT_NAME" ) == 0 )
        {
            pValue = "/";
            valLen = 1;
        }
        break;
    case 'P':
        if ( strcmp( pKey, "PATH_INFO" ) == 0 )
            return 1;
    default:
        break;
    }
    
    /* lsapi_ruby_setenv(pKey, pValue ); */
    
    rb_hash_aset( lsapi_env,rb_tainted_str_new(pKey, keyLen),
                    rb_tainted_str_new(pValue, valLen));
    return 1;
}

static int add_env_no_fix( const char * pKey, int keyLen, const char * pValue, int valLen,
                         void * arg )
{
    rb_hash_aset( lsapi_env,rb_tainted_str_new(pKey, keyLen),
                    rb_tainted_str_new(pValue, valLen));
    return 1;
}

typedef int (*fn_add_env)( const char * pKey, int keyLen, const char * pValue, int valLen,
                         void * arg );
                         
fn_add_env s_fn_add_env = add_env_no_fix;
                         
static void clear_env()
{
    /* rb_funcall( lsapi_env, rb_intern( "clear" ), 0 ); */
    rb_funcall( lsapi_env, rb_intern( "replace" ), 1, env_copy );
}

static void setup_cgi_env( lsapi_data * data )
{
    clear_env();

    LSAPI_ForeachHeader_r( data->req, s_fn_add_env, data );
    LSAPI_ForeachEnv_r( data->req, s_fn_add_env, data );
    
}




static VALUE lsapi_s_accept( VALUE self )
{

    if ( LSAPI_Prefork_Accept_r( &g_req ) == -1 )
        return Qnil;
    else
    {
        setup_cgi_env( s_req_data );
        return s_req;
    }
   
}

/*
static int chdir_file( const char * pFile )
{
    char * p = strrchr( pFile, '/' );
    int ret;
    if ( !p )
        return -1;
    *p = 0;
    ret = chdir( pFile );
    *p = '/';
    return ret;
}
*/

static VALUE lsapi_eval_string_wrap(VALUE self, VALUE str)
{
    if (rb_safe_level() >= 4)
    {
        Check_Type(str, T_STRING);
    }
    else
    {
        Check_SafeStr(str);
    }
    return rb_eval_string_wrap(StringValuePtr(str), NULL);
}

static VALUE lsapi_process( VALUE self )
{
    lsapi_data *data;
    const char * pScriptPath;
    Data_Get_Struct(self,lsapi_data, data);
    pScriptPath = LSAPI_GetScriptFileName_r( data->req );
/*
   if ( chdir_file( pScriptPath ) == -1 )
   {
       lsapi_send_error( 404 );
   }
   rb_load_file( pScriptPath );
*/
   return Qnil;
}


static VALUE lsapi_putc(VALUE self, VALUE c)
{
    char ch = NUM2CHR(c);
    lsapi_data *data;
    Data_Get_Struct(self,lsapi_data, data);
    if ( (*data->fn_write)( data->req, &ch, 1 ) == 1 )
        return c;
    else
        return INT2NUM( EOF );
}


static VALUE lsapi_write( VALUE self, VALUE str )
{
    lsapi_data *data;
    int len;
    Data_Get_Struct(self,lsapi_data, data);
/*    len = LSAPI_Write_r( data->req, RSTRING(str)->ptr, RSTRING(str)->len ); */
    if (TYPE(str) != T_STRING)
	    str = rb_obj_as_string(str);
    len = (*data->fn_write)( data->req, RSTRING(str)->ptr, RSTRING(str)->len );
    return INT2NUM( len );
}

static VALUE lsapi_print( int argc, VALUE *argv, VALUE out )
{
    int i;
    VALUE line;

    /* if no argument given, print `$_' */
    if (argc == 0)
    {
      argc = 1;
      line = rb_lastline_get();
      argv = &line;
    }
    for (i = 0; i<argc; i++)
    {
        if (!NIL_P(rb_output_fs) && i>0)
        {
            lsapi_write(out, rb_output_fs);
        }
        switch (TYPE(argv[i]))
        {
        case T_NIL:
            lsapi_write(out, rb_str_new2("nil"));
            break;
        default:
            lsapi_write(out, argv[i]);
            break;
        }
    }
    if (!NIL_P(rb_output_rs))
    {
        lsapi_write(out, rb_output_rs);
    }

    return Qnil;
}

static VALUE lsapi_printf(int argc, VALUE *argv, VALUE out)
{
    lsapi_write(out, rb_f_sprintf(argc, argv));
    return Qnil;
}

static VALUE lsapi_puts _((int, VALUE*, VALUE));

static VALUE lsapi_puts_ary(VALUE ary, VALUE out)
{
    VALUE tmp;
    int i;

    for (i=0; i<RARRAY(ary)->len; i++)
    {
        tmp = RARRAY(ary)->ptr[i];
	    if (rb_inspecting_p(tmp))
        {
	        tmp = rb_str_new2("[...]");
	    }
	    lsapi_puts(1, &tmp, out);
    }
    return Qnil;
}

static VALUE lsapi_puts(int argc, VALUE *argv, VALUE out)
{
    int i;
    VALUE line;

    /* if no argument given, print newline. */
    if (argc == 0)
    {
        lsapi_write(out, rb_default_rs);
        return Qnil;
    }
    for (i=0; i<argc; i++)
    {
        switch (TYPE(argv[i]))
        {
        case T_NIL:
            line = rb_str_new2("nil");
            break;
        case T_ARRAY:
            rb_protect_inspect(lsapi_puts_ary, argv[i], out);
            continue;
        default:
            line = argv[i];
            break;
        }
        line = rb_obj_as_string(line);
        lsapi_write(out, line);
        if (RSTRING(line)->ptr[RSTRING(line)->len-1] != '\n')
        {
            lsapi_write(out, rb_default_rs);
        }
    }

    return Qnil;
}


static VALUE lsapi_addstr(VALUE out, VALUE str)
{
    lsapi_write(out, str);
    return out;
}

static VALUE lsapi_flush( VALUE self )
{
/*
    lsapi_data *data;
    Data_Get_Struct(self,lsapi_data, data);
*/
    LSAPI_Flush_r( &g_req ); 
    return Qnil;
}

static VALUE lsapi_getc( VALUE self )
{
    int ch;
/*
    lsapi_data *data;
    Data_Get_Struct(self,lsapi_data, data);
*/
    if (rb_safe_level() >= 4 && !OBJ_TAINTED(self))
    {
        rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
    }
    ch = LSAPI_ReqBodyGetChar_r( &g_req );
    if ( ch == EOF )
        return Qnil;
    return INT2NUM( ch );
}

static VALUE lsapi_gets( VALUE self )
{
    VALUE str;
    int getLF = 0;
    char buff[4096];
    int len;
    if (rb_safe_level() >= 4 && !OBJ_TAINTED(self))
    {
        rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
    }
    if ( LSAPI_GetReqBodyRemain_r( &g_req ) <= 0 )
        return Qnil;
    str = rb_str_buf_new( 1024 );
    OBJ_TAINT(str);
    while( !getLF )
    {
        len = LSAPI_ReqBodyGetLine_r( &g_req, buff, 4096, &getLF );
        if ( len > 0 )
            rb_str_buf_cat( str, buff, len );
        
    }
    if (RSTRING(str)->len == 0)
        return Qnil;
    return str;
}


static VALUE lsapi_read(int argc, VALUE *argv, VALUE self)
{
    VALUE str;
    int n;
    int remain;
    char buff[8192];

    if (rb_safe_level() >= 4 && !OBJ_TAINTED(self))
    {
        rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
    }


    remain = LSAPI_GetReqBodyRemain_r( &g_req );
    if ( remain <= 0 )
        return Qnil;
    if (argc != 0)
    {
        n = NUM2INT(argv[0]);
        if ( remain > n )
            remain = n;
    }
    str = rb_str_buf_new( remain );
    OBJ_TAINT(str);
    while( remain > 0 )
    {
        n = LSAPI_ReadReqBody_r(&g_req, buff,
                        (remain > 8192)?8192:remain );
        if ( n > 0 )
        {
            rb_str_buf_cat( str, buff, n );
            remain -= n;
        }
        else if ( n <= 0 )
        {
            /* FIXME: broken connection */
            break;
        }
    }
    if (RSTRING(str)->len == 0)
        return Qnil;
    return str;
}

static VALUE lsapi_eof(VALUE self)
{
/*
   lsapi_data *data;

   if (rb_safe_level() >= 4 && !OBJ_TAINTED(self))
   {
       rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
   }
   Data_Get_Struct(self, lsapi_data, data);
*/
    return (LSAPI_GetReqBodyRemain( &g_req ) <= 0) ? Qtrue : Qfalse;
}

static VALUE lsapi_binmode(VALUE self)
{
    return self;
}

static VALUE lsapi_isatty(VALUE self)
{
    return Qfalse;
}

static VALUE lsapi_sync(VALUE self)
{
    return Qfalse;
}

static VALUE lsapi_setsync(VALUE self,VALUE sync)
{
    return Qfalse;
}

static VALUE lsapi_close(VALUE self)
{
    LSAPI_Flush_r( &g_req );    
    return Qnil;
}


static VALUE lsapi_reopen( int argc, VALUE *argv, VALUE self)
{
    VALUE orig_verbose;
    if ( self == s_req_stderr )
    {
        /* constant silence hack */
        orig_verbose = (VALUE)ruby_verbose;
        ruby_verbose = Qnil;

        rb_define_global_const("STDERR", orig_stderr);

        ruby_verbose = (VALUE)orig_verbose;

        return rb_funcall2( orig_stderr, rb_intern( "reopen" ), argc, argv );

    }
    return self;
}



void Init_lsapi()
{
    VALUE remove_env;
    VALUE orig_verbose; 
    char * p;

    LSAPI_Init();

    LSAPI_Init_Env_Parameters( rb_thread_select );

    p = getenv( "RAILS_ROOT" );
    if ( p )
    {
        if ( chdir( p ) == -1 )
            perror( "chdir()" );
    }
    if ( p || getenv( "RAILS_ENV" ) )
        s_fn_add_env = add_env_rails;

                
    orig_stdin = rb_stdin;
    orig_stdout = rb_stdout;
    orig_stderr = rb_stderr;
#if RUBY_VERSION_CODE < 180
    orig_defout = rb_defout;
#endif
    orig_env = rb_const_get( rb_cObject, rb_intern("ENV") );
    env_copy = rb_funcall( orig_env, rb_intern( "to_hash" ), 0 );
    
    /* tell the garbage collector it is a global variable, do not recycle it. */
    rb_global_variable(&env_copy);

    rb_hash_aset( env_copy,rb_tainted_str_new("GATEWAY_INTERFACE", 17),
                        rb_tainted_str_new("CGI/1.2", 7));
    
    /* Do not need those environments after initialization */
    remove_env = rb_str_new( "RAILS_ROOT", 10 );
    rb_funcall( env_copy, rb_intern( "delete" ), 1, remove_env );
    

    rb_define_global_function("eval_string_wrap", lsapi_eval_string_wrap, 1);

    cLSAPI = rb_define_class("LSAPI", rb_cObject);
    rb_define_singleton_method(cLSAPI, "accept", lsapi_s_accept, 0);

    rb_define_method(cLSAPI, "process", lsapi_process, 0 );
    /* rb_define_method(cLSAPI, "initialize", lsapi_initialize, 0); */
    rb_define_method(cLSAPI, "putc", lsapi_putc, 1);
    rb_define_method(cLSAPI, "write", lsapi_write, 1);
    rb_define_method(cLSAPI, "print", lsapi_print, -1);
    rb_define_method(cLSAPI, "printf", lsapi_printf, -1);
    rb_define_method(cLSAPI, "puts", lsapi_puts, -1);
    rb_define_method(cLSAPI, "<<", lsapi_addstr, 1);
    rb_define_method(cLSAPI, "flush", lsapi_flush, 0);
    rb_define_method(cLSAPI, "getc", lsapi_getc, 0);
    /* rb_define_method(cLSAPI, "ungetc", lsapi_ungetc, 1); */
    rb_define_method(cLSAPI, "gets", lsapi_gets, 0);
    rb_define_method(cLSAPI, "read", lsapi_read, -1);
    rb_define_method(cLSAPI, "eof", lsapi_eof, 0);
    rb_define_method(cLSAPI, "eof?", lsapi_eof, 0);
    rb_define_method(cLSAPI, "close", lsapi_close, 0);
    /* rb_define_method(cLSAPI, "closed?", lsapi_closed, 0); */
    rb_define_method(cLSAPI, "binmode", lsapi_binmode, 0);
    rb_define_method(cLSAPI, "isatty", lsapi_isatty, 0);
    rb_define_method(cLSAPI, "tty?", lsapi_isatty, 0);
    rb_define_method(cLSAPI, "sync", lsapi_sync, 0);
    rb_define_method(cLSAPI, "sync=", lsapi_setsync, 1);
    rb_define_method(cLSAPI, "reopen", lsapi_reopen, -1 );
    
        
    s_req = Data_Make_Struct( cLSAPI, lsapi_data, lsapi_mark, free, s_req_data );
    s_req_data->req = &g_req;
    s_req_data->fn_write = LSAPI_Write_r;
    rb_stdin = rb_stdout = s_req;

#if RUBY_VERSION_CODE < 180
    rb_defout = s_req;
#endif
    rb_global_variable(&s_req );

    s_req_stderr = Data_Make_Struct( cLSAPI, lsapi_data, lsapi_mark, free, s_stderr_data );
    s_stderr_data->req = &g_req;
    s_stderr_data->fn_write = LSAPI_Write_Stderr_r;
    rb_stderr = s_req_stderr;
    rb_global_variable(&s_req_stderr );

    /* constant silence hack */
    orig_verbose = (VALUE)ruby_verbose;
    ruby_verbose = Qnil;

    lsapi_env = rb_hash_new();
    /* redefine ENV using a hash table, should be faster than char **environment */
    rb_define_global_const("ENV", lsapi_env);
    
    rb_define_global_const("STDERR", rb_stderr);

    ruby_verbose = (VALUE)orig_verbose;
    
    return;
}