class GxG::Networking::FtpClient

# File lib/gxg/net_clients.rb, line 4822
def initialize()
  @client = nil
  self
end

# File lib/gxg/net_clients.rb, line 5157
def change_directory(dir_name=nil)
  result = false
  begin
    if @client
      if @client.closed?
        raise Exception, "Attempted to access a closed session"
      else
        unless dir_name
          raise ArgumentError, "You MUST provide a directory path to change to."
        end
        @client.chdir(dir_name)
        if @client.pwd() != dir_name
          raise Exception, "Failed to change directory."
        else
          result = true
        end
      end
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {:dir_name => dir_name}})
  end
  result
end

# File lib/gxg/net_clients.rb, line 4912
def closed?()
  if @client
    @client.closed?
  else
    true
  end
end

# File lib/gxg/net_clients.rb, line 5103
def entries(dir_name=nil, filter=nil)
  result = []
  unless dir_name
    dir_name = @client.pwd()
  end
  begin
    if @client
      present_dir = @client.pwd()
      @client.chdir(dir_name)
      if filter
        list = @client.list(filter)
      else
        list = @client.list()
      end
      list.each do |entry|
        # TODO: process entry text
        data = entry.split(" ")
        record = {:title => "", :type => :virtual_directory, :owner_type => :virtual_directory, :on_device => nil, :on_device_major => nil, :on_device_minor => nil, :is_device => nil, :is_device_major => nil, :is_device_minor => nil, :inode => nil, :flags => [:read], :hardlinks_to => 0, :user_id => nil, :group_id => nil, :size => 0, :block_size => 0, :blocks => 0, :accessed => nil, :modified => nil, :status_modified => nil, :permissions => nil, :mode=>nil}
        #
        record[:permissions] = ::File.unix_permissions_to_gxg(data[0].to_s)
        if record[:permissions][:other][:write]
          record[:flags] << :write
        end
        #              record[:owner] = data[2]
        #              record[:group] = data[3]
        record[:size] = data[4].to_i
        record[:modified] = ::DateTime::parse(data[5..7].join(" "))
        record[:title] = data[8]
        result << record
      end
      @client.chdir(present_dir)
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {:dir_name => dir_name, :filter => filter}})
  end
  result
end

# File lib/gxg/net_clients.rb, line 5025
def get_file(file_name=nil, save_path=nil)
  result = nil
  begin
    if @client
      if save_path
        result = @client.getbinaryfile(file_name, save_path, 1024)
      else
        result = ::GxG::ByteArray.new
        @client.getbinaryfile(file_name, save_path) do |data_chunk|
          result << data_chunk
        end
      end
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {:file_name => file_name, :save_path => save_path}})
  end
  result
end

# File lib/gxg/net_clients.rb, line 4952
def help()
  result = nil
  begin
    if @client
      if @client.closed?
        raise Exception, "Attempted to access a closed connection."
      else
        result = @client.help()
      end
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {}})
  end
  result
end

# File lib/gxg/net_clients.rb, line 4827
def login(the_url=nil, options={})
  result = false
  login_options = {}
  begin
    unless the_url.is_a?(::URI::Generic)
      raise ArgumentError, "You MUST provide a valid URI"
    end
    # The available options are:
    #
    # port::      Port number (default value is 21)
    if options[:port].is_a?(::Numeric)
      login_options[:port] = options[:port].to_i
    end
    # ssl::       If options[:ssl] is true, then an attempt will be made
    #             to use SSL (now TLS) to connect to the server.  For this
    #             to work OpenSSL [OSSL] and the Ruby OpenSSL [RSSL]
    #             extensions need to be installed.  If options[:ssl] is a
    #             hash, it's passed to OpenSSL::SSL::SSLContext#set_params
    #             as parameters.
    if options[:use_ssl] == true
      login_options[:ssl] = true
    end
    # private_data_connection::  If true, TLS is used for data connections.
    #                            Default: +true+ when options[:ssl] is true.
    # username::  Username for login.  If options[:username] is the string
    #             "anonymous" and the options[:password] is +nil+,
    #             "anonymous@" is used as a password.
    login_options[:username] = the_url.user
    # password::  Password for login.
    login_options[:password] = the_url.password
    # account::   Account information for ACCT.
    if options[:account_info]
      login_options[:account] = options[:account_info]
    end
    # passive::   When +true+, the connection is in passive mode. Default:
    #             +true+.
    if options[:passive] == false
      login_options[:passive] = false
    end
    # open_timeout::  Number of seconds to wait for the connection to open.
    #                 See Net::FTP#open_timeout for details.  Default: +nil+.
    if options[:open_timeout].is_a?(::Numeric)
      login_options[:open_timeout] = options[:open_timeout]
    end
    # read_timeout::  Number of seconds to wait for one block to be read.
    #                 See Net::FTP#read_timeout for details.  Default: +60+.
    if options[:read_timeout].is_a?(::Numeric)
      login_options[:read_timeout] = options[:read_timeout]
    end
    # ssl_handshake_timeout::  Number of seconds to wait for the TLS
    #                          handshake.
    #                          See Net::FTP#ssl_handshake_timeout for
    #                          details.  Default: +nil+.
    if options[:ssl_handshake_timeout].is_a?(::Numeric)
      login_options[:ssl_handshake_timeout] = options[:ssl_handshake_timeout]
    end
    #
    @client = Net::FTP.new(the_url.hostname, login_options)
    if @client.is_a?(Net::FTP)
      @client.login
      if @client.closed?
        raise Exception, "Failed to log into FTP session"
      else
        result = true
      end
    else
      raise Exception, "Failed to create FTP session"
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {:url => the_url, :options => options}})
  end
  result
end

# File lib/gxg/net_clients.rb, line 4901
def logout()
  if @client
    @client.close
    if @client.closed?
      true
    else
      false
    end
  end
end

# File lib/gxg/net_clients.rb, line 5181
def make_directory(dir_name=nil)
  result = false
  begin
    if @client
      if @client.closed?
        raise Exception, "Attempted to access a closed session"
      else
        unless dir_name
          raise ArgumentError, "You MUST provide a directory path to create."
        end
        result = @client.mkdir(dir_name)
        unless result
          raise Exception, "Failed to change directory."
        end
      end
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {:dir_name => dir_name}})
  end
  result
end

# File lib/gxg/net_clients.rb, line 5141
def present_directory()
  result = nil
  begin
    if @client
      if @client.closed?
        raise Exception, "Attempted to access a closed session"
      else
        result = @client.pwd()
      end
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {}})
  end
  result
end

# File lib/gxg/net_clients.rb, line 5044
def put_file(local_path=nil, remote_file=nil)
  result = false
  begin
    if @client
      result = @client.putbinaryfile(local_path, remote_file, 1024)
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {:local_path => local_path, :remote_file => remote_file}})
  end
  result
end

# File lib/gxg/net_clients.rb, line 5203
def remove_directory(dir_name=nil)
  result = false
  begin
    if @client
      if @client.closed?
        raise Exception, "Attempted to access a closed session"
      else
        unless dir_name
          raise ArgumentError, "You MUST provide a directory name to remove."
        end
        result = @client.rmdir(dir_name)
        unless result
          raise Exception, "Failed to remove directory."
        end
      end
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {:dir_name => dir_name}})
  end
  result
end

# File lib/gxg/net_clients.rb, line 5081
def remove_file(file_name=nil)
  result = false
  begin
    if @client
      if @client.closed?
        raise Exception, "Attempted to access a closed session"
      else
        unless file_name
          raise ArgumentError, "You MUST provide a file name to remove."
        end
        result = @client.delete(file_name)
        unless result
          raise Exception, "Failed to remove file."
        end
      end
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {:file_name => file_name}})
  end
  result
end

# File lib/gxg/net_clients.rb, line 5056
def rename_file(file_name=nil, new_file_name=nil)
  result = false
  begin
    if @client
      if @client.closed?
        raise Exception, "Attempted to access a closed session"
      else
        unless file_name
          raise ArgumentError, "You MUST provide a current file name to rename."
        end
        unless new_file_name
          raise ArgumentError, "You MUST provide a new name to rename the file."
        end
        result = @client.rename(file_name, new_file_name)
        unless result
          raise Exception, "Failed to rename file."
        end
      end
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {:file_name => file_name, :new_file_name => new_file_name}})
  end
  result
end

# File lib/gxg/net_clients.rb, line 5006
def reopen()
  result = false
  begin
    if @client
      if @client.closed?
        @client.connect()
        if @client.closed?
          raise Exception, "Failed to re-open connection."
        end
      else
        result = true
      end
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {}})
  end
  result
end

# File lib/gxg/net_clients.rb, line 4968
def send_account_info(acct_info=nil)
  result = false
  begin
    if @client
      if @client.closed?
        raise Exception, "Attempted to access a closed connection."
      else
        unless acct_info.is_a?(::String)
          raise ArgumentError, "You MUST provide account information (as a String)."
        end
        result = @client.acct(acct_info)
      end
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {:account_info => acct_info}})
  end
  result
end

# File lib/gxg/net_clients.rb, line 4987
def send_command(command=nil)
  result = nil
  begin
    if @client
      if @client.closed?
        raise Exception, "Attempted to access a closed connection."
      else
        unless command.is_a?(::String)
          raise ArgumentError, "You must provide a String to issue FTP commands."
        end
        result = @client.sendcmd(command)
      end
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {:command => command}})
  end
  result
end

# File lib/gxg/net_clients.rb, line 4920
def status()
  result = nil
  begin
    if @client
      if @client.closed?
        raise Exception, "Attempted to access a closed connection."
      else
        result = @client.status()
      end
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {}})
  end
  result
end

# File lib/gxg/net_clients.rb, line 4936
def system_info()
  result = nil
  begin
    if @client
      if @client.closed?
        raise Exception, "Attempted to access a closed connection."
      else
        result = @client.system()
      end
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {}})
  end
  result
end