require 'rbconfig'
require 'fileutils'

require 'facet/fileutils/safe_ln'
require 'facet/string/tabto'
require 'facet/module/basename'
require 'facet/module/attr_setter'

require 'facet/filelist'
require 'facet/openobject'

#  _____        _     ___                  ___ _
# |_   _|_ _ __| |__ | _ ) __ _ ___ ___   / __| |__ _ ______
#   | |/ _` (_-< / / | _ \/ _` (_-</ -_) | (__| / _` (_-<_-<
#   |_|\__,_/__/_\_\ |___/\__,_/__/\___|  \___|_\__,_/__/__/
#

# Base class for reap tasks.
#
# Here's a simple example:
#
#   class MyTask < Reap::Task
#
#     task_desc 'this is a custom reap task'
#
#     task_attr :mytask
#
#     def init
#       mytask.message ||= 'None Found!'
#     end
#
#     def run
#       puts mytask.message  #=> Hello!
#       puts master.default  #=> Yo!
#       puts mytask.default  #=> Yo!   (inherited from master)
#     end
#   end
#
# With the corresponding settings in the ProjectInfo file as:
#
#   default: Yo!
#
#   mytask:
#     message: Hello!
#

module Reap

  class Task

    include ::Config
    include ::FileUtils

    RUBY = CONFIG['ruby_install_name']

    class << self

      # When this class is inherited the new task is registered.

      def inherited( base )
        task_list[base.task_name] = base
      end

      def task_list
        @task_list ||= {}
      end

      def task_name
        basename.downcase
      end

      def task_desc( text=nil, &block )
        return @task_desc = proc { text } if text
        return @task_desc = block if block_given?
        return @task_desc.call
      end
      #def task_desc ; '(no desciption given)' ; end

      def task_help( text=nil, &block )
        return @task_help = proc { text } if text
        return @task_help = block if block_given?
        return @task_help.call
      end

      def task_attr( name )
        define_method(name) { @task }
      end

      def section_required( val ) ; @section_required = val ; end
      def section_required?       ; @section_required ; end

      def verify?
        if section_required?
          return $PROJECT_INFO.info.key?(task_name)
        end
        true
      end

      def master
        @master ||= CascadingOpenObject.new( $PROJECT_INFO )
      end

#       def master_attributes ; @master_attributes ||= [] ; end
#
#       # Use this DSL method to define master task attributes.
#       def attr_master( *names )
#         attr_accessor *names
#         @master_attributes ||= []
#         @master_attributes |= names.collect { |n| n.to_s }
#       end

      # properties not to be looked up in master
      # if they are not in regular task section

#       def task_only_properties ; @task_only_properties ||= [] ; end
#       def task_only_property( *names )
#         @task_only_properties ||= []
#         @task_only_properties |= names.collect { |n| n.to_s }
#       end

    end #<< class

    # instance methods

    def task_name ; self.class.task_name ; end
    def task_desc ; self.class.task_desc ; end
    def task_help ; self.class.task_help ; end

    def section_required? ; self.class.section_required? ; end

    #def master ; ::ProjectInfo.info ; end
    def master  ; self.class.master  ; end
    def section ; @section ; end
    def task    ; @task    ; end

    def initialize( *args )
      #@master = CascadingOpenObject.new( $PROJECT_INFO )
      section = master[task_name]
      case section
      when Array
        section.each do |s|
          initiate( s )
        end
      else
        initiate( section )
      end
    end

    # Per section

    def initiate( section )
      @section = CascadingOpenObject.new( section )

      task_properties = {}
      #self.class.task_only_properties.each { |t| section[t] ||= nil }
      task_properties = CascadingOpenObject.new( section )
      task_properties.__parent__ = master
      @task = task_properties

      init #task
      run #task
    end

#     def set( sec )
# 
#       #@task = @section #TaskProperties.new( @master, @section )
# 
#       #self.class.master_attributes.each do |k,v|
#       #  send( "#{k}=", @master[k] )
#       #end
# 
#       #@section.each do |k,v|
#       #  send( "#{k}=", v )
#       #end
#     end

    # the two primary methods

    def init
      raise "not implemented for '#{task_name}' task"
    end

    def run
      raise "no action defined for task #{task_name}"
    end

    # Task support methods

    def use_subsection( name )
      subsection = @section.__send__(name)
      if subsection
        subsection.__parent__ = @section
        @task = subsection
      end
    end

    def sh( arg )
      puts arg
      system arg unless $PRETEND
    end

    def provide_setup_rb
      return true if File.exists?( 'setup.rb')
      # copy from data dir to current directory
      f = File.join( Config::CONFIG['datadir'], 'reap', 'setup_rb', 'setup.rb' )
      if File.exists?(f)
        File.cp( f, '.' )
        true
      else
        nil
      end
    end

  end #class Task

end #module Reap