/*
 * LPC 2000 Loader, http://www.pjrc.com/arm/lpc2k_pgm
 * Copyright (c) 2004, PJRC.COM, LLC, <paul@pjrc.com>
 *
 * 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; version 2 of the License.
 *
 * 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.
 */

/* If this code fails to build, please provide at least the following
 * information when requesting (free) technical support.
 *
 * 1: Complete copy of all messages during the build.
 * 2: Output of "gtk-config --version"
 * 3: Output of "gtk-config --libs"
 * 4: Output of "gtk-config --cflags"
 * 5: Output of "uname -a"
 * 6: Version of GTK installed... eg, type: ls -l /lib/libgtk*
 * 7: Other info... which linux distribution, version, other software
 */


#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <gtk/gtk.h>
#include <sys/types.h>
#include <sys/stat.h>

#include "gui.h"
#include "settings.h"
#include "serial.h"
#include "lpc2k_pgm.h"
#include "download.h"


static GtkWidget *firmware_label, *firmware_entry, *program_button;
static GtkWidget *port_label, *port_entry, *baud_label, *baud_combo;
static GtkWidget *crystal_label, *crystal_entry, *mhz_label;
static GtkWidget *reboot_button, *bootloader_button, *quit_button;
static GtkWidget *line1_hbox, *line2_hbox, *line3_hbox, *line4_hbox;
static GtkWidget *main_vbox, *main_window;

static int port_timeout = 0;
static int baud_timeout = 0;
static int download_in_progress = 0;

gint do_quit(GtkWidget *widget, gpointer *data)
{
    gtk_main_quit();
    return FALSE;
}

gint do_program(GtkWidget *widget, gpointer *data)
{
    if (download_in_progress) {
        // error... not supposed to get here
        gtk_widget_set_sensitive(program_button, FALSE);
        return FALSE;
    }

    download_in_progress = 1;
    gtk_widget_set_sensitive(program_button, FALSE);
    gtk_widget_set_sensitive(reboot_button, FALSE);
    gtk_widget_set_sensitive(bootloader_button, TRUE);
    download_begin();
    return FALSE;
}

int file_exists(const char *filename)
{
    struct stat file_stats;
    int r;

    r = stat(filename, &file_stats);

    if (r != 0) {
        return 0;
    }

    if (!S_ISREG(file_stats.st_mode)) {
        return 0;
    }

    return 1;
}

void done_program(int still_in_bootloader)
{
    download_in_progress = 0;

    if (file_exists(gtk_entry_get_text(GTK_ENTRY(firmware_entry)))) {
        gtk_widget_set_sensitive(program_button, TRUE);
    }
    else {
        gtk_widget_set_sensitive(program_button, FALSE);
    }

    gtk_widget_set_sensitive(bootloader_button, TRUE);
    gtk_widget_set_sensitive(reboot_button, TRUE);
}

gint do_reboot(GtkWidget *widget, gpointer *data)
{
    if (download_in_progress) {
        download_cancel(NULL);
        gtk_widget_set_sensitive(program_button, FALSE);
        gtk_widget_set_sensitive(reboot_button, FALSE);
        gtk_widget_set_sensitive(bootloader_button, FALSE);
    }

    gtk_widget_set_sensitive(program_button, FALSE);
    gtk_widget_set_sensitive(reboot_button, FALSE);
    gtk_widget_set_sensitive(bootloader_button, FALSE);

    hard_reset_to_user_code();

#if 0
    download_in_progress = 1;
    soft_reboot_begin();
#endif

    if (file_exists(gtk_entry_get_text(GTK_ENTRY(firmware_entry)))) {
        gtk_widget_set_sensitive(program_button, TRUE);
    }
    else {
        gtk_widget_set_sensitive(program_button, FALSE);
    }

    gtk_widget_set_sensitive(bootloader_button, TRUE);
    return FALSE;
}

gint do_bootloader(GtkWidget *widget, gpointer *data)
{
    if (download_in_progress) {
        download_cancel(NULL);
        gtk_widget_set_sensitive(program_button, FALSE);
        gtk_widget_set_sensitive(reboot_button, FALSE);
        gtk_widget_set_sensitive(bootloader_button, FALSE);
    }

    hard_reset_to_bootloader();

    if (file_exists(gtk_entry_get_text(GTK_ENTRY(firmware_entry)))) {
        gtk_widget_set_sensitive(program_button, TRUE);
    }
    else {
        gtk_widget_set_sensitive(program_button, FALSE);
    }

    gtk_widget_set_sensitive(reboot_button, TRUE);
    gtk_widget_set_sensitive(bootloader_button, TRUE);
    return FALSE;
}

gint do_new_port(GtkWidget *widget, gpointer *data)
{
    port_timeout = 12;
    return FALSE;
}

gint do_new_baud(GtkWidget *widget, gpointer *data)
{
    baud_timeout = 7;
    return FALSE;
}

gint do_new_file(GtkWidget *widget, gpointer *data)
{
    const char *filename;

    filename = gtk_entry_get_text(GTK_ENTRY(firmware_entry));

    if (file_exists(filename)) {
        new_file_setting(filename);

        if (download_in_progress) {
            gtk_widget_set_sensitive(program_button, FALSE);
        }
        else {
            gtk_widget_set_sensitive(program_button, TRUE);
        }
    }
    else {
        gtk_widget_set_sensitive(program_button, FALSE);
    }

    return FALSE;
}

gint do_new_crystal(GtkWidget *widget, gpointer *data)
{
    const char *xtal;

    xtal = gtk_entry_get_text(GTK_ENTRY(crystal_entry));
    new_crystal_setting(xtal);
    return FALSE;
}


gint do_timer(gpointer data)
{
    if (port_timeout && --port_timeout == 0) {
        open_serial_port(gtk_entry_get_text(GTK_ENTRY(port_entry)));
    }

    if (baud_timeout && --baud_timeout == 0) {
        change_baud(gtk_entry_get_text(GTK_ENTRY(
                                           GTK_COMBO(baud_combo)->entry)));
    }

    if (download_in_progress) {
        download_timer();
    }

    return TRUE;
}

void do_term_input(gpointer data, int fd, GdkInputCondition cond)
{
    char buf[256];
    int num, flags;

    flags = fcntl(term_fd, F_GETFL);
    fcntl(term_fd, F_SETFL, flags | O_NONBLOCK);
    num = read(term_fd, buf, sizeof(buf));
    fcntl(term_fd, F_SETFL, flags);

    if (num > 0) {
        if (download_in_progress) {
            download_rx_term(buf, num);
        }
        else {
            write_serial_port(buf, num);
        }
    }
}

void do_port_input(gpointer data, int fd, GdkInputCondition cond)
{
    char buf[256];
    int num;

    num = read_serial_port_nb((unsigned char *)buf, sizeof(buf));

    if (num > 0) {
        if (download_in_progress) {
            download_rx_port(buf, num);
        }
        else {
            write(term_fd, buf, num);
        }
    }
}


void run_gui(void)
{
    gtk_signal_connect(GTK_OBJECT(main_window), "delete_event",
                       GTK_SIGNAL_FUNC(do_quit), NULL);
    gtk_signal_connect(GTK_OBJECT(quit_button), "pressed",
                       GTK_SIGNAL_FUNC(do_quit), NULL);
    gtk_signal_connect(GTK_OBJECT(port_entry), "changed",
                       GTK_SIGNAL_FUNC(do_new_port), NULL);
    gtk_signal_connect(GTK_OBJECT(GTK_COMBO(baud_combo)->entry), "changed",
                       GTK_SIGNAL_FUNC(do_new_baud), NULL);
    gtk_signal_connect(GTK_OBJECT(firmware_entry), "changed",
                       GTK_SIGNAL_FUNC(do_new_file), NULL);
    gtk_signal_connect(GTK_OBJECT(crystal_entry), "changed",
                       GTK_SIGNAL_FUNC(do_new_crystal), NULL);
    gtk_signal_connect(GTK_OBJECT(program_button), "pressed",
                       GTK_SIGNAL_FUNC(do_program), NULL);
    gtk_signal_connect(GTK_OBJECT(reboot_button), "pressed",
                       GTK_SIGNAL_FUNC(do_reboot), NULL);
    gtk_signal_connect(GTK_OBJECT(bootloader_button), "pressed",
                       GTK_SIGNAL_FUNC(do_bootloader), NULL);

    gtk_timeout_add(100, do_timer, NULL);
    gdk_input_add(term_fd, GDK_INPUT_READ, do_term_input, NULL);
    gdk_input_add(serial_port_fd(), GDK_INPUT_READ, do_port_input, NULL);

    gtk_main();
}


void create_window(int *argc, char ***argv)
{
    GList *gtk_baud_list = NULL;
    int i;

    gtk_init(argc, argv);

    firmware_label = gtk_label_new("Firmware:");
    gtk_label_set_justify(GTK_LABEL(firmware_label), GTK_JUSTIFY_RIGHT);
    gtk_widget_show(firmware_label);

    firmware_entry = gtk_entry_new();
    gtk_widget_set_usize(firmware_entry, 110, 0);
    gtk_entry_set_text(GTK_ENTRY(firmware_entry), file_setting());
    gtk_widget_show(firmware_entry);

    program_button = gtk_button_new_with_label("Program Now");

    if (file_exists(file_setting())) {
        gtk_widget_set_sensitive(program_button, TRUE);
    }
    else {
        gtk_widget_set_sensitive(program_button, FALSE);
    }

    gtk_widget_show(program_button);

    line1_hbox = gtk_hbox_new(FALSE, 2);
    gtk_box_pack_start(GTK_BOX(line1_hbox), firmware_label, FALSE, FALSE, 2);
    gtk_box_pack_start(GTK_BOX(line1_hbox), firmware_entry, TRUE, TRUE, 2);
    gtk_box_pack_start(GTK_BOX(line1_hbox), program_button, FALSE, FALSE, 2);
    gtk_widget_show(line1_hbox);


    port_label = gtk_label_new("Port:");
    gtk_label_set_justify(GTK_LABEL(port_label), GTK_JUSTIFY_RIGHT);
    gtk_widget_show(port_label);

    port_entry = gtk_entry_new();
    gtk_widget_set_usize(port_entry, 80, 0);
    gtk_entry_set_text(GTK_ENTRY(port_entry), port_setting());
    open_serial_port(port_setting());
    gtk_widget_show(port_entry);

    baud_label = gtk_label_new("Baud:");
    gtk_label_set_justify(GTK_LABEL(baud_label), GTK_JUSTIFY_RIGHT);
    gtk_widget_show(baud_label);

    baud_combo = gtk_combo_new();

    for (i = 0; baud_list[i] != NULL; i++) {
        gtk_baud_list = g_list_append(gtk_baud_list, baud_list[i]);
    }

    gtk_combo_set_popdown_strings(GTK_COMBO(baud_combo), gtk_baud_list);
    gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(baud_combo)->entry), FALSE);
    gtk_widget_set_usize(baud_combo, 75, 0);

    for (i = 0; baud_list[i] != NULL; i++) {
        if (strcmp(baud_list[i], baud_setting()) == 0) {
            gtk_list_select_item(GTK_LIST(GTK_COMBO(baud_combo)->list), i);
            break;
        }
    }

    gtk_widget_show(baud_combo);

    line2_hbox = gtk_hbox_new(FALSE, 2);
    gtk_box_pack_start(GTK_BOX(line2_hbox), port_label, FALSE, FALSE, 2);
    gtk_box_pack_start(GTK_BOX(line2_hbox), port_entry, TRUE, TRUE, 2);
    gtk_box_pack_start(GTK_BOX(line2_hbox), baud_label, FALSE, FALSE, 2);
    gtk_box_pack_start(GTK_BOX(line2_hbox), baud_combo, FALSE, FALSE, 2);
    gtk_widget_show(line2_hbox);


    crystal_label = gtk_label_new("Crystal:");
    gtk_label_set_justify(GTK_LABEL(crystal_label), GTK_JUSTIFY_RIGHT);
    gtk_widget_show(crystal_label);

    crystal_entry = gtk_entry_new();
    gtk_widget_set_usize(crystal_entry, 80, 0);
    gtk_entry_set_text(GTK_ENTRY(crystal_entry), crystal_setting());
    gtk_widget_show(crystal_entry);

    mhz_label = gtk_label_new("(MHz)");
    gtk_label_set_justify(GTK_LABEL(mhz_label), GTK_JUSTIFY_LEFT);
    gtk_widget_show(mhz_label);

    line3_hbox = gtk_hbox_new(FALSE, 2);
    gtk_box_pack_start(GTK_BOX(line3_hbox), crystal_label, FALSE, FALSE, 2);
    gtk_box_pack_start(GTK_BOX(line3_hbox), crystal_entry, TRUE, TRUE, 2);
    gtk_box_pack_start(GTK_BOX(line3_hbox), mhz_label, FALSE, FALSE, 2);
    gtk_widget_show(line3_hbox);


    reboot_button = gtk_button_new_with_label("Reboot");
    gtk_widget_set_sensitive(reboot_button, TRUE);
    gtk_widget_show(reboot_button);

    bootloader_button = gtk_button_new_with_label("Booloader");
    gtk_widget_show(bootloader_button);

    quit_button = gtk_button_new_with_label("Quit");
    gtk_widget_show(quit_button);

    line4_hbox = gtk_hbox_new(TRUE, 2);
    gtk_box_pack_start(GTK_BOX(line4_hbox), reboot_button, TRUE, TRUE, 2);
    gtk_box_pack_start(GTK_BOX(line4_hbox), bootloader_button, TRUE, TRUE, 2);
    gtk_box_pack_start(GTK_BOX(line4_hbox), quit_button, TRUE, TRUE, 2);
    gtk_widget_show(line4_hbox);

    main_vbox = gtk_vbox_new(FALSE, 2);
    gtk_box_pack_start(GTK_BOX(main_vbox), line1_hbox, TRUE, TRUE, 2);
    gtk_box_pack_start(GTK_BOX(main_vbox), line2_hbox, TRUE, TRUE, 2);
    gtk_box_pack_start(GTK_BOX(main_vbox), line3_hbox, TRUE, TRUE, 2);
    gtk_box_pack_start(GTK_BOX(main_vbox), line4_hbox, TRUE, TRUE, 2);
    gtk_widget_show(main_vbox);

    main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_container_add(GTK_CONTAINER(main_window), main_vbox);
    gtk_widget_show(main_window);
}