/* gtkcutlass-keygenwindow.c - handle the key generation window poop.
* 
* thanatos@hoodlum.org
*/

// first stab - 08/15/04 - Finland :)

#include <gtkcutlass.h>
#include <gtkcutlass-utilities.h>

gint newkeykeylength = 0;
gchar *newkeypassphrase = NULL;
gint counter = 0;
GladeXML * NewContactWindowXML;

void keygen_callback( void *foo )
{
    GtkProgressBar * pb;
    pb = GTK_PROGRESS_BAR( glade_xml_get_widget( NewContactWindowXML, "newkeygenprogressbar" ) );
    if ( pb == NULL )
        g_print( "nope" );
    counter++;
    if ( ( counter % 1000 ) == 0 )
    {
        while ( gtk_events_pending() )
            gtk_main_iteration();
        gtk_progress_bar_pulse( pb );
    }
}

gint run_keygen_dialog( void )
{
    GtkComboBox * combo;

    NewContactWindowXML = ( GladeXML * ) glade_xml_new (GTK_CUTLASS_GLADEDIR "gtkcutlass.glade", "keygenwindow", NULL );
    if ( NewContactWindowXML == NULL )
        g_error( "Couldn't create window for key generation (gtkcutlass.glade not found?)" );
    combo = GTK_COMBO_BOX( glade_xml_get_widget( NewContactWindowXML, "newkeygenkeylengthcombobox" ) );
    if ( combo == NULL )
        g_error ( "couldn't set default keylength\n" );
    gtk_combo_box_set_active ( combo, 0 );
    newkeykeylength = 1024;
    glade_xml_signal_autoconnect( NewContactWindowXML ) ;
    gtk_widget_destroy( ( GtkWidget * ) NewContactWindowXML );
    return ( 0 );
}

void on_newkeygenpassphrase_changed ( GtkWidget *widget, gpointer user_data )
{
    if ( newkeypassphrase != NULL )
        g_free( newkeypassphrase );
    newkeypassphrase = ( gchar * ) g_strdup( gtk_entry_get_text( ( GtkEntry * ) widget ) );
}

void on_newkeygenokbutton_clicked ( GtkWidget *widget, gpointer user_data )
{
    extern user_info * userstuff;
    extern gui_status *currentstatus;
    gint x = 0;

    if ( newkeypassphrase == NULL )
    {
        tellem( "Must enter passphrase" );
        return ;
    }
    if ( g_utf8_strlen( newkeypassphrase, 1024 ) <= 1 )
    {
        tellem( "Must enter passphrase" );
        return ;
    }
    /*	if (g_utf8_strlen(newkeypassphrase,1024) <= 8)
    	{
    		tellem("Insufficient passphrase length.\n Please enter a longer passphrase.\n ( >8 Characters)");
    		return;
    	}
    */ 
    // well, here goes.
    userstuff->keylength = newkeykeylength;
    userstuff->key_passphrase = g_strdup( newkeypassphrase );
    g_free( newkeypassphrase );
    userstuff->key = generate_rsa_key( userstuff->keylength, keygen_callback, widget );
    // FIXME: we should verify that the key was generated correctly. (somehow)

    if ( save_user_info() != 0 )
    {
        tellem ( "Saving user info failed." );
        return ;
    }
    if ( save_user_key() != 0 )
    {
        tellem ( "Saving user key failed." );
        return ;
    }
    // the only interface we have for inserting keys into the cutlass_t structure is from the disk.
    // so, that's how we'll load it.
    userstuff->key = load_private_key( get_key_save_file_name(), passphrase_dialog_wrapper );
    if ( userstuff->key.key == NULL )
        g_error ( "failure in key manipulation" );


    cutlass_register_action( userstuff->cutlass_info, CUT_USER_CONN, gtkcutlass_conn_finish_handler );
    cutlass_register_action( userstuff->cutlass_info, CUT_USER_CONN_REQ, gtkcutlass_conn_new_incoming_handler );
    cutlass_register_action( userstuff->cutlass_info, CUT_USER_DROP, gtkcutlass_drop_handler );
    cutlass_register_action( userstuff->cutlass_info, CUT_USER_TIMEOUT, gtkcutlass_timeout_handler );

    cutlass_register_action( userstuff->cutlass_info, CUT_MSG_RECV, gtkcutlass_message_handler );

    cutlass_register_action( userstuff->cutlass_info, CUT_GRP_JOIN, gtkcutlass_group_join_handler );
    cutlass_register_action( userstuff->cutlass_info, CUT_GRP_JOIN_REQ, gtkcutlass_group_join_req_handler );
    cutlass_register_action( userstuff->cutlass_info, CUT_GRP_INVITE, gtkcutlass_group_invite_handler );
    cutlass_register_action( userstuff->cutlass_info, CUT_GRP_LEAVE, gtkcutlass_group_leave_handler );

    cutlass_register_action( userstuff->cutlass_info, CUT_FILE_OFFER, gtkcutlass_file_offer_handler );
    cutlass_register_action( userstuff->cutlass_info, CUT_FILE_ACCEPT, gtkcutlass_file_accept_handler );
    cutlass_register_action( userstuff->cutlass_info, CUT_FILE_SEND_DONE, gtkcutlass_file_send_done_handler );
    cutlass_register_action( userstuff->cutlass_info, CUT_FILE_RECV_DONE, gtkcutlass_file_recv_done_handler );

    cutlass_register_action( userstuff->cutlass_info, CUT_SND_OFFER, gtkcutlass_sound_offer_handler );
    cutlass_register_action( userstuff->cutlass_info, CUT_SND_ACCEPT, gtkcutlass_sound_accept_handler );
    cutlass_register_action( userstuff->cutlass_info, CUT_SND_DONE, gtkcutlass_sound_done_handler );

    cutlass_register_action( userstuff->cutlass_info, CUT_SYS_MSG, gtkcutlass_system_message_handler );

    //    cutlass_set_capabilities ( userstuff->cutlass_info, CAN_RECV_MSGS| CAN_RECV_FILES );


    if ( userstuff->textcapable )
        cutlass_set_permission ( userstuff->cutlass_info, CAN_RECV_MSGS, ALL_ALLOWED );
    if ( userstuff->videocapable )
        cutlass_set_permission ( userstuff->cutlass_info, CAN_RECV_VIDEO, USER_ALLOW_CHECK );
    if ( userstuff->audiocapable )
        cutlass_set_permission ( userstuff->cutlass_info, CAN_RECV_AUDIO, ALL_ALLOWED );
    if ( userstuff->fileserver )
        cutlass_set_permission ( userstuff->cutlass_info, CAN_RECV_FILES, userstuff->file_permissions );

    if ( application_crankup( userstuff, currentstatus ) != 0 )
        g_error( "general error starting cutlass - aborting\n" );

    if ( cutlass_set_private_key ( userstuff->cutlass_info, userstuff->key ) != 0 )
        g_error ( "Failure setting user private key" );

    g_print ( "Initializing Cutlass\n" );
    if ( ( x = cutlass_start( userstuff->cutlass_info ) ) != 0 )
    {
        g_print ( "problem starting cutlass : cutlass_start returned %d\n", x );
        g_error ( "Error initializing Cutlass" );
    }

    if ( cutlass_set_verbose ( userstuff->cutlass_info, userstuff->verbosity ) != 0 )
        g_warning ( "Error setting cutlass verbosity\n" );

    currentstatus->newdude = FALSE;
    currentstatus->unsavedchanges = FALSE;

    if ( userstuff->defaultalias != NULL )
    {
        if ( cutlass_set_nick ( userstuff->cutlass_info, userstuff->defaultalias ) != 0 )
            g_warning ( "Couldn't set nick (alias)" );
    }
    else
    {
        if ( cutlass_set_nick ( userstuff->cutlass_info, userstuff->myname ) != 0 )
            g_warning ( "Counldn't set nick - realname" );
    }

    gtk_widget_destroy( gtk_widget_get_toplevel( widget ) );
}

void on_keygenwindow_delete_event ( GtkWidget *widget, gpointer user_data )
{
    tellem( "You must generate a key to use Cutlass - Exiting" );
    gtk_widget_destroy( gtk_widget_get_toplevel( widget ) );
    gtk_main_quit();
}
void on_keygenwindow_destroy_event ( GtkWidget *widget, gpointer user_data )
{
    tellem( "You must generate a key to use Cutlass - Exiting" );
    gtk_widget_destroy( gtk_widget_get_toplevel( widget ) );
    gtk_main_quit();
}

void on_newkeygenkeylengthcombobox_changed ( GtkWidget *widget, gpointer user_data )
{
    switch ( gtk_combo_box_get_active( GTK_COMBO_BOX( widget ) ) )
    {
        case 0:
            {
                newkeykeylength = 1024;
                break;
            }
        case 1:
            {
                newkeykeylength = 2048;
                break;
            }
        case 2:
            {
                newkeykeylength = 4096;
                break;
            }
        default:
            break;
    }

}
void on_newkeygeneratecancelbutton_clicked ( GtkWidget *widget, gpointer user_data )
{
    // LEAK! LEAK! FIXME
    tellem( "You must generate a key to use Cutlass - Exiting" );
    gtk_widget_destroy( gtk_widget_get_toplevel( widget ) );
    gtk_main_quit();
}