class SoftLayer::Software

# File lib/softlayer/Software.rb, line 150
def self.find_software_on_hardware(options_hash = {})
  softlayer_client = options_hash[:client] || Client.default_client
  raise "#{__method__} requires a client but none was given and Client::default_client is not set" if !softlayer_client

  if(options_hash.has_key? :hardware_object_filter)
    hardware_object_filter = options_hash[:hardware_object_filter]
    raise "Expected an instance of SoftLayer::ObjectFilter" unless hardware_object_filter.kind_of?(SoftLayer::ObjectFilter)
  else
    hardware_object_filter = ObjectFilter.new()
  end

  if(options_hash.has_key? :software_object_filter)
    software_object_filter = options_hash[:software_object_filter]
    raise "Expected an instance of SoftLayer::ObjectFilter" unless software_object_filter.kind_of?(SoftLayer::ObjectFilter)
  else
    software_object_filter = ObjectFilter.new()
  end

  filter_label = {
    :bare_metal_instance => "bareMetalInstances",
    :hardware            => "hardware",
    :network_hardware    => "networkHardware",
    :router              => "routers"
  }

  option_to_filter_path = {
    :hardware       => {
      :datacenter     => lambda { |hardware_type| return [ filter_label[hardware_type], '.datacenter.name' ].join        },
      :domain         => lambda { |hardware_type| return [ filter_label[hardware_type], '.domain' ].join                 },
      :hostname       => lambda { |hardware_type| return [ filter_label[hardware_type], '.hostname' ].join               },
      :tags           => lambda { |hardware_type| return [ filter_label[hardware_type], '.tagReferences.tag.name' ].join }
    },
    :software       => {
      :description  => "softwareComponents.softwareDescription.longDescription",
      :manufacturer => "softwareComponents.softwareDescription.manufacturer",
      :name         => "softwareComponents.softwareDescription.name",
      :username     => "softwareComponents.passwords.username"
    }
  }

  if options_hash[:hardware_type]
    unless filter_label.keys.include?(options_hash[:hardware_type])
      raise "Expected :bare_metal_instance, :hardware, :network_hardware, or :router for option :hardware_type in #{__method__}"
    end
  end

  option_to_filter_path[:hardware].keys.each do |option|
    if options_hash[option]
      hardware_object_filter.modify { |filter| filter.accept(option_to_filter_path[:hardware][option].call(options_hash[:hardware_type] || :hardware)).when_it is(options_hash[option]) }
    end
  end

  option_to_filter_path[:software].each do |option, filter_path|
    software_object_filter.modify { |filter| filter.accept(filter_path).when_it is(options_hash[option]) } if options_hash[option]
  end

  account_service = softlayer_client[:Account]
  account_service = account_service.object_filter(hardware_object_filter) unless hardware_object_filter.empty?
  account_service = account_service.object_mask("mask[id]")

  case options_hash[:hardware_type]
  when :bare_metal_instance
    hardware_data = account_service.getBareMetalInstances
  when :hardware, nil
    hardware_data = account_service.getHardware
  when :network_hardware
    hardware_data = account_service.getNetworkHardware
  when :router
    hardware_data = account_service.getRouters
  end

  software = hardware_data.collect do |hardware|
    hardware_service = softlayer_client[:Hardware].object_with_id(hardware['id'])
    hardware_service = hardware_service.object_filter(software_object_filter) unless software_object_filter.empty?
    hardware_service = hardware_service.object_mask(Software.default_object_mask)
    hardware_service = hardware_service.object_mask(options_hash[:software_object_mask]) if options_hash[:software_object_mask]

    software_data = hardware_service.getSoftwareComponents
    software_data.map { |software| Software.new(softlayer_client, software) unless software.empty? }.compact
  end

  software.flatten
end

# File lib/softlayer/Software.rb, line 258
def self.find_software_on_virtual_servers(options_hash = {})
  softlayer_client = options_hash[:client] || Client.default_client
  raise "#{__method__} requires a client but none was given and Client::default_client is not set" if !softlayer_client

  if(options_hash.has_key? :virtual_server_object_filter)
    virtual_server_object_filter = options_hash[:virtual_server_object_filter]
    raise "Expected an instance of SoftLayer::ObjectFilter" unless virtual_server_object_filter.kind_of?(SoftLayer::ObjectFilter)
  else
    virtual_server_object_filter = ObjectFilter.new()
  end

  if(options_hash.has_key? :software_object_filter)
    software_object_filter = options_hash[:software_object_filter]
    raise "Expected an instance of SoftLayer::ObjectFilter" unless software_object_filter.kind_of?(SoftLayer::ObjectFilter)
  else
    software_object_filter = ObjectFilter.new()
  end

  option_to_filter_path = {
    :software       => {
      :description  => "softwareComponents.softwareDescription.longDescription",
      :manufacturer => "softwareComponents.softwareDescription.manufacturer",
      :name         => "softwareComponents.softwareDescription.name",
      :username     => "softwareComponents.passwords.username"
    },
    :virtual_server => {
      :datacenter   => "virtualGuests.datacenter.name",
      :domain       => "virtualGuests.domain",
      :hostname     => "virtualGuests.hostname",
      :tags         => "virtualGuests.tagReferences.tag.name"
    }
  }

  option_to_filter_path[:virtual_server].each do |option, filter_path|
    virtual_server_object_filter.modify { |filter| filter.accept(filter_path).when_it is(options_hash[option]) } if options_hash[option]
  end

  option_to_filter_path[:software].each do |option, filter_path|
    software_object_filter.modify { |filter| filter.accept(filter_path).when_it is(options_hash[option]) } if options_hash[option]
  end

  account_service = softlayer_client[:Account]
  account_service = account_service.object_filter(virtual_server_object_filter) unless virtual_server_object_filter.empty?
  account_service = account_service.object_mask("mask[id]")

  virtual_server_data = account_service.getVirtualGuests

  software = virtual_server_data.collect do |virtual_server|
    virtual_server_service = softlayer_client[:Virtual_Guest].object_with_id(virtual_server['id'])
    virtual_server_service = virtual_server_service.object_filter(software_object_filter) unless software_object_filter.empty?
    virtual_server_service = virtual_server_service.object_mask(Software.default_object_mask)
    virtual_server_service = virtual_server_service.object_mask(options_hash[:software_object_mask]) if options_hash[:software_object_mask]

    software_data = virtual_server_service.getSoftwareComponents
    software_data.map { |software| Software.new(softlayer_client, software) unless software.empty? }.compact
  end

  software.flatten
end

# File lib/softlayer/Software.rb, line 343
def self.default_object_mask
  {
    "mask(SoftLayer_Software_Component)" => [
                                             'id',
                                             'manufacturerActivationCode',
                                             'manufacturerLicenseInstance'
                                            ]
  }.to_sl_object_mask
end

# File lib/softlayer/Software.rb, line 79
def add_user_password(username, password, options = {})
  raise ArgumentError, "The new password cannot be nil"   unless password
  raise ArgumentError, "The new username cannot be nil"   unless username
  raise ArgumentError, "The new password cannot be empty" if password.empty?
  raise ArgumentError, "The new username cannot be empty" if username.empty?

  raise Exception, "Cannot add username password, a Software Password already exists for the provided username" if self.has_user_password?(username.to_s)

  add_user_pw_template = {
    'softwareId' => self['id'].to_i,
    'password'   => password.to_s,
    'username'   => username.to_s
  }

  add_user_pw_template['notes'] = options['notes'].to_s if options.has_key?('notes')
  add_user_pw_template['port']  = options['port'].to_i  if options.has_key?('port')

  softlayer_client[:Software_Component_Password].createObject(add_user_pw_template)

  @passwords = nil
end

# File lib/softlayer/Software.rb, line 109
def delete_user_password!(username)
  user_password = self.passwords.select { |sw_pw| sw_pw.username == username.to_s }

  unless user_password.empty?
    softlayer_client[:Software_Component_Password].object_with_id(user_password.first['id']).deleteObject
    @passwords = nil
  end
end

# File lib/softlayer/Software.rb, line 32
sl_dynamic_attr :description do |resource|
  resource.should_update? do
    #only retrieved once per instance
    @description == nil
  end

  resource.to_update do
    description = self.service.getSoftwareDescription
    description['longDescription']
  end
end

# File lib/softlayer/Software.rb, line 121
def has_user_password?(username)
  self.passwords.map { |sw_pw| sw_pw.username }.include?(username)
end

# File lib/softlayer/Software.rb, line 48
sl_dynamic_attr :name do |resource|
  resource.should_update? do
    #only retrieved once per instance
    @name == nil
  end

  resource.to_update do
    description = self.service.getSoftwareDescription
    description['name']
  end
end

# File lib/softlayer/Software.rb, line 64
sl_dynamic_attr :passwords do |resource|
  resource.should_update? do
    #only retrieved once per instance
    @passwords == nil
  end

  resource.to_update do
    passwords = self.service.getPasswords
    passwords.collect { |password_data| SoftwarePassword.new(softlayer_client, password_data) }
  end
end

# File lib/softlayer/Software.rb, line 321
def service
  softlayer_client[:Software_Component].object_with_id(self.id)
end

# File lib/softlayer/Software.rb, line 329
def softlayer_properties(object_mask = nil)
  my_service = self.service

  if(object_mask)
    my_service = my_service.object_mask(object_mask)
  else
    my_service = my_service.object_mask(self.class.default_object_mask)
  end

  my_service.getObject()
end