partition

def get_types
  return ["4.2BSD", "swap"]
end

def set_disklabels
  $disklabels = Hash.new
  disks = $hdds.keys
  disks.each do | disk |
    $disklabels.store(disk, %w[a b d e f g h i j k l m n o p])
  end
end

def get_parts(disk)
  return $disklabels.fetch(disk)
end

def remove_part(disk, part)
  $disklabels.fetch(disk).delete(part)
end

def add_part(disk, part)
  $disklabels.fetch(disk) << part
  $disklabels.fetch(disk).sort!
end

def part_exist(disk, part)
  return $disklabels.fetch(disk).include?(part)
end

def get_harddisks
  command = SystemCall.new
  $hdds = Hash.new

  command.exec("sysctl -n hw.disknames")

  command.stdout.each do | val |
    disks = val.split(",")
    disks.each do | disk |
      if disk =~ /^[sw]d[0-9][0-9]*/
        $hdds.store(disk.to_s, get_harddisk_size(disk))
      end
    end
  end
end

def set_current_size(disk, op, val)
  current_size = $hdds.fetch(disk).to_f
  if op == "+"
  new_size = current_size + val
  elsif op == "-"
    new_size = current_size - val
  end
  $hdds.store(disk, new_size)
  set_hddsizeLbl()
end

def get_current_size(disk)
  return $hdds.fetch(disk).to_f
end

def get_current_size_sum
  sum = 0.0
  $hdds.each_value do | val |
    sum = sum + val
  end
  return sum
end

def get_harddisk_size(disk)
  command = SystemCall.new

  command.exec("disklabel #{disk} | grep \"total sectors\"")
  sectors = command.stdout.to_s

  command.exec("disklabel #{disk} | grep \"bytes/sector\"")
  bytes = command.stdout.to_s

  sectors.gsub!("total sectors: ", "")
  bytes.gsub!("bytes/sector: ", "")

  #XXX: Quick Hack!
  # Fix It!!!
  sectors.gsub!("\"", "").gsub!("[", "").gsub!("]", "")
  bytes.gsub!("\"", "").gsub!("[", "").gsub!("]", "")

  size_byte = sectors.to_i(10) * bytes.to_i(10)
  size_mbyte = size_byte / 1048576

  size_mbyte *= 0.95

  return size_mbyte
end

def set_hddsizeLbl
  disks = $hdds
  label = "Space left:\n"
  disks.each_pair do | key, val |
    if val >= 1024
      label = label + "#{key}: #{val / 1024} GB\n"
    else
      label = label + "#{key}: #{val.floor} MB\n"
    end
  end
  $hddsizeLbl.text=(label)
end

class PartitionChoice
  attr_accessor :widget, :manual, :auto
  def initialize
    image = Gtk::Image.new("icons/hdd_icon.png")
    @widget = Gtk::Fixed.new
    @manual = Gtk::RadioButton.new("I want to define the partitions on\nmy own (expert-mode)", true)
    @auto = Gtk::RadioButton.new(@manual, "I want to use the auto-partition-feature", true)

    helpText = "What way for partitioning your\n" +
               "harddrive(s) do you prefer?"

    help = Label.new(helpText).widget

    @widget.put(image, 40, 40)
    @widget.put(help, 25,200)
    @widget.put(@manual, 350, 150)
    @widget.put(@auto, 350, 190)
  end

  def set
  end

  def validate
  end

  def save
    $config.store("partitionAuto", self.auto.active?)
    $config.store("partitionManual", self.manual.active?)
  end
end

class PartitionManual
  attr_accessor :widget
  def initialize(window)

    $hddsizeLbl = Gtk::Label.new
    get_harddisks()
    set_hddsizeLbl()
    set_disklabels()

    @widget = fixedMain = Gtk::Fixed.new
    $addBtn = Gtk::Button.new(Gtk::Stock::ADD)
    $delBtn = Gtk::Button.new(Gtk::Stock::DELETE)
    bootableLbl = Gtk::Label.new("Root Disk:")
    $bootable = Gtk::ComboBox.new(is_text_only = true)
    $delBtn.sensitive=(false)
    hdd_pic = image = Gtk::Image.new("icons/hdd_icon.png")
    $partitionList = Array.new
    $hdd = 0; $size = 1; $type = 2; $mountpoint = 3; $iter = 4; $part = 5;

    tree = Gtk::TreeView.new
    tree.selection.mode = Gtk::SELECTION_BROWSE
    renderer = Gtk::CellRendererText.new
    renderer.set_fixed_size(100,20)
    $store = Gtk::ListStore.new(String, String, String, String, String, String)

    hdd = Gtk::TreeViewColumn.new("\tHDD\t", renderer, "text" => $hdd)
    size = Gtk::TreeViewColumn.new("\tSize (in MB)\t", renderer,
                                   "text" => $size)
    type = Gtk::TreeViewColumn.new("\tType\t", renderer, "text" => $type)
    mountpoint = Gtk::TreeViewColumn.new("\tMountpoint\t", renderer,
                                         "text" => $mountpoint)
    iter = Gtk::TreeViewColumn.new("", renderer, "text" => $iter)
    part = Gtk::TreeViewColumn.new("Partition", renderer, "text" => $part)

    treeToolTip = Gtk::Tooltips.new
    deleteToolTip = Gtk::Tooltips.new
    addToolTip = Gtk::Tooltips.new
    exitToolTip = Gtk::Tooltips.new

    $hdds.keys.each do | hdd |
      $bootable.append_text(hdd)
    end

    $bootable.active=(0)

    treeToolTip.set_tip(tree, "double click to edit", "")
    deleteToolTip.set_tip($delBtn, "click to delete selected partition", "")
    addToolTip.set_tip($addBtn, "click to add a partition", "")

    tree.append_column(hdd)
    tree.append_column(size)
    tree.append_column(type)
    tree.append_column(mountpoint)
    tree.append_column(part)

    $addBtn.signal_connect("clicked") {
      addDlg(window)
      if (get_current_size_sum.floor <= 0)
        $addBtn.sensitive=(false)
      else
        $addBtn.sensitive=(true)
      end
      validate()
    }

    $delBtn.signal_connect("clicked") {
      if (!tree.selection.selected.nil?)
        hdd = tree.selection.selected[0]
        hdd_name = tree.selection.selected[3]
        add_part(hdd, tree.selection.selected[5])
        set_current_size(hdd, "+", tree.selection.selected[1].to_f)
        $partitionList.delete_at(tree.selection.selected[4].to_i)
    $store.remove(tree.selection.selected)
        if (get_current_size_sum.floor > 1)
          $addBtn.sensitive=(true)
        end
        if ($partitionList.size < 0)
          $delBtn.sensitive=(false)
        end
      end
      validate()
    }

    tree.selection.signal_connect("changed") {
      if $partitionList.size > 0
        $delBtn.sensitive=(true)
      else
        $delBtn.sensitive=(false)
      end
    }

    tree.signal_connect("row-activated") {
      editDlg(window, tree.selection.selected)
      validate()
    }

    $bootable.signal_connect("changed") {
      validate()
    }

    tree.model = $store
    fixedMain.put($hddsizeLbl, 40, 200)
    fixedMain.put(hdd_pic, 40, 40)
    fixedMain.put(tree, 240, 50)
    fixedMain.put($addBtn, 300, 420)
    fixedMain.put($delBtn, 450, 420)
    fixedMain.put(bootableLbl, 600, 430)
    fixedMain.put($bootable, 700, 420)
  end

  def add_hdd(hdd, size, mountpoint, type, part)
    iter = $store.append
    iter_num = iter.to_str.to_i
    $partitionList[iter_num] = Partition.new(hdd.active_text,
      size.value.to_s, type.active_text, mountpoint.text, iter_num.to_s, part.active_text)

    $store.set_value(iter, $hdd, $partitionList[iter_num].hdd)
    $store.set_value(iter, $size, $partitionList[iter_num].size)
    $store.set_value(iter, $mountpoint, $partitionList[iter_num].mountpoint)
    $store.set_value(iter, $type, $partitionList[iter_num].type)
    $store.set_value(iter, $iter, $partitionList[iter_num].iter.to_s)
    $store.set_value(iter, $part, $partitionList[iter_num].part)
    remove_part(hdd.active_text, part.active_text)
  end

  def update_hdd(hdd, size, mountpoint, type, item, part)
    index = item.to_str.to_i
    $partitionList[index].hdd = hdd.active_text
    $partitionList[index].size = size.value.to_s
    $partitionList[index].mountpoint = mountpoint.text
    $partitionList[index].type = type.active_text
    $partitionList[index].iter = index.to_s
    $partitionList[index].part = part.active_text
    $store.set_value(item, $hdd, hdd.active_text)
    $store.set_value(item, $size, size.value.to_s)
    $store.set_value(item, $mountpoint, mountpoint.text)
    $store.set_value(item, $type, type.active_text)
    $store.set_value(item, $iter, index.to_s)
    $store.set_value(item, $part, part.active_text)
    remove_part(hdd.active_text, part.active_text)
  end

  def editDlg(parent, item)
    dialog = Gtk::Dialog.new(
      "Edit Partition",
      parent,
      Gtk::Dialog::MODAL,
      [ Gtk::Stock::OK, Gtk::Dialog::RESPONSE_OK ],
      [ Gtk::Stock::CANCEL, Gtk::Dialog::RESPONSE_CANCEL ]
    )
    dialog.default_response = Gtk::Dialog::RESPONSE_CANCEL
    dialog.default_width=(400)
    dialog.default_height=(300)

    dialog.window_position=(Gtk::Window::POS_CENTER_ALWAYS)

    hddLbl = Gtk::Label.new("HDD:")
    mountpointLbl = Gtk::Label.new("Mountpoint:")
    sizeLbl = Gtk::Label.new("Size (in MB):")
    typeLbl = Gtk::Label.new("Type:")
    partLbl = Gtk::Label.new("Partition:")

    hdd = Gtk::ComboBox.new(is_text_only = true)
    mountpoint = Gtk::Entry.new
    type = Gtk::ComboBox.new(is_text_only = true)
    part = Gtk::ComboBox.new(true)

    editableAry = Array.new
    hddAry = $hdds.keys
    typeAry = get_types()

    hddAry.each do | element |
      if element == item[0] || !(get_current_size(element).floor <= 0)
        hdd.append_text(element.to_s)
        editableAry << element.to_s
      end
    end

    typeAry.each do | element |
      type.append_text(element)
    end

    size_value = get_current_size(item[0]) + item[1].to_f
    size = Gtk::HScale.new(0, size_value, 1)

    hdd.active=(editableAry.index(item[0]))
    size.value = item[1].to_f
    type.active=(typeAry.index(item[2]))

    mountpoint.text = mountpoint_orig = item[3]
    if item[2] == "swap"
      mountpoint.sensitive=(false)
    else
      mountpoint.sensitive=(true)
    end

    if !part_exist(item[0], item[5])
      add_part(item[0], item[5])
    end

    partsAry = get_parts(item[0])

    partsAry.each do | element |
      part.append_text(element)
    end

    part.active=(partsAry.index(item[5]))

    hdd.signal_connect('changed') {
      partsAry.size.times do
        part.remove_text(0)
      end

      partsAryNew = get_parts(hdd.active_text)
      partsAryNew.each do | element |
        part.insert_text(partsAryNew.index(element), element)
      end
      if hdd.active_text != item[0]
        part.active=(0)
      else
        part.active=(partsAry.index(item[5]))
      end

      if hdd.active_text == item[0]
        size_val = get_current_size(hdd.active_text) + item[1].to_f
      else
        size_val = get_current_size(hdd.active_text)
      end

      adjustment = Gtk::Adjustment.new(0, 0, size_val, 1, 10, 0)
      size.adjustment=(adjustment)
    }

    type.signal_connect('changed') {
      if type.active_text == "swap"
        mountpoint.text = ""
        mountpoint.sensitive=(false)
      else
        mountpoint.sensitive=(true)
      end
    }

    table = Gtk::Table.new(9, 2, true)
    table.attach_defaults(hddLbl,    0, 1, 0, 1)
    table.attach_defaults(mountpointLbl, 0, 1, 2, 3)
    table.attach_defaults(sizeLbl,   0, 1, 4, 5)
    table.attach_defaults(typeLbl,   0, 1, 6, 7)
    table.attach_defaults(partLbl,   0, 1, 8, 9)

    table.attach_defaults(hdd,       1, 2, 0, 1)
    table.attach_defaults(mountpoint,    1, 2, 2, 3)
    table.attach_defaults(size,      1, 2, 4, 5)
    table.attach_defaults(type,      1, 2, 6, 7)
    table.attach_defaults(part,      1, 2, 8, 9)

    table.row_spacings = 5
    table.column_spacings = 5
    table.border_width = 10

    dialog.vbox.add(table)
    dialog.show_all
    dialog.run do |response|
      if response == Gtk::Dialog::RESPONSE_OK
        if (size.value > 0  && (validate_mp(mountpoint.text, true, mountpoint_orig, hdd.active_text, part.active_text) || type.active_text == "swap"))
          #plus old value to old hdd
          set_current_size(item[0], "+", item[1].to_f)
          update_hdd(hdd, size, mountpoint, type, item, part)
          #minus new value to new hdd
          set_current_size(hdd.active_text, "-", size.value.to_f)
          if (get_current_size_sum().floor <= 1)
            $addBtn.sensitive=(false)
          else
            $addBtn.sensitive=(true)
          end
          dialog.destroy
        else
          image = Gtk::Image.new("icons/dialog-error.png")
          box = Gtk::Fixed.new

          case validate_mp(mountpoint.text, false, nil, hdd.active_text, part.active_text)
          when  Partition::EMPTY_NAME
            label = "Mountpoint cant be empty"
          when Partition::INVALID_NAME
            label = "Invalid mountpoint"
          when Partition::ALREADY_EXIST
            label = "Mountpoint already exists"
          when Partition::INVALID_ROOT
            label = "The root-dir (\"/\") have to be on the\n"
            label += "root-disk and receive the Partition \"a\""
          end
          label = "invalid partition size" if size.value <= 0
          errorLbl = Gtk::Label.new(label)

          error = Gtk::Dialog.new("Error: #{label}",
            dialog,
            Gtk::Dialog::MODAL | Gtk::Dialog::DESTROY_WITH_PARENT,
            [Gtk::Stock::OK, Gtk::Dialog::RESPONSE_ACCEPT]
          )

          error.signal_connect('response') {
            error.destroy
            dialog.destroy
            editDlg(parent, item)
          }

          error.set_size_request(400, 200)

          box.put(image, 20, 10)
          box.put(errorLbl, 130, 15)
          error.vbox.add(box)
          error.show_all
        end
      elsif response = Gtk::Dialog::RESPONSE_CANCEL
        remove_part(item[0], item[5])
        dialog.destroy
        break
      else
        remove_part(item[0], item[5])
        break
      end
    end
  end

  def addDlg (parent)
    dialog = Gtk::Dialog.new(
      "Add Partition",
       parent,
       Gtk::Dialog::MODAL,
       [ Gtk::Stock::OK, Gtk::Dialog::RESPONSE_OK ],
       [ Gtk::Stock::CANCEL, Gtk::Dialog::RESPONSE_CANCEL ]
    )
    dialog.default_response = Gtk::Dialog::RESPONSE_CANCEL
    dialog.default_width=(400)
    dialog.default_height=(300)

    dialog.window_position=(Gtk::Window::POS_CENTER_ALWAYS)

    hddLbl = Gtk::Label.new("HDD:")
    mountpointLbl = Gtk::Label.new("Mountpoint:")
    sizeLbl = Gtk::Label.new("Size (in MB):")
    typeLbl = Gtk::Label.new("Type:")
    partLbl = Gtk::Label.new("Partition:")

    hdd = Gtk::ComboBox.new(is_text_only = true)
    mountpoint = Gtk::Entry.new
    type = Gtk::ComboBox.new(is_text_only = true)
    part = Gtk::ComboBox.new(is_text_only = true)

    hddAry = $hdds.keys
    typeAry = get_types()

    i = 0
    hddAry.each do | element |
      if !(get_current_size(element).floor <= 0)
        hdd.append_text(element.to_s)
        i = i + 1
      end
    end

    if i == 0
      # no space for new partitions
      # => self.destruction
      dialog.destroy
      return
    end

    typeAry.each do | element |
      type.append_text(element)
    end

    type.active=(0)
    hdd.active=(0)

    size = Gtk::HScale.new(0, get_current_size(hdd.active_text), 1)

    partsAry = get_parts(hdd.active_text)

    partsAry.each do | element |
      part.append_text(element)
    end

    part.active=(0)

    hdd.signal_connect('changed') {
      partsAry.size.times do
        part.remove_text(0)
      end

      partsAryNew = get_parts(hdd.active_text)
      partsAryNew.each do | element |
        part.insert_text(partsAryNew.index(element), element)
      end
      part.active=(0)
      adjustment = Gtk::Adjustment.new(0, 0, get_current_size(hdd.active_text), 1, 10, 0)
      size.adjustment=(adjustment)
    }

    type.signal_connect('changed') {
      if type.active_text == "swap"
        mountpoint.text = ""
        mountpoint.sensitive=(false)
      else
        mountpoint.sensitive=(true)
      end
    }

    table = Gtk::Table.new(9, 2, true)
    table.attach_defaults(hddLbl,    0, 1, 0, 1)
    table.attach_defaults(mountpointLbl, 0, 1, 2, 3)
    table.attach_defaults(sizeLbl,   0, 1, 4, 5)
    table.attach_defaults(typeLbl,   0, 1, 6, 7)
    table.attach_defaults(partLbl,   0, 1, 8, 9)

    table.attach_defaults(hdd,      1, 2, 0, 1)
    table.attach_defaults(mountpoint,   1, 2, 2, 3)
    table.attach_defaults(size,     1, 2, 4, 5)
    table.attach_defaults(type,     1, 2, 6, 7)
    table.attach_defaults(part,     1, 2, 8, 9)

    table.row_spacings = 5
    table.column_spacings = 5
    table.border_width = 10

    dialog.vbox.add(table)
    dialog.show_all
    dialog.run { |response|
      if response == Gtk::Dialog::RESPONSE_OK
        if (size.value > 0 && (validate_mp(mountpoint.text, true, nil, hdd.active_text, part.active_text) || type.active_text == "swap"))
          add_hdd(hdd, size, mountpoint, type, part)
          if (get_current_size_sum().floor <= 1)
            $addBtn.sensitive=(false)
          end
          set_current_size(hdd.active_text, "-", size.value.to_f)

          dialog.destroy
        else
          image = Gtk::Image.new("icons/dialog-error.png")
          box = Gtk::Fixed.new
          case validate_mp(mountpoint.text, false, nil, hdd.active_text, part.active_text)
          when Partition::EMPTY_NAME
            label = "Mountpoint cant be empty"
          when Partition::INVALID_NAME
            label = "Invalid mountpoint"
          when Partition::ALREADY_EXIST
            label = "Mountpoint already exists"
          when Partition::INVALID_ROOT
            label = "The root-dir (\"/\") have to be on the\n"
            label += "root-disk and receive the Partition \"a\""
          end
          label = "invalid partition size" if size.value <= 0
          errorLbl = Gtk::Label.new(label)

          error = Gtk::Dialog.new("Error: #{label}",
            dialog,
            Gtk::Dialog::MODAL | Gtk::Dialog::DESTROY_WITH_PARENT,
            [Gtk::Stock::OK, Gtk::Dialog::RESPONSE_ACCEPT]
          )

          error.signal_connect('response') {
            error.destroy
           dialog.destroy
           addDlg(parent)
          }

          error.set_size_request(400, 200)

          box.put(image, 20, 10)
          box.put(errorLbl, 130, 15)
          error.vbox.add(box)
          error.show_all
        end
      elsif response = Gtk::Dialog::RESPONSE_CANCEL
        dialog.destroy
        break
      else
        break
      end
    }
  end

  def validate_mp(mountpoint, use_boolean = false, mountpoint_orig = "", hdd, part)
    rCode = Partition::FINE
    rCode = true if use_boolean
    if mountpoint.empty?
      rCode = Partition::EMPTY_NAME
      rCode = false if use_boolean
    end
    if mountpoint !~ /^[\/][A-z0-9\/_-]*$/
      rCode = Partition::INVALID_NAME
      rCode = false if use_boolean
    end
    if mountpoint != mountpoint_orig
      $partitionList.each do | partition |
        if partition.mountpoint == mountpoint
          rCode = Partition::ALREADY_EXIST
          rCode = false if use_boolean
        end
      end
    end
    if mountpoint == "/"
      if part != "a" || hdd != $bootable.active_text
        rCode = Partition::INVALID_ROOT
        rCode = false if use_boolean
      end
    end
    return rCode
  end

  def set
  end

  def validate
    mountpoints = Array.new
    $partitionList.each do | partition |
      mountpoints << partition.mountpoint
      if partition.mountpoint == "/" && partition.hdd == $bootable.active_text
        self.widget.parent.set_page_complete(self.widget, true)
      elsif partition.mountpoint == "/" && partition.hdd != $bootable.active_text
        self.widget.parent.set_page_complete(self.widget, false)
      end
    end
    if !mountpoints.include?("/")
      self.widget.parent.set_page_complete(self.widget, false)
    end
  end

  def save
    if $config.fetch("partitionManual")
      iter = 0
      partitions = Hash.new
      $partitionList.each do | partition |
        partitions.store("partition#{iter}", partition)
        iter = iter + 1
      end
      $config.store("Partitions", partitions)
      $config.store("Bootable-Disk", $bootable.active_text)
    elsif $config.has_key?("Partitions") && !$config.fetch("partitionManual")
      $config.delete("Partitions")
    end
  end

end

class PartitionAuto

  attr_accessor :widget, :hdd

  def initialize
    label = "Auto Partition"
    @label = Label.new(label)
    image = Gtk::Image.new("icons/hdd_icon.png")
    hddAry = $hdds.keys
    @hdd = DropDown.new("Harddisk\t\t", hddAry )
    hdd_size = Label.new
    hdd_size.widget.text=("HDD-Size:\t\t#{get_harddisk_size(@hdd.comboBox.active_text)} MB")

    @hdd.comboBox.signal_connect('changed') {
      hdd_size.widget.text=("HDD-Size:\t\t#{get_harddisk_size(@hdd.comboBox.active_text)} MB")
    }

    @widget = Gtk::Fixed.new
    @widget.put(image, 40, 40)
    @widget.put(@label.widget, 300, 100)
    @widget.put(@hdd.widget, 340, 150)
    @widget.put(hdd_size.widget, 340, 190)
  end

  def set
  end

  def validate
  end

  def save
    if $config.fetch("partitionAuto")
      $config.store("AutoDisk", self.hdd.comboBox.active_text)
      $config.store("Bootable-Disk", self.hdd.comboBox.active_text)
    elsif $config.has_key?("AutoDisk") && !$config.fetch("partitionAuto")
      $config.delete("AutoDisk")
      $config.delete("Bootable-Disk")
    end
  end

end

class Partition

  attr_accessor :hdd, :size, :type, :mountpoint, :iter, :part

  FINE=0
  ALREADY_EXIST=1
  INVALID_NAME=2
  INVALID_SIZE=3
  EMPTY_NAME=4
  INVALID_ROOT=5

  def initialize(a, b, c, d, e, f)
    @hdd, @size, @type, @mountpoint, @iter, @part= a, b, c, d, e, f;
  end

end