require 'quandl/pattern'
require 'quandl/pattern/client'
require 'quandl/operation'
require 'quandl/operation'

class Quandl::Command::Tasks::Download < Quandl::Command::Tasks::Base
  autoload_client_library
  
  syntax "quandl download (SOURCE_CODE/)CODE"
  description "Download a dataset using its quandl code."
  
  warn_unauthenticated_users
  
  options({
    String => {
      order:        t('options.order'),
      transform:    t('options.transform'),
      collapse:     t('options.collapse'),
      trim_start:   t('options.trim_start'),
      trim_end:     t('options.trim_end'),
    },
    Integer => {
      threads:      t('options.threads'),
      limit:        t('options.order'),
      column:       t('options.column'),
      row:          t('options.row'),
      offset:       t('options.offset'),
    }
  })
  
  validates :trim_start, :trim_end, allow_nil: true, format: { with: Quandl::Pattern.dataset_date, message: t('validations.trim_start') }
  validates :order, allow_nil: true, inclusion: { in: ['asc', 'desc'], message: t('validations.order') }
  validates :collapse, allow_nil: true, inclusion: { in: Quandl::Operation::Collapse.valid_collapses.collect(&:to_s), message: t('validations.collapse') }
  validates :transform, allow_nil: true, inclusion: { in: Quandl::Operation::Transform.valid_transformations.collect(&:to_s), message: t('validations.transform') }
  
  def execute
    # download using arguments when present
    return download_each_argument if args.first.present?
    # otherwise download using stdin
    download_each_stdin
  end
  
  def download_each_argument
    args.each do |code|
      pool.process{ download(code) }
    end
    pool.shutdown
  end
  
  def download_each_stdin
    $stdin.each_line do |code|
      pool.process{ download(code.strip.rstrip) }
    end
    pool.shutdown
  end
  
  def download(code)
    timer = Time.now
    # find dataset
    dataset = Quandl::Client::Dataset.find( code )
    # fail fast
    return error(table(Quandl::Client::HTTP_STATUS_CODES[404], code)) if dataset.nil?
    # set data operations
    dataset.data.assign_attributes(data_params) unless dataset.blank?
    # send request & check for errors.
    if !dataset.exists? && !dataset.valid?
      # raise detailed error
      return error( table( dataset.human_status, code, dataset.elapsed_request_time_ms ) )
    end
    # generate qdf
    elapsed = timer.elapsed_ms
    qdf = dataset.to_qdf
    # write to STDOUT
    mutex.synchronize{
      debug("# #{dataset.try(:full_url)} downloaded in #{elapsed}")
      info(qdf)
    }
    true
  end
  
  def trim_start
    options.trim_start
  end
  
  def trim_end
    options.trim_end
  end
  
  def order
    options.order
  end
  
  def collapse
    options.collapse
  end
  
  def transform
    options.transform
  end
  
  def data_params
    params = {}
    self.class.options.each do |class_type, opts|
      opts.each do |name, desc|
        if options.is_a?(OpenStruct)
          params[name] = self.options.send(name)
        else
          params[name] = self.options[name] if self.options[name].present?
        end
        
      end
    end
    params
  end
  
end