/*
 * dbMetrix Database Tool v0.1
 * Copyright (c) 1998 David E. Storey <dave@tamos.net>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */

#include <gtk/gtk.h>
#include "config.h"
#include "global.h"

#include <string.h>

/* prototypes */
void dbx_shutdown(GtkWidget *widget, gpointer data);

/* variables */
ds_menus *dsMenus = NULL;
ds_funcs *dsFuncs = NULL;

void (*dsInit[])(void) = {
    NULL
#ifdef HAVE_MYSQL
    , init_MySQL
#endif
#ifdef HAVE_MSQL
    , init_mSQL
#endif
#ifdef HAVE_PGSQL
    , init_pgSQL
#endif
#ifdef HAVE_ORACLE
    , init_Oracle
#endif
#ifdef HAVE_SOLID
    , init_Solid
#endif
};

int ds_total = sizeof(dsInit)/sizeof(dsInit[0]);

GtkWidget *mainWindow;
GtkWidget *dbTree;
GtkWidget *qbNotebook;
GtkWidget *Toolbar;
GtkWidget *menuBar;
GtkWidget *statusBar;

void
dbx_about_dialog()
{
    GtkWidget *dWindow;
    GtkWidget *hbox;
    GtkWidget *vbox;
    GtkWidget *button;
    GtkWidget *label;
    GtkWidget *logo;
    GtkStyle *style;
    GdkPixmap *pixmap;
    GdkBitmap *mask;
    char buff[256];

#include "icons/logo.xpm"

    dWindow = gtk_dialog_new();
    gtk_window_set_title(GTK_WINDOW(dWindow), "About dbMetrix");
    gtk_widget_set_usize(GTK_DIALOG(dWindow)->action_area, -1, 32);
    gtk_container_border_width(GTK_CONTAINER(GTK_DIALOG(dWindow)->action_area), 4);
    gtk_container_border_width(GTK_CONTAINER(GTK_DIALOG(dWindow)->vbox), 4);
    gtk_widget_show(dWindow);

    button = gtk_button_new_with_label("Cancel");
    gtk_signal_connect_object(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(dWindow));
    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dWindow)->action_area), button, TRUE, TRUE, 0);
    gtk_widget_show(button);

    hbox = gtk_hbox_new(FALSE, 0);
    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dWindow)->vbox), hbox, TRUE, TRUE, 0);
    gtk_widget_show(hbox);

    /* logo! */
    style = gtk_widget_get_style(dWindow);
    pixmap = gdk_pixmap_create_from_xpm_d(dWindow->window, &mask, &style->bg[GTK_STATE_NORMAL], (char **)logo_xpm);
    logo = gtk_pixmap_new(pixmap, mask);
    gtk_box_pack_start(GTK_BOX(hbox), logo, TRUE, TRUE, 0);
    gtk_widget_show(logo);

    vbox = gtk_vbox_new(FALSE, 0);
    gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
    gtk_widget_show(vbox);

    g_snprintf(buff, 256, "dbMetrix v%d.%d.%d", MAJOR_VERSION, MINOR_VERSION, PATCH_VERSION);
    label = gtk_label_new(buff);
    gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0);
    gtk_widget_show(label);

    label = gtk_label_new("by David E. Storey");
    gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0);
    gtk_widget_show(label);

}

void
dbx_addDataSource_clicked(GtkWidget *widget, gpointer data)
{
    GtkWidget *notebook;
    int curpage;
    char pagekey[8];
    dsClass ds_class;

    notebook = get_widget(widget, "notebook");
    curpage = gtk_notebook_current_page(GTK_NOTEBOOK(notebook));
    g_snprintf(pagekey, 8, "%d", curpage);
    ds_class = (dsClass)gtk_object_get_data(GTK_OBJECT(widget), pagekey);

    if (dsFuncs[ds_class].create_dsEntry)
        dsFuncs[ds_class].create_dsEntry(widget);

    gtk_widget_destroy(widget);
}

void
dbx_addDataSource_dialog(GtkWidget *widget, gpointer data)
{
    GtkWidget *dWindow;
    GtkWidget *button;
    GtkWidget *notebook;
    int curpage = 0;
    int i = 0;

    /* dialog as a whole */
    dWindow = gtk_dialog_new();
    gtk_window_set_title(GTK_WINDOW(dWindow), "Add Data Source");
    gtk_container_border_width(GTK_CONTAINER(GTK_DIALOG(dWindow)->action_area), 2);
    gtk_container_border_width(GTK_CONTAINER(GTK_DIALOG(dWindow)->vbox), 4);

    /* action area buttons */
    button = gtk_button_new_with_label("Connect");
    gtk_signal_connect_object(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(dbx_addDataSource_clicked), GTK_OBJECT(dWindow));
    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dWindow)->action_area), button, TRUE, TRUE, 0);
    GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
    gtk_widget_grab_default(button);
    gtk_widget_show(button);

    button = gtk_button_new_with_label("Cancel");
    gtk_signal_connect_object(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(dWindow));
    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dWindow)->action_area), button, TRUE, TRUE, 0);
    GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
    gtk_widget_show(button);

    /* notebook */
    notebook = gtk_notebook_new();
    gtk_object_set_data(GTK_OBJECT(dWindow), "notebook", notebook);
    gtk_notebook_set_show_border(GTK_NOTEBOOK(notebook), FALSE);
    gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), TRUE);
    gtk_notebook_set_tab_border(GTK_NOTEBOOK(notebook), 2);
    gtk_notebook_popup_enable(GTK_NOTEBOOK(notebook));
    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dWindow)->vbox), notebook, TRUE, TRUE, 0);
    gtk_widget_show(notebook);

    /* data source notebook pages */
    for (i = 0; i < ds_total; i++)
        if (dsFuncs[i].create_dsDialog)
            dsFuncs[i].create_dsDialog(dWindow, notebook, &curpage);

    gtk_widget_show(dWindow);
}

GtkWidget *
create_main_window(void)
{
    GtkWidget *vBox;
    GtkWidget *HandleBox;
    GtkWidget *hPane;
    GtkWidget *scrollbars;
    GtkWidget *menu;
    GtkWidget *frame;

    dbxMenuEntry menuItemsFile[] = {
        {"New data source...", "<control>O", DBX_SIGNAL_FUNC(dbx_addDataSource_dialog), NULL},
        {NULL, NULL, NULL, NULL},
        {"Preferences...", NULL, NULL, NULL},
        {NULL, NULL, NULL, NULL},
        {"Quit", "<control>Q", DBX_SIGNAL_FUNC(dbx_shutdown), NULL}
    };
    
    dbxMenuEntry menuItemsQuery[] = {
        {"New", NULL, DBX_SIGNAL_FUNC(query_new), NULL},
        {"Open", NULL, DBX_SIGNAL_FUNC(query_open), NULL},
        {"Save", NULL, DBX_SIGNAL_FUNC(query_save), NULL},
        {"Save As...", NULL, DBX_SIGNAL_FUNC(query_save_as), NULL},
        {"Close", NULL, DBX_SIGNAL_FUNC(query_close), NULL},
        {NULL, NULL, NULL, NULL},
        {"Execute", NULL, DBX_SIGNAL_FUNC(query_execute), NULL}
    };

    dbxMenuEntry menuItemsHelp[] = {
        {"About", NULL, DBX_SIGNAL_FUNC(dbx_about_dialog), NULL}
    };

    mainWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(mainWindow), "dbMetrix");
    gtk_signal_connect (GTK_OBJECT(mainWindow), "destroy", GTK_SIGNAL_FUNC (dbx_shutdown), NULL);

    vBox = gtk_vbox_new(FALSE, 0);
    gtk_container_add(GTK_CONTAINER(mainWindow), vBox);
    gtk_widget_show(vBox);

    /* menuBar */
    menuBar = gtk_menu_bar_new();
    gtk_box_pack_start(GTK_BOX(vBox), menuBar, FALSE, TRUE, 0);
    gtk_widget_show(menuBar);

    menu = set_menu(menuItemsFile, sizeof(menuItemsFile)/sizeof(menuItemsFile[0]));
    add_to_menu_bar(menuBar, menu, "File", FALSE);

    menu = set_menu(menuItemsQuery, sizeof(menuItemsQuery)/sizeof(menuItemsQuery[0]));
    add_to_menu_bar(menuBar, menu, "Query", FALSE);

    menu = set_menu(menuItemsHelp, sizeof(menuItemsHelp)/sizeof(menuItemsHelp[0]));
    add_to_menu_bar(menuBar, menu, "Help", TRUE);

    /* Toolbar/HandleBox */
    HandleBox = gtk_handle_box_new();
    gtk_box_pack_start(GTK_BOX(vBox), HandleBox, FALSE, TRUE, 0);
    gtk_widget_show(HandleBox);

    Toolbar = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
    gtk_toolbar_append_item(GTK_TOOLBAR(Toolbar), "Connect", "Connect to data source", "private text?",
                            NULL, GTK_SIGNAL_FUNC(dbx_addDataSource_dialog), NULL);
    gtk_toolbar_append_space(GTK_TOOLBAR(Toolbar));
    gtk_toolbar_append_item(GTK_TOOLBAR(Toolbar), "Execute", "Execute current query", "private text?",
                            NULL, GTK_SIGNAL_FUNC(query_execute), NULL);
    gtk_toolbar_append_item(GTK_TOOLBAR(Toolbar), "New", "Create new query", "private text?",
                            NULL, GTK_SIGNAL_FUNC(query_new), NULL);
    gtk_toolbar_append_item(GTK_TOOLBAR(Toolbar), "Open", "Open saved query", "private text?",
                            NULL, GTK_SIGNAL_FUNC(query_open), NULL);
    gtk_toolbar_append_item(GTK_TOOLBAR(Toolbar), "Save", "Save current query", "private text?",
                            NULL, GTK_SIGNAL_FUNC(query_save), NULL);
    gtk_toolbar_append_item(GTK_TOOLBAR(Toolbar), "Close", "Close current query", "private text?",
                            NULL, GTK_SIGNAL_FUNC(query_close), NULL);
    gtk_container_add (GTK_CONTAINER (HandleBox), Toolbar);
    gtk_widget_show(Toolbar);

    /* horizontal pane */
    hPane = gtk_hpaned_new();
    gtk_container_border_width(GTK_CONTAINER(hPane), 1);
    gtk_box_pack_start(GTK_BOX(vBox), hPane, TRUE, TRUE, 0);
    gtk_widget_show(hPane);

    /* Tree View */
    frame = gtk_frame_new("Data Source");
    gtk_container_add(GTK_CONTAINER(hPane), frame);
    gtk_widget_show(frame);

    scrollbars = gtk_scrolled_window_new(NULL, NULL);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollbars), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
    gtk_container_border_width(GTK_CONTAINER(scrollbars), 1);
    gtk_container_add(GTK_CONTAINER(frame), scrollbars);
    gtk_widget_show(scrollbars);

    dbTree = gtk_tree_new();
    GTK_TREE(dbTree)->root_tree = GTK_TREE(dbTree);
    gtk_container_add(GTK_CONTAINER(scrollbars), dbTree);
    gtk_widget_show(dbTree);

    /* Notebook */
    qbNotebook = gtk_notebook_new();
    gtk_notebook_set_show_border(GTK_NOTEBOOK(qbNotebook), FALSE);
    gtk_container_add(GTK_CONTAINER(hPane), qbNotebook);
    gtk_widget_show(qbNotebook);

    /* Query Tab */
    query_new(NULL, NULL);

    /* Status Bar */
    statusBar = gtk_statusbar_new();
    gtk_statusbar_push(GTK_STATUSBAR(statusBar), 1, "Ready");
    gtk_box_pack_start(GTK_BOX(vBox), statusBar, FALSE, TRUE, 0);
    gtk_widget_show(statusBar);

    gtk_widget_show(mainWindow);
    return(mainWindow);
}

void
ds_close(gpointer widget, gpointer data)
{
    char message[256];
    GtkWidget *treeItem = data ? gtk_object_get_data(GTK_OBJECT(dbTree), "selected") : (GtkWidget *)widget;
    node_ds *nodeInfo = (node_ds *)gtk_object_get_data(GTK_OBJECT(treeItem), "info");
    dataSource *conn = nodeInfo ? nodeInfo->conn : (dataSource *)gtk_object_get_data(GTK_OBJECT(treeItem), "conn");

    if (data)
    {
        g_snprintf(message, 256, "Disconnected from %s", conn->name);
        gtk_object_remove_data(GTK_OBJECT(dbTree), conn->name);
        ds_prune_tree((gpointer)treeItem, NULL);
    }

    /* remove key from dbTree */
    gtk_object_remove_data(GTK_OBJECT(dbTree), conn->name);

    /* close data source */
    if (dsFuncs[conn->class].close)
        dsFuncs[conn->class].close(conn);

    conn->connected = FALSE;
    g_free(conn->name);
    g_free(conn->info);
    g_free(conn);

    if (data)
        s_print(message);
}

void
dbx_shutdown(GtkWidget *widget, gpointer data)
{
    g_list_foreach(GTK_TREE(dbTree)->children, ds_close, NULL);

    if (dsMenus)
        free(dsMenus);

    gtk_main_quit();
}

void
ds_init(GtkWidget *mWindow)
{
    int i;

    dsMenus = (ds_menus *)calloc(ds_total, sizeof(ds_menus));
    dsFuncs = (ds_funcs *)calloc(ds_total, sizeof(ds_funcs));

    for (i = 0; i < ds_total; i++)
    {
        /* initialize menus */
        dsMenus[i].host = NULL;
        dsMenus[i].database = NULL;
        dsMenus[i].table = NULL;

        dsFuncs[i].close = NULL;
        dsFuncs[i].create_db = NULL;
        dsFuncs[i].create_dsEntry = NULL;
        dsFuncs[i].create_dsDialog = NULL;
        dsFuncs[i].drop_db = NULL;
        dsFuncs[i].exec_query = NULL;
        dsFuncs[i].export = NULL;
        dsFuncs[i].refresh = NULL;

        /* initialize functions */
        if (dsInit[i])
            dsInit[i]();
    }
}

void
pass_change(GtkWidget *widget, gpointer data)
{
    char *hidden = (char *)data;
    char *entry = gtk_entry_get_text(GTK_ENTRY(widget));
    int entrylen = strlen(entry);
    int hiddenlen = strlen(hidden);
    int diff = entrylen - hiddenlen;

    if (diff > 0)
    {
        int i = 0;
        char tmp[256];
        strcpy(&hidden[hiddenlen], &entry[hiddenlen]);
        for (i = 0; i < entrylen; i++)
            tmp[i] = '*';
        tmp[i] = '\0';
        gtk_entry_set_text(GTK_ENTRY(widget), tmp);
    }

    if (diff < 0)
        hidden[entrylen] = '\0';
}

void
pass_destroy(GtkWidget *widget, gpointer data)
{
    g_free(data);
}

void
create_dialogs(GtkWidget *dWindow,
               GtkWidget *notebook,
               int *curpage,
               dsClass ds_class,
               char *tabtext,
               dbx_Dialog *entries,
               int nentries)
{
    GtkWidget *tLayout;
    GtkWidget *label;
    GtkWidget *entry;
    GtkWidget *combo1;
    GList *combo1_items = NULL;
    int i;

    tLayout = gtk_table_new(nentries + 1, 2, FALSE);
    gtk_table_set_row_spacings(GTK_TABLE(tLayout), 1);
    gtk_table_set_col_spacings(GTK_TABLE(tLayout), 3);
    gtk_widget_show(tLayout);

    if (notebook && curpage)
    {
        char pagekey[8];
        label = gtk_label_new(tabtext);
        g_snprintf(pagekey, 8, "%d", (*curpage)++);
        gtk_object_set_data(GTK_OBJECT(dWindow), pagekey, (gpointer)ds_class);
        gtk_notebook_append_page(GTK_NOTEBOOK(notebook), tLayout, label);
    } else
        gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dWindow)->vbox), tLayout, FALSE, TRUE, 0);

    for (i = 0; i < nentries; i++)
    {
        label = gtk_label_new(entries[i].text);
        gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
        gtk_table_attach(GTK_TABLE(tLayout), label, 0, 1, i + 1, i + 2, GTK_FILL, GTK_FILL, 0, 0);
        gtk_widget_show(label);

        Gentry[i] = entry = gtk_entry_new();
        if (entries[i].pass)
        {
            char *hidden = (char *)g_malloc(256);
            Ghidden = hidden;
            hidden[0] = '\0';
            gtk_object_set_data(GTK_OBJECT(dWindow), entries[i].dbKey, hidden);
            gtk_signal_connect(GTK_OBJECT(entry), "changed", GTK_SIGNAL_FUNC(pass_change), hidden);
            gtk_signal_connect(GTK_OBJECT(entry), "destroy", GTK_SIGNAL_FUNC(pass_destroy), hidden);
        } else
            gtk_object_set_data(GTK_OBJECT(dWindow), entries[i].dbKey, entry);
        gtk_table_attach(GTK_TABLE(tLayout), entry, 1, 2, i + 1, i + 2, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
        gtk_widget_show(entry);
    }

    label = gtk_label_new("Alias:");
    gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);
    gtk_table_attach(GTK_TABLE(tLayout), label, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
    gtk_widget_show(label);

    load_db_alias();
    combo1 = gtk_combo_new ();
    gtk_object_set_data (GTK_OBJECT (dWindow), "combo1", combo1);
    gtk_table_attach(GTK_TABLE(tLayout), combo1, 1, 2, 0, 1, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
    gtk_widget_show (combo1);
    for (i = 0; i < cntAlias; i++) {
        combo1_items = g_list_append (combo1_items, infAlias[i].alias);
    }
    gtk_signal_connect (GTK_OBJECT (GTK_COMBO (combo1)->entry), "changed",
                        GTK_SIGNAL_FUNC (on_combo1_activate),
                        NULL);
    gtk_combo_set_popdown_strings (GTK_COMBO (combo1), combo1_items);
    g_list_free (combo1_items);
}

int
main(int argc, char *argv[])
{
    GtkWidget *mWindow;
    gtk_init(&argc, &argv);
    pref_init(argc, argv);

    mWindow = create_main_window();
    ds_init(mWindow);
    gtk_main();

    g_print("normal termination.\n");
    return(0);
}