mod interfaces;

use self::interfaces::*;
use gdk_pixbuf_sys::*;
use gdk_sys::*;
use gio_sys::*;
use glib_sys::*;
use gobject_sys::*;
use gtk_sys::*;
use maraiah::{c_str,
              durandal::{err::*, ffi}};
use std::{cell::RefCell, rc::Rc};

// Called when the application activates in order to set everything up.
unsafe extern "C" fn app_activate(app: *mut GtkApplication, _: gpointer)
{
   // Callback to finalize the reference.
   unsafe extern "C" fn c_done(_: *mut GApplication, ptr: gpointer)
   {
      let edit = Rc::from_raw(ptr as *const EditorRef);
      assert_eq!(Rc::strong_count(&edit), 1);
   }

   let b = Refc::new(gtk_builder_new_from_resource(PATH_BUILDER));

   let prop = PropertiesWindow{flg_ent: get_flag_fields(&b, B_CON_F_ENT),
                               flg_env: get_flag_fields(&b, B_CON_F_ENV),
                               flg_msn: get_flag_fields(&b, B_CON_F_MSN)};

   let edit = EditorModel::new(EditorView{prop});
   let edit = RefCell::new(edit);
   let edit = Rc::new(edit);

   setup_css();
   //setup_draw_area(&b, edit.clone());
   let wv = setup_win(&b, B_WIN_M_VIEW, B_BTN_M_VIEW);
   let wt = setup_win(&b, B_WIN_M_TOOL, B_BTN_M_TOOL);
   let _  = setup_win(&b, B_WIN_M_PROP, B_BTN_M_PROP);
   gtk_widget_show_all(wv);
   gtk_widget_show_all(wt);

   setup_about_dlg(&b);
   setup_win_main(&b, app, edit.clone());

   connect(app, E_SHUTDOWN, c_done as _, Rc::into_raw(edit));
}

// Gets all of the toggle buttons from a container.
unsafe fn get_flag_fields(b: &Refc<GtkBuilder>, name: ffi::NT)
   -> Vec<Refc<'static, GtkToggleButton>>
{
   let mut flags = Vec::new();

   let head = get_obj(b, name);
   let head = ListD::new(gtk_container_get_children(head));
   let gtyp = gtk_toggle_button_get_type();

   get_typed_from(head, gtyp, |obj| flags.push(Refc::own(obj as _)));

   flags
}

// Sets up the map view window.
unsafe fn setup_win(b: &Refc<GtkBuilder>, win: ffi::NT, btn: ffi::NT)
   -> *mut GtkWidget
{
   // Callback to show the widget.
   unsafe extern "C" fn c_show_act(_: *mut GtkWidget, wid: gpointer)
   {
      gtk_widget_show_all(wid as _);
   }

   let win = get_obj::<GtkWindow  >(b, win);
   let btn = get_obj::<GtkMenuItem>(b, btn);

   connect_hide(win);
   connect(btn, E_ACTIVATE, c_show_act as _, win);

   win as *mut GtkWidget
}

// Sets up the about dialogue.
unsafe fn setup_about_dlg(b: &Refc<GtkBuilder>)
{
   // Callback to show the dialogue when the "About" button is pressed, and
   // hide it when the "Close" button is pressed on it.
   unsafe extern "C" fn c_show_act(_: *mut GtkWidget, dlg: gpointer)
   {
      gtk_dialog_run(dlg as _);
      gtk_widget_hide(dlg as _);
   }

   let dlg = get_obj::<GtkAboutDialog>(b, B_DLG_ABOUT);
   let btn = get_obj::<GtkMenuItem   >(b, B_BTN_ABOUT);

   let it    = env!("CARGO_PKG_AUTHORS").split(';');
   let mut v = ffi::CStringVec::new_from_iter(it).unwrap();
   let img   = Refc::new(load_img(IM_ABOUT));

   gtk_about_dialog_set_authors(dlg, v.as_mut_ptr());
   gtk_about_dialog_set_version(dlg, c_str!(env!("CARGO_PKG_VERSION")));
   gtk_about_dialog_set_website(dlg, c_str!(env!("CARGO_PKG_HOMEPAGE")));
   gtk_about_dialog_set_logo(dlg, *img);

   connect_hide(dlg);
   connect(btn, E_ACTIVATE, c_show_act as _, dlg);
}

// Sets up explicit window finalization for the main window.
unsafe fn setup_explicit_drop(b: &Refc<GtkBuilder>, win: *mut GtkWindow)
{
   // Callback to explicitly finalize all windows on exit.
   unsafe extern "C" fn c_done(_: *mut GtkWidget, exp_del: gpointer)
   {
      let exp_del = Box::from_raw(exp_del as *mut Vec<*mut GtkWindow>);

      for win in *exp_del {
         gtk_widget_destroy(win as _);
      }
   }

   // we need to explicitly drop other windows on exit, which means we need to
   // create a list of them to send to the callback
   let mut exp_del = Vec::new();

   // so, we get all of the objects from the builder, and iterate through them
   let head = ListS::new(gtk_builder_get_objects(**b));

   get_typed_from(head, gtk_window_get_type(), |obj| {
      let obj = obj as *mut GtkWindow;

      if obj != win {
         exp_del.push(obj);
      }
   });

   let exp_del = Box::into_raw(Box::new(exp_del));

   connect(win, E_DESTROY, c_done as _, exp_del);
}

// Get objects of type `ty` from `it`.
unsafe fn get_typed_from<I, F>(it: I, ty: GType, mut f: F)
   where I: Iterator<Item = gpointer>,
         F: FnMut(*mut GObject)
{
   for obj in it {
      // while this is well-defined, it is a weird way of doing it, because
      // this exact method of checking types isn't fully documented. we can't
      // use the macros for this functionality because we're not using C, so we
      // use the underlying function calls. again, get jacked, punk.
      if g_type_check_instance_is_a(obj as *mut GTypeInstance, ty) != 0 {
         f(obj as _);
      }
   }
}

// Sets up the main menu window.
unsafe fn setup_win_main(b: &Refc<GtkBuilder>,
                         app: *mut GtkApplication,
                         edit: Rc<EditorRef>)
{
   // Callback to close the window when the "Quit" button is pressed.
   unsafe extern "C" fn c_quit_act(_: *mut GtkWidget, win: gpointer)
   {
      gtk_window_close(win as _);
   }

   // Callback to create a new map when the "New" button is pressed.
   unsafe extern "C" fn c_new_act(_: *mut GtkWidget, edit: gpointer)
   {
      let edit = &*(edit as *const EditorRef);

      edit.borrow_mut().open_new();
   }

   // Opens the map editor with a buffer.
   unsafe fn open_buf(path: &str, edit: &mut EditorModel) -> ResultS<()>
   {
      let fp = std::fs::File::open(&path)?;
      let mm = memmap::Mmap::map(&fp)?;

      edit.open_buf(&mm);

      Ok(())
   }

   // Callback to open an existing map when the "Open" button is pressed.
   unsafe extern "C" fn c_open_act(_: *mut GtkWidget, edit: gpointer)
   {
      let edit = &*(edit as *const EditorRef);

      if let Some(path) = run_file_chooser_open() {
         // TODO: handle errors gracefully
         open_buf(&path, &mut edit.borrow_mut()).unwrap();
      }
   }

   // set up main window
   let win = get_obj(b, B_WIN_MAIN);

   setup_explicit_drop(b, win);

   gtk_window_set_application(win, app);
   gtk_widget_show_all(win as _);

   // set up buttons
   let btn = get_obj::<GtkMenuItem>(b, B_BTN_QUIT);
   connect(btn, E_ACTIVATE, c_quit_act as _, win);

   let btn = get_obj::<GtkMenuItem>(b, B_BTN_NEW);
   connect(btn, E_ACTIVATE, c_new_act as _, connect_ref(btn, edit.clone()));

   let btn = get_obj::<GtkMenuItem>(b, B_BTN_OPEN);
   connect(btn, E_ACTIVATE, c_open_act as _, connect_ref(btn, edit.clone()));
}

// Sets up the CSS styling providers.
unsafe fn setup_css()
{
   let css  = Refc::new(gtk_css_provider_new());
   gtk_css_provider_load_from_resource(*css, PATH_CSS);

   let scr = gdk_screen_get_default();
   let pri = GTK_STYLE_PROVIDER_PRIORITY_APPLICATION as u32;
   gtk_style_context_add_provider_for_screen(scr, *css as _, pri);
}

// Runs a modal Open File dialogue.
unsafe fn run_file_chooser_open() -> Option<String>
{
   let action = GTK_FILE_CHOOSER_ACTION_OPEN;
   let dlg = gtk_file_chooser_dialog_new(c_str!("Open File"),
                                         ffi::null_mut(),
                                         action,
                                         c_str!("_Cancel"),
                                         GTK_RESPONSE_CANCEL,
                                         c_str!("_Open"),
                                         GTK_RESPONSE_ACCEPT,
                                         ffi::null_mut_void());

   let res = gtk_dialog_run(dlg as _);

   let ret = if res == GTK_RESPONSE_ACCEPT {
      let fna = gtk_file_chooser_get_filename(dlg as _);

      let own = ffi::CStr::from_ptr(fna);
      let own = own.to_str().ok()?.to_owned();

      g_free(fna as _);

      Some(own)
   } else {
      None
   };

   gtk_widget_destroy(dlg);

   ret
}

// Connects a handler that hides a toplevel widget when deleted.
unsafe fn connect_hide<T>(wid: *mut T)
{
   // Callback to hide the widget.
   unsafe extern "C" fn c_hide_del(wid: *mut GtkWidget,
                                   _: *mut GdkEvent,
                                   _: gpointer)
   {
      gtk_widget_hide(wid);
   }

   connect(wid, E_DELETE, c_hide_del as _, ffi::null_void());
}

// Connects the map editor reference to a widget.
unsafe fn connect_ref<T>(obj: *mut T, rc: Rc<EditorRef>) -> *const EditorRef
{
   // Callback to finalize the reference.
   unsafe extern "C" fn c_done(_: *mut GtkWidget, ptr: gpointer)
   {
      Rc::from_raw(ptr as *const EditorRef);
   }

   let ptr = Rc::into_raw(rc);

   connect(obj, E_DESTROY, c_done as _, ptr);

   ptr
}

// Gets an object from a `GtkBuilder`.
unsafe fn get_obj<T>(b: &Refc<GtkBuilder>, name: ffi::NT) -> *mut T
{
   gtk_builder_get_object(**b, name) as _
}

// Connects a signal handler.
unsafe fn connect<T, U>(obj: *mut T, name: ffi::NT, cb: gpointer, d: *const U)
   -> ffi::c_ulong
{
   let cb = std::mem::transmute(cb);
   g_signal_connect_data(obj as _, name, cb, d as _, None, 0)
}

// Loads a `Pixbuf` from a resource.
unsafe fn load_img(path: ffi::NT) -> *mut GdkPixbuf
{
   gdk_pixbuf_new_from_resource(path, ffi::null_mut())
}

// Entry point.
fn main()
{
   unsafe {
      // get jacked, punk. opaque data structures are for nerds.
      const RESOURCE_DATA: &[u8] =
         include_bytes!(concat!(env!("OUT_DIR"), "/resources"));

      // first we create the static resource header, which is really simple
      let mut resource = GStaticResource{data:     RESOURCE_DATA.as_ptr(),
                                         data_len: RESOURCE_DATA.len(),
                                         resource: ffi::null_mut(),
                                         next:     ffi::null_mut(),
                                         padding:  ffi::null_mut()};

      // init it, now we can use it throughout the entire app without copying!
      g_static_resource_init(&mut resource);

      {
         // create and run the app
         let app = Refc::new(gtk_application_new(APP_ID, 0));

         connect(*app, E_ACTIVATE, app_activate as _, ffi::null_void());

         g_application_run(*app as _, 0, ffi::null_mut());
      }

      // deinit the "static" data, and everything will be done
      g_static_resource_fini(&mut resource);
   }
}

const APP_ID:       ffi::NT = c_str!("net.greyserv.maraiah.tycho");
const B_ADJ_M_HORZ: ffi::NT = c_str!("adj-map-horz");
const B_ADJ_M_VERT: ffi::NT = c_str!("adj-map-vert");
const B_BTN_ABOUT:  ffi::NT = c_str!("btn-about");
const B_BTN_M_PROP: ffi::NT = c_str!("btn-show-map-prop");
const B_BTN_M_TOOL: ffi::NT = c_str!("btn-show-map-tools");
const B_BTN_M_VIEW: ffi::NT = c_str!("btn-show-map-view");
const B_BTN_NEW:    ffi::NT = c_str!("btn-new");
const B_BTN_OPEN:   ffi::NT = c_str!("btn-open");
const B_BTN_QUIT:   ffi::NT = c_str!("btn-quit");
const B_CON_F_ENT:  ffi::NT = c_str!("con-f-ent");
const B_CON_F_ENV:  ffi::NT = c_str!("con-f-env");
const B_CON_F_MSN:  ffi::NT = c_str!("con-f-msn");
const B_DLG_ABOUT:  ffi::NT = c_str!("dlg-about");
const B_DRAW_AREA:  ffi::NT = c_str!("draw-area");
const B_WIN_MAIN:   ffi::NT = c_str!("win-main");
const B_WIN_M_PROP: ffi::NT = c_str!("win-map-prop");
const B_WIN_M_TOOL: ffi::NT = c_str!("win-map-tools");
const B_WIN_M_VIEW: ffi::NT = c_str!("win-map-view");
const E_ACTIVATE:   ffi::NT = c_str!("activate");
const E_DELETE:     ffi::NT = c_str!("delete-event");
const E_DESTROY:    ffi::NT = c_str!("destroy");
const E_DRAW:       ffi::NT = c_str!("draw");
const E_SHUTDOWN:   ffi::NT = c_str!("shutdown");
const E_TOGGLE:     ffi::NT = c_str!("toggled");
const IM_ABOUT:     ffi::NT = c_str!("/net/greyserv/maraiah/tycho/tycho2.png");
const IM_NOMAP:     ffi::NT = c_str!("/net/greyserv/maraiah/tycho/tycho1.png");
const PATH_BUILDER: ffi::NT = c_str!("/net/greyserv/maraiah/tycho/ui");
const PATH_CSS:     ffi::NT = c_str!("/net/greyserv/maraiah/tycho/css");

// EOF