/* vim: set sw=3 ts=3 sts=3 expandtab: */
#include "ecdb.h"

typedef struct _Burn_Data_Data Burn_Data_Data;
struct _Burn_Data_Data
{
   Ecdb_Burn_Project *proj;
   Evas_Object *capacity;
   Evas_Object *swallow;
   Evas_Object *sc;
   Evas_Object *dc;
};

static void _button_cb_return(void *data, Evas_Object *obj, void *event_info);
static void _button_cb_begin(void *data, Evas_Object *obj, void *event_info);
static void _combo_cb_clicked(void *data, Evas_Object *obj, void *event_info);
static int _update_capacity(void *data, int type, void *ev_data);

// Config inwin updates
static void _joliet_clicked(void *data, Evas_Object *obj, void *event_info);
static void _rockridge_clicked(void *data, Evas_Object *obj, void *event_info);
static void _symlinks_clicked(void *data, Evas_Object *obj, void *event_info);
static void _hidden_clicked(void *data, Evas_Object *obj, void *event_info);
static void _multi_clicked(void *data, Evas_Object *obj, void *event_info);
static void _sim_clicked(void *data, Evas_Object *obj, void *event_info);
static void _underrun_clicked(void *data, Evas_Object *obj, void *event_info);
static void _apply_clicked(void *data, Evas_Object *obj, void *event_info);
static void _proj_name(void *data, Evas *e, Evas_Object *obj, void *event_info);
static void _settings_clicked(void *data, Evas_Object *obj, void *event_into);

// Update on showing to proper values
static void _joliet_config(void *data, Evas_Object *obj, void *event_info);
static void _rockridge_config(void *data, Evas_Object *obj, void *event_info);
static void _symlinks_config(void *data, Evas_Object *obj, void *event_info);
static void _hidden_config(void *data, Evas_Object *obj, void *event_info);
static void _multi_config(void *data, Evas_Object *obj, void *event_info);
static void _sim_config(void *data, Evas_Object *obj, void *event_info);
static void _underrun_config(void *data, Evas_Object *obj, void *event_info);
static void _proj_config(void *data, Evas_Object *obj, void *event_info);

static int
_update_capacity(void *data, int type, void *ev_data)
{
   Ecdb_Source *src;
   Edje_Message_Float msg;
   Burn_Data_Data *bdd;
   Ecdb_Project *proj;

   bdd = data;
   if ((!bdd) || (!bdd->proj))
      return ECORE_CALLBACK_RENEW;

   proj = ECDB_PROJECT(bdd->proj);
   src = evas_object_data_get(bdd->capacity, "source");
   if ((proj->drive) && (proj->drive->capacity > 0))
   {
      printf("drive capacity: %lld, src->size: %lld\n", proj->drive->capacity, src->size);
      msg.val = (float)src->size / (float)proj->drive->capacity;
   }
   else
   {
      // Default to a nice, small size
      msg.val = (float)src->size / 1048576.0 / 700.0;
   }
   if (msg.val > 1.0)
   {
      printf("OVER SIZE LIMIT!\n");
      edje_object_signal_emit(bdd->capacity, "ecdb,capacity,exceeded", "ecdb");
      edje_object_signal_emit(bdd->swallow, "ecdb,capacity, exceeded", "ecdb");
   }
   edje_object_message_send(bdd->capacity, EDJE_MESSAGE_FLOAT, 1, &msg);

   return ECORE_CALLBACK_RENEW;
}

static void
_button_cb_return(void *data, Evas_Object *obj, void *event_info)
{
   Evas_Object *gui;
   Burn_Data_Data *bdd;
   char *signal;

   bdd = data;
   if (!bdd)
      return;

   gui = evas_object_name_find(ecore_evas_get(em->main_win_ee), "gui");

   signal = evas_object_data_get(bdd->swallow, "hide_signal");
   edje_object_signal_emit(bdd->swallow, signal, "ecdb");
   ecdb_welcome_page_show();

   /* Hide the filelist to be nice */
   edje_object_signal_emit(gui, "ecdb,filelist,hide", "ecdb");
}

static void
_button_cb_begin(void *data, Evas_Object *obj, void *event_info)
{
   Evas_Object *gui;
   Ecdb_Project *base_proj;
   Burn_Data_Data *bdd;
   Ewl_Widget *filelist;
   char buf[1024];
   Ecdb_Burn_Result burn_result;
   int drive, speed;

   bdd = data;
   if ((!bdd) || (!bdd->proj))
      return;

   gui = evas_object_name_find(ecore_evas_get(em->main_win_ee), "gui");
   filelist = ewl_widget_name_find("ecdb/burn_data/filelist");
   base_proj = ECDB_PROJECT(bdd->proj);
   if (!base_proj->drive)
   {
      printf("Choose a drive!\n");
      edje_object_part_text_set(bdd->swallow, "progress_text",
                                                            "Choose a Drive!");
      return;
   }

   drive = ecdb_combo_selected_get(bdd->dc);
   speed = ecdb_speed_convert(eina_list_nth(em->drives, drive),
                                             ecdb_combo_selected_get(bdd->sc));
   if (speed < 0)
      bdd->proj->speed = 0;
   else
      bdd->proj->speed = speed;

   bdd->proj->files = ewl_widget_data_get(filelist, "source");
   while (bdd->proj->files->parent)
      bdd->proj->files = bdd->proj->files->parent;

   snprintf(buf, sizeof(buf), "Commencing...");
   edje_object_part_text_set(bdd->swallow, "progress_text", buf);
   if (!ecdb_aquire_drive(ECDB_PROJECT(bdd->proj), drive))
   {
      printf("Couldn't grab drive!\n");
      edje_object_part_text_set(bdd->swallow, "progress_text",
																	"Couldn't grab the drive!");
      return;
   }

   burn_result = ecdb_burn_project(bdd->proj);
   switch (burn_result)
   {
      case ECDB_ERROR_NONE:
         edje_object_signal_emit(gui, "ecdb,filelist,hide", "ecdb");
         edje_object_signal_emit(bdd->swallow, "ecdb,burn_data,start", "ecdb");
         const char *ids[] = {"ecdb/burn_data/return", "ecdb/burn_data/begin",
										"ecdb/burn_data/file", "ecdb/burn_data/drive",
                              "ecdb/burn_data/speed"};
         ecdb_gui_controls_disable(ids, 5);
         return;

      case ECDB_ERROR_IMAGE_CREATE:
         snprintf(buf, sizeof(buf), "Invalid file!");
         break;

      case ECDB_ERROR_SOURCE_ATTACH:
         snprintf(buf, sizeof(buf), "Couldn't attach source data!");
         break;

      case ECDB_ERROR_WRITE_MODE:
         snprintf(buf, sizeof(buf), "No suitable burn mode!");
         break;

      default:
         snprintf(buf, sizeof(buf), "Unknown error :-(");
   }     
      
   edje_object_part_text_set(bdd->swallow, "progress_text", buf);
   burn_drive_release(base_proj->drive->tangible[0].drive, 1);
   burn_drive_info_free(base_proj->drive->tangible);
   ecdb_burn_project_destroy(bdd->proj);
   bdd->proj = NULL;
}

static void
_combo_cb_clicked(void *data, Evas_Object *obj, void *event_info)
{
   Evas_Object *b;
   Burn_Data_Data *bdd;
   Ecdb_Project *proj;
   int sel, i, num_speeds, speed;
   char buf[1024];

   bdd = data;
   if ((!bdd) || (!bdd->proj))
      return;

   proj = ECDB_PROJECT(bdd->proj);
   sel = ecdb_combo_selected_get(bdd->dc);
   if (sel < 0)
      return;

   proj->drive = eina_list_nth(em->drives, sel);
   // Update the capacity here, as our capacity could change with the drive
   ecore_event_add(ECDB_FILELIST_SIZE_CHANGED, NULL, NULL, NULL);
   num_speeds = proj->drive->write_speeds[0];
   ecdb_combo_data_set(bdd->sc, proj->drive);
   for (i = 1; i < num_speeds; i++)
   {
      if ((proj->drive->write_speeds[i]) <= 0)
         continue;

      b = ecdb_combo_item_add(bdd->sc, NULL);

      if ((proj->drive->profile_name) &&
                              (proj->drive->profile_name[0] != '\0'))
      {
         if (proj->drive->profile_name[0] == 'C')
            speed = proj->drive->write_speeds[i] / 150;
         else if (proj->drive->profile_name[0] == 'D')
            speed = proj->drive->write_speeds[i] / 1352;
         else
            speed = proj->drive->write_speeds[i] / 4500;
      }
      else
      {
         speed = 0;
      }

      snprintf(buf, sizeof(buf), "%dX (%dkb/s)", speed,
                                                proj->drive->write_speeds[i]);
      ecdb_combo_item_label_set(b, buf);
      ecdb_combo_append(bdd->sc, b);
      evas_object_show(b);
   }
}

static void
_joliet_clicked(void *data, Evas_Object *obj, void *event_info)
{
   int state;
   Ecdb_Burn_Project *proj;

   proj = data;
   state = ecdb_check_checked_get(obj);
   proj->use_joliet = state;
}

static void
_joliet_config(void *data, Evas_Object *obj, void *event_info)
{
   Ecdb_Burn_Project *proj;

   proj = data;
   ecdb_check_checked_set(obj, proj->use_joliet);
}

static void
_rockridge_clicked(void *data, Evas_Object *obj, void *event_info)
{
   int state;
   Ecdb_Burn_Project *proj;

   proj = data;
   state = ecdb_check_checked_get(obj);
   proj->use_rockridge = state;
}

static void
_rockridge_config(void *data, Evas_Object *obj, void *event_info)
{
   Ecdb_Burn_Project *proj;

   proj = data;
   ecdb_check_checked_set(obj, proj->use_rockridge);
}

static void
_symlinks_clicked(void *data, Evas_Object *obj, void *event_info)
{
   int state;
   Ecdb_Burn_Project *proj;

   proj = data;
   state = ecdb_check_checked_get(obj);
   proj->follow_symlinks = state;
}

static void
_symlinks_config(void *data, Evas_Object *obj, void *event_info)
{
   Ecdb_Burn_Project *proj;

   proj = data;
   ecdb_check_checked_set(obj, proj->follow_symlinks);
}

static void
_hidden_clicked(void *data, Evas_Object *obj, void *event_info)
{
   int state;
   Ecdb_Burn_Project *proj;

   proj = data;
   state = ecdb_check_checked_get(obj);
   proj->ignore_hidden = state;
}

static void
_hidden_config(void *data, Evas_Object *obj, void *event_info)
{
   Ecdb_Burn_Project *proj;

   proj = data;
   ecdb_check_checked_set(obj, proj->ignore_hidden);
}

static void
_multi_clicked(void *data, Evas_Object *obj, void *event_info)
{
   int state;
   Ecdb_Burn_Project *proj;

   proj = data;
   state = ecdb_check_checked_get(obj);
   proj->multi = state;
}

static void
_multi_config(void *data, Evas_Object *obj, void *event_info)
{
   Ecdb_Burn_Project *proj;

   proj = data;
   ecdb_check_checked_set(obj, proj->multi);
}

static void
_sim_clicked(void *data, Evas_Object *obj, void *event_info)
{
   int state;
   Ecdb_Burn_Project *proj;

   proj = data;
   state = ecdb_check_checked_get(obj);
   proj->simulate = state;
}

static void
_sim_config(void *data, Evas_Object *obj, void *event_info)
{
   Ecdb_Burn_Project *proj;

   proj = data;
   ecdb_check_checked_set(obj, proj->simulate);
}

static void
_underrun_clicked(void *data, Evas_Object *obj, void *event_info)
{
   int state;
   Ecdb_Burn_Project *proj;

   proj = data;
   state = ecdb_check_checked_get(obj);
   proj->underrun_proof = state;
}

static void
_underrun_config(void *data, Evas_Object *obj, void *event_info)
{
   Ecdb_Burn_Project *proj;

   proj = data;
   ecdb_check_checked_set(obj, proj->underrun_proof);
}

static void
_apply_clicked(void *data, Evas_Object *obj, void *event_info)
{
   ecdb_config_inwin_hide(data);
}

static void
_proj_name(void *data, Evas *e, Evas_Object *obj, void *event_info)
{
   const char *name;
   Ecdb_Burn_Project *proj;

   proj = data;
   name = ecdb_entry_text_get(obj);
   if (proj->volume_id)
      free(proj->volume_id);

   proj->volume_id = strdup(name);
}

static void
_proj_config(void *data, Evas_Object *obj, void *event_info)
{
   Ecdb_Burn_Project *proj;

   proj = data;

   if (proj->volume_id)
      ecdb_entry_text_set(obj, proj->volume_id);
   else
      ecdb_entry_text_set(obj, "Project Name");
}

static void
_settings_clicked(void *data, Evas_Object *obj, void *event_into)
{
   Eina_Iterator *it;
   const Evas_Object *table;
   Evas_Object *o;

   table = edje_object_part_object_get(data, "ecdb.table");
   it = evas_object_table_iterator_new(table);
   
   if (!it)
   {
      printf("_settings_clicked: NULL iterator!\n");
      return;
   }

   while (eina_iterator_next(it, (void **)&o))
      evas_object_smart_callback_call(o, "proj_config", NULL);
   eina_iterator_free(it);

   ecdb_config_inwin_show(data);
}

void
ecdb_burn_data_page_show(void)
{
   Evas_Object *swallow, *gui;
   Burn_Data_Data *bdd;

   gui = evas_object_name_find(ecore_evas_get(em->main_win_ee), "gui");
   swallow = evas_object_name_find(ecore_evas_get(em->main_win_ee),
         "burn_data_page");

   if (!swallow)
   {
      Evas_Object *b, *c1, *c2, *t;
      Eina_List *l;
      Ecdb_Drive_Info *drive;
      Evas_Coord x, y, w, h;
      Ewl_Widget *embed, *filelist;
      Ecdb_Source *src;

      bdd = calloc(1, sizeof(Burn_Data_Data));
      bdd->proj = ecdb_burn_project_new();

      swallow = edje_object_add(ecore_evas_get(em->main_win_ee));
      edje_object_file_set(swallow, em->theme_path, "ecdb/burn_data_page");
      evas_object_name_set(swallow, "burn_data_page");
      evas_object_data_set(swallow, "hide_signal", "ecdb,burn_data_page,hide");
      edje_object_part_geometry_get(gui, "active_area", &x, &y, &w, &h);
      evas_object_move(swallow, x, y);
      evas_object_resize(swallow, w, h);
      edje_object_part_swallow(gui, "action_area", swallow);

      edje_object_signal_callback_add(swallow, "hide,finished",
													"burn_data_page",
													ecdb_page_hide_finished, NULL);
      evas_object_data_set(swallow, "bdd", bdd);
      evas_object_show(swallow);
      bdd->swallow = swallow;

      b = ecdb_button_add(swallow, "ecdb/burn_data/return");
      ecdb_button_label_set(b, "Return to Main Page");
      evas_object_smart_callback_add(b, "clicked", _button_cb_return, bdd);
      evas_object_show(b);
      ecdb_button_icon_set(b, "ecdb/burn_data/return");

      b = ecdb_button_add(swallow, "ecdb/burn_data/begin");
      ecdb_button_label_set(b, "Start Burn");
      evas_object_smart_callback_add(b, "clicked", _button_cb_begin, bdd);
      evas_object_show(b);
      ecdb_button_icon_set(b, "ecdb/burn_data/begin");

      c1 = ecdb_combo_add(swallow, "ecdb/burn_data/drive");
      ecdb_combo_header_set(c1, "Drive");
      ecdb_combo_header_create_set(c1, ecdb_gui_combo_header_from_drive);
      evas_object_show(c1);
      bdd->dc = c1;

      c2 = ecdb_combo_add(swallow, "ecdb/burn_data/speed");
      ecdb_combo_header_create_set(c2, ecdb_gui_combo_header_from_speeds);
      ecdb_combo_header_set(c2, "Max Speed");
      evas_object_show(c2);
      bdd->sc = c2;

      EINA_LIST_FOREACH(em->drives, l, drive)
      {
         b = ecdb_combo_item_add(c1, NULL);
         ecdb_combo_item_label_set(b, drive->product);
         evas_object_smart_callback_add(b, "clicked", _combo_cb_clicked, bdd);
         ecdb_combo_append(c1, b);
         evas_object_show(b);
      }

      embed = ewl_embed_new();
      ewl_object_fill_policy_set(EWL_OBJECT(embed), EWL_FLAG_FILL_ALL);
      b = ewl_embed_canvas_set(EWL_EMBED(embed), evas_object_evas_get(c2),
            (void *)(long)ecore_evas_software_x11_window_get(em->main_win_ee));
      ewl_embed_focus_set(EWL_EMBED(embed), TRUE);
      ewl_widget_show(embed);

      filelist = ecdb_custom_filelist_new();
      ewl_widget_name_set(EWL_WIDGET(filelist), "ecdb/burn_data/filelist");
      ewl_container_child_append(EWL_CONTAINER(embed), filelist);
      ewl_widget_show(filelist);

      src = ecdb_source_new();
      ewl_widget_data_set(filelist, "source", src);

      edje_object_part_geometry_get(swallow, "ecdb/burn_data/filelist", &x, &y,
                                                            &w, &h);
      evas_object_name_set(b, "ecdb/burn_data/filelist_swallow");
      evas_object_move(b, x, y);
      evas_object_resize(b, w, h);
      edje_object_part_swallow(swallow, "ecdb/burn_data/filelist", b);

      b = edje_object_part_swallow_get(swallow, "ecdb/burn_data/filelist");
      ecdb_widget_focus_callback_add(b, "ecdb/burn_data/filelist");

      // FIXME Turn this into a normal widget
      b = ecdb_widget_add(swallow, "ecdb/burn_data/capacity");
      edje_object_file_set(b, em->theme_path, "ecdb/capacity");
      evas_object_data_set(b, "source", src);
      ecore_event_handler_add(ECDB_FILELIST_SIZE_CHANGED, _update_capacity,
                                                                        bdd);
      evas_object_show(b);
      bdd->capacity = b;

      t = ecdb_config_inwin_add(swallow, NULL);
      
      b = ecdb_check_add(t, NULL);
      ecdb_check_label_set(b, "Use Joliet");
      evas_object_smart_callback_add(b, "clicked", _joliet_clicked, bdd->proj);
      evas_object_smart_callback_add(b, "proj_config", _joliet_config,
                                                                  bdd->proj);
      ecdb_config_inwin_child_add(t, b, 0, 0, 1, 1);
      evas_object_name_set(b, "ecdb/burn_data/joliet");
      evas_object_show(b);

      b = ecdb_check_add(t, NULL);
      ecdb_check_label_set(b, "Use Rockridge");
      evas_object_smart_callback_add(b, "clicked", _rockridge_clicked,
                                                                  bdd->proj);
      evas_object_smart_callback_add(b, "proj_config", _rockridge_config,
                                                                  bdd->proj);
      ecdb_config_inwin_child_add(t, b, 0, 1, 1, 1);
      evas_object_name_set(b, "ecdb/burn_data/rockridge");
      evas_object_show(b);

      b = ecdb_check_add(t, NULL);
      ecdb_check_label_set(b, "Follow Symlinks");
      evas_object_smart_callback_add(b, "clicked", _symlinks_clicked,
                                                                  bdd->proj);
      evas_object_smart_callback_add(b, "proj_config", _symlinks_config,
                                                                  bdd->proj);
      ecdb_config_inwin_child_add(t, b, 0, 2, 1, 1);
      evas_object_name_set(b, "ecdb/burn_data/symlinks");
      evas_object_show(b);

      b = ecdb_check_add(t, NULL);
      ecdb_check_label_set(b, "Ignore Hidden Files");
      evas_object_smart_callback_add(b, "clicked", _hidden_clicked, bdd->proj);
      evas_object_smart_callback_add(b, "proj_config", _hidden_config,
                                                                  bdd->proj);
      ecdb_config_inwin_child_add(t, b, 0, 3, 1, 1);
      evas_object_name_set(b, "ecdb/burn_data/hidden");
      evas_object_show(b);

      b = ecdb_check_add(t, NULL);
      ecdb_check_label_set(b, "Multi-session");
      evas_object_smart_callback_add(b, "clicked", _multi_clicked, bdd->proj);
      evas_object_smart_callback_add(b, "proj_config", _multi_config,
                                                                  bdd->proj);
      ecdb_config_inwin_child_add(t, b, 1, 0, 1, 1);
      evas_object_name_set(b, "ecdb/burn_data/multi");
      evas_object_show(b);

      b = ecdb_check_add(t, NULL);
      ecdb_check_label_set(b, "Simulate");
      evas_object_smart_callback_add(b, "clicked", _sim_clicked, bdd->proj);
      evas_object_smart_callback_add(b, "proj_config", _sim_config, bdd->proj);
      ecdb_config_inwin_child_add(t, b, 1, 1, 1, 1);
      evas_object_name_set(b, "ecdb/burn_data/sim");
      evas_object_show(b);

      b = ecdb_check_add(t, NULL);
      ecdb_check_label_set(b, "Use Underrun Proof");
      evas_object_smart_callback_add(b, "clicked", _underrun_clicked,
                                                                  bdd->proj);
      evas_object_smart_callback_add(b, "proj_config", _underrun_config,
                                                                  bdd->proj);
      ecdb_config_inwin_child_add(t, b, 1, 2, 1, 1);
      evas_object_name_set(b, "ecdb/burn_data/underrun");
      evas_object_show(b);

      b = ecdb_entry_add(t, NULL);
      ecdb_entry_text_set(b, "Volume Name");
      evas_object_event_callback_add(b, EVAS_CALLBACK_FOCUS_OUT,
                                                   _proj_name, bdd->proj);
      evas_object_smart_callback_add(b, "proj_config", _proj_config,
                                                                  bdd->proj);
      ecdb_config_inwin_child_add(t, b, 1, 3, 1, 1);
      evas_object_name_set(b, "ecdb/burn_data/name");
      evas_object_show(b);

      b = ecdb_button_add(t, NULL);
      ecdb_button_label_set(b, "Apply");
      evas_object_smart_callback_add(b, "clicked", _apply_clicked, t);
      ecdb_config_inwin_child_add(t, b, 0, 4, 2, 1);
      evas_object_name_set(b, "ecdb/burn_data/apply");
      evas_object_show(b);
      
      // At the end so t is a valid pointer
      b = ecdb_button_add(swallow, "ecdb/burn_data/settings");
      ecdb_button_label_set(b, "Settings");
      evas_object_smart_callback_add(b, "clicked", _settings_clicked, t);
      evas_object_show(b);
   }
   else if (edje_object_part_swallow_get(gui, "action_area") != swallow)
   {
      edje_object_part_swallow(gui, "action_area", swallow);
      evas_object_show(swallow);
   }

   bdd = evas_object_data_get(swallow, "bdd");
   if (!bdd)
   {
      printf("No data for burn data page! This should never happen!\n");
   }
   else
   {
      if (!bdd->proj)
         bdd->proj = ecdb_burn_project_new();
   }

   edje_object_signal_emit(gui, "ecdb,burn_data_page,visible", "ecdb");
   edje_object_signal_emit(swallow, "ecdb,burn_data_page,visible", "ecdb");
}

void
ecdb_burn_data_cleanup(void)
{
   Evas_Object *swallow;
   Ewl_Widget *filelist;
   Ecdb_Source *src;
   Burn_Data_Data *bdd;
   int i;

   const char *ids[] = {"ecdb/burn_data/return", "ecdb/burn_data/begin",
								"ecdb/burn_data/file", "ecdb/burn_data/drive"
                        "ecdb/burn_data/speed"};
   swallow = evas_object_name_find(ecore_evas_get(em->main_win_ee),
																				"burn_data_page");
   bdd = evas_object_data_get(swallow, "bdd");
   edje_object_part_text_set(swallow, "progress_text", "Burn Complete!");
   ecdb_gui_controls_enable(ids, 5);
   edje_object_signal_emit(swallow, "ecdb,burn_data,done", "ecdb");

   filelist = ewl_widget_name_find("ecdb/burn_data/filelist");
   src = ewl_widget_data_get(filelist, "source");
   while (src->parent)
      src = src->parent;

   for (i = 0; i < src->num_children; i++)
   {
      ecdb_source_child_remove(src, src->children[i]);
      ecdb_source_destroy(src->children[i]);
   }
   bdd->proj = NULL;
}