#include <gtk/gtk.h>
#include <gdk-pixbuf/gdk-pixbuf.h>
#include <libappindicator/app-indicator.h>
#include <stdbool.h>
#include <limits.h>

#include <pango-1.0/pango/pango-font.h>

#include "states.h"
#include "statusicon.h"
#include "magic_code.h"
#include "melon_vpn_about.h"

GtkApplication *app;
GdkPixbuf *appicon;
char *statusiconoff;
char *statusiconon;
States currentstate;
char *currentpeers;
bool restarttoggle = false;
bool cli_is_debug = false;

// Window shit
GtkWidget *window;
GtkWidget *box;
GtkWidget *button;
GtkWidget *button2;
GtkWidget *button3;
GtkWidget *button4;
GtkWidget *statustxt;

// Callback functions for the code in the CLI
int (*cli_start_vpn)();
int (*cli_stop_vpn)();
int (*cli_refresh_vpn)();
int (*cli_restart_conf_vpn)(bool);

int quit_app() {
  // Stops 'g_application_run'
  g_application_quit(G_APPLICATION(app));
  return 0;
}

void open_about(GtkApplication* app) {
  // Setup and display about window
  GtkWidget *about = gtk_about_dialog_new();
  gtk_about_dialog_set_program_name(GTK_ABOUT_DIALOG(about),about_name);
  gtk_about_dialog_set_version(GTK_ABOUT_DIALOG(about),"v1.0.0");
  gtk_about_dialog_set_copyright(GTK_ABOUT_DIALOG(about),about_copyright);
  gtk_about_dialog_set_license_type(GTK_ABOUT_DIALOG(about),GTK_LICENSE_UNKNOWN);
  gtk_about_dialog_set_website(GTK_ABOUT_DIALOG(about),about_url);
  gtk_about_dialog_set_website_label(GTK_ABOUT_DIALOG(about),about_website);
  gtk_about_dialog_set_logo(GTK_ABOUT_DIALOG(about),appicon);

  const char *authors[2] = {about_author,NULL};
  gtk_about_dialog_set_authors(GTK_ABOUT_DIALOG(about),authors);

  const char *artists[2] = {about_artist,NULL};
  gtk_about_dialog_set_artists(GTK_ABOUT_DIALOG(about),artists);

  gtk_widget_show_all(about);
}

void open_start_btn(GtkButton *button) {
  (*cli_start_vpn)();
}

void open_stop_btn(GtkButton *button) {
  (*cli_stop_vpn)();
}

void update_restart_toggle_btn_label() {
  char restartbtnlabel[] = "Restart [ ]";
  if(restarttoggle) restartbtnlabel[9] = '#';
  gtk_button_set_label(GTK_BUTTON(button3), restartbtnlabel);
}

void open_restart_toggle_btn(GtkButton *button) {
  restarttoggle = !restarttoggle;
  (*cli_restart_conf_vpn)(restarttoggle);
  update_restart_toggle_btn_label();
}

void open_about_btn(GtkButton *button) {
  open_about(app);
}

gboolean on_window_deleted(GtkWidget *widget, GdkEvent *event, gpointer data) {
  gtk_widget_hide(widget);
  return true;
}

void activate(GtkApplication* app) {
  window = gtk_application_window_new(app);
  gtk_window_set_title(GTK_WINDOW(window),"Melon VPN");
  gtk_window_set_default_size(GTK_WINDOW(window),300,300);
  gtk_window_set_resizable(GTK_WINDOW(window),false);
  gtk_window_set_type_hint(GTK_WINDOW(window),GDK_WINDOW_TYPE_HINT_DIALOG);
  g_signal_connect(G_OBJECT(window),"delete-event",G_CALLBACK(on_window_deleted),NULL);

  // Setup status icon now window is available
  status_icon_create(window,statusiconoff,statusiconon);
  status_icon_set_state(APP_INDICATOR_STATUS_ACTIVE);
  status_icon_set_quit_callback(quit_app);
  status_icon_set_connect_callback(cli_start_vpn);
  status_icon_set_disconnect_callback(cli_stop_vpn);

  gtk_container_set_border_width(GTK_CONTAINER(window),8);

  // Setup a monospace font
  PangoFontDescription *font = pango_font_description_new();
  pango_font_description_set_family(font,"Monospace");

  // Create start button
  button = gtk_button_new_with_label("Start");
  gtk_widget_modify_font(GTK_WIDGET(button), font);
  g_signal_connect(button,"clicked",G_CALLBACK(open_start_btn),NULL);

  // Create stop button
  button2 = gtk_button_new_with_label("Stop");
  gtk_widget_modify_font(GTK_WIDGET(button2), font);
  g_signal_connect(button2,"clicked",G_CALLBACK(open_stop_btn),NULL);

  // Create restart button
  button3 = gtk_button_new_with_label("Restart [ ]");
  gtk_widget_modify_font(GTK_WIDGET(button3), font);
  g_signal_connect(button3,"clicked",G_CALLBACK(open_restart_toggle_btn),NULL);

  // Create about button
  button4 = gtk_button_new_with_label("About");
  gtk_widget_modify_font(GTK_WIDGET(button4), font);
  g_signal_connect(button4,"clicked",G_CALLBACK(open_about_btn),NULL);

  // Create label for status text
  statustxt = gtk_label_new("");
  gtk_widget_modify_font(GTK_WIDGET(statustxt), font);

  // Fixed box used to position the widgets
  box = gtk_fixed_new();

  gtk_container_add(GTK_CONTAINER(window),box);
  gtk_fixed_put(GTK_FIXED(box),button,10,40);
  gtk_fixed_put(GTK_FIXED(box),button2,100,40);
  gtk_fixed_put(GTK_FIXED(box),button3,190,40);
  gtk_fixed_put(GTK_FIXED(box),button4,190,5);
  gtk_fixed_put(GTK_FIXED(box),statustxt,10,10);

  gtk_widget_show_all(window);

  // Refresh data when loading the GUI
  (*cli_refresh_vpn)();
}

void get_magic_code(int *a, int *b) {
  *a = MAGIC_CODE_A;
  *b = MAGIC_CODE_B;
}

int run_gui(int argc, char **argv, bool is_debug, int (*start_vpn)(), int (*stop_vpn)(), int (*restart_conf_vpn)(bool), int (*refresh_vpn)()) {
  int status;

  cli_is_debug = is_debug;
  cli_start_vpn = start_vpn;
  cli_stop_vpn = stop_vpn;
  cli_refresh_vpn = refresh_vpn;
  cli_restart_conf_vpn = restart_conf_vpn;

  statusiconoff = "";
  statusiconon = "";

  char cwd[PATH_MAX];
  if (getcwd(cwd, sizeof(cwd)) == NULL) {
    fprintf(stderr, "Failed to get current directory\n");
    return 1;
  }

  int cwdlen = strlen(cwd);

  char officonname[] = "/statusmelonoff.png";
  int officonl = cwdlen+strlen(officonname)+1;
  char officonpath[officonl];
  strcpy(officonpath, cwd);
  officonpath[cwdlen] = 0;
  strcat(officonpath, officonname);
  officonpath[officonl-1] = 0;

  char oniconname[] = "/statusmelonon.png";
  int oniconl = cwdlen+strlen(oniconname)+1;
  char oniconpath[oniconl];
  strcpy(oniconpath, cwd);
  oniconpath[cwdlen] = 0;
  strcat(oniconpath, oniconname);
  oniconpath[oniconl-1] = 0;

  if(access("melonvpn.png",R_OK) == 0) {
    appicon = gdk_pixbuf_new_from_file("melonvpn.png",NULL);
  } else if(access("/usr/lib/melonvpn/melonvpn.png",R_OK) == 0) {
    appicon = gdk_pixbuf_new_from_file("/usr/lib/melonvpn/melonvpn.png",NULL);
  }

  if(access(officonpath,R_OK) == 0) {
    statusiconoff = officonpath;
  } else if(access("/usr/lib/melonvpn/statusmelonoff.png",R_OK) == 0) {
    statusiconoff = "/usr/lib/melonvpn/statusmelonoff.png";
  }

  if(access(oniconpath,R_OK) == 0) {
    statusiconon = oniconpath;
  } else if(access("/usr/lib/melonvpn/statusmelonon.png",R_OK) == 0) {
    statusiconon = "/usr/lib/melonvpn/statusmelonon.png";
  }

  if(appicon == NULL) {
    fprintf(stderr,"ERROR: Failed to load program logo\n");
    return 1;
  }
  if(strcmp(statusiconoff,"")==0) {
    fprintf(stderr,"ERROR: Failed to load status off icon\n");
    return 1;
  }
  if(strcmp(statusiconon,"")==0) {
    fprintf(stderr,"ERROR: Failed to load status on icon\n");
    return 1;
  }

  currentstate = DISCONNECTED;

  app = gtk_application_new("net.onpointcoding.melonvpn",G_APPLICATION_FLAGS_NONE);
  g_signal_connect(app,"activate",G_CALLBACK(activate),NULL);
  status = g_application_run(G_APPLICATION(app),argc,argv);
  g_object_unref(app);

  return status;
}

void mod_trigger_state(States state) {
  currentstate = state;
  if(cli_is_debug) fprintf(stderr, "update_state(%s);\n",string_state(currentstate));
  if(currentstate == CONNECTED) {
    status_icon_set_state(APP_INDICATOR_STATUS_ATTENTION);
  } else if(currentstate == DISCONNECTED) {
    status_icon_set_state(APP_INDICATOR_STATUS_ACTIVE);
  } else {
    status_icon_set_state(APP_INDICATOR_STATUS_PASSIVE);
  }

  char *statelbl = string_state_upper(state);
  gtk_label_set_text(GTK_LABEL(statustxt), statelbl);
}

void mod_trigger_peers(char *peers) {
  strcpy(currentpeers, peers);
}

void mod_trigger_isrestart(bool isrestart) {
  restarttoggle = isrestart;
  update_restart_toggle_btn_label();
}