class CORL::Util::Puppet::Resource

# File lib/core/util/puppet/resource.rb, line 12
def initialize(group, info, title, properties = {})
  super({
    :group => group,
    :title => string(title),
    :info  => symbol_map(hash(info)),
    :ready => false
  })
  import(properties) 
end

# File lib/core/util/puppet/resource.rb, line 124
def self.render(resource_info, options = {})
  resource = string_map(resource_info)
  config   = Config.ensure(options)
  
  resource.keys.each do |name|
    if match = name.to_s.match(/^(.+)_template$/)
      target = match.captures[0]
      
      config.set(:normalize_template, config.get("normalize_#{target}", true))
      config.set(:interpolate_template, config.get("interpolate_#{target}", true))
      
      input_data       = resource[target]        
      resource[target] = CORL.template(config, resource[name]).render(input_data)
      
      if config.get(:debug, false)
        CORL.ui.info("\n", { :prefix => false })
        CORL.ui_group("#{resource[name]} template", :cyan) do |ui|
          ui.info("-----------------------------------------------------")
      
          source_dump  = Console.blue(Data.to_json(input_data, true))
          value_render = Console.green(resource[target])       
      
          ui.info("Data:\n#{source_dump}")
          ui.info("Rendered:\n#{value_render}")
          ui.info("\n", { :prefix => false }) 
        end
      end
      resource.delete(name)         
    end
  end
  return resource 
end

# File lib/core/util/puppet/resource.rb, line 61
def defaults(defaults, options = {})
  super(defaults, options)
  
  _set(:ready, false)
  return self 
end

# File lib/core/util/puppet/resource.rb, line 80
def ensure_ready(options = {})
  unless ready
    process(options)
  end
end

# File lib/core/util/puppet/resource.rb, line 25
def group
  return _get(:group)
end

# File lib/core/util/puppet/resource.rb, line 70
def import(properties, options = {})
  super(properties, options)
  
  _set(:ready, false)
  return self  
end

# File lib/core/util/puppet/resource.rb, line 31
def info(default = {})
  return hash(_get(:info, default))
end

# File lib/core/util/puppet/resource.rb, line 37
def info=info
  _set(:info, hash(info))
end

# File lib/core/util/puppet/resource.rb, line 88
def process(options = {})
  config = Config.ensure(options)
  
  tag(config[:tag])
  render(config)
  translate(config)
  
  _set(:ready, true) # Ready for resource creation
  return self
end

# File lib/core/util/puppet/resource.rb, line 55
def ready(default = false)
  return test(_get(:ready, default))
end

# File lib/core/util/puppet/resource.rb, line 159
def render(options = {})
  resource = self.class.render(export, options)
  clear
  import(Config.ensure(resource).export, options)    
  return self
end

# File lib/core/util/puppet/resource.rb, line 101
def tag(tags, append = true)
  unless Data.empty?(tags)
    if tags.is_a?(String)
      tags = tags.to_s.split(/\s*,\s*/)
    else
      tags = tags.flatten
    end
    resource_tags = get(:tag)
    
    if ! resource_tags || ! append
      set(:tag, tags)
    else
      tags.each do |tag|
        resource_tags << tag unless resource_tags.include?(tag)  
      end
      set(:tag, resource_tags)
    end
  end
  return self
end

# File lib/core/util/puppet/resource.rb, line 43
def title(default = '')
  return string(_get(:title, default))
end

# File lib/core/util/puppet/resource.rb, line 49
def title=info
  _set(:title, string(info))
end

# File lib/core/util/puppet/resource.rb, line 168
def translate(options = {})
  config = Config.ensure(options)
  
  set(:before, translate_resource_refs(get(:before), config)) if get(:before)
  set(:notify, translate_resource_refs(get(:notify), config)) if get(:notify)
  set(:require, translate_resource_refs(get(:require), config)) if get(:require)       
  set(:subscribe, translate_resource_refs(get(:subscribe), config)) if get(:subscribe)
  
  return self
end

# File lib/core/util/puppet/resource.rb, line 182
def translate_resource_refs(resource_refs, options = {})
  return :undef if Data.undef?(resource_refs)
  
  config         = Config.ensure(options)
  resource_names = config.get(:resource_names, {})
  title_prefix   = config.get(:title_prefix, '')
  
  title_pattern  = config.get(:title_pattern, '^\s*([^\[\]]+)\s*$')
  title_group    = config.get(:title_var_group, 1)
  title_flags    = config.get(:title_flags, '')
  title_regexp   = Regexp.new(title_pattern, title_flags.split(''))
  
  allow_single   = config.get(:allow_single_return, true)    
  
  type_name      = info[:name].sub(/^\@?\@/, '')
  values         = []
  
  composite_resources = group.composite_resources
      
  case resource_refs
  when String
    if resource_refs.empty?
      return :undef 
    else
      resource_refs = resource_refs.split(/\s*,\s*/)
    end
      
  when ::Puppet::Resource
    resource_refs = [ resource_refs ]  
  end
  
  resource_refs.collect! do |value|
    if value.is_a?(::Puppet::Resource) || ! value.to_s.match(title_regexp)
      value.to_s
        
    elsif resource_names.has_key?(value.to_s)
      if ! title_prefix.empty?
        "#{title_prefix}_#{value}"
      else
        value.to_s
      end
      
    elsif composite_resources.has_key?(value.to_sym) && ! composite_resources[value.to_sym].empty?
      results = []
      composite_resources[value.to_sym].each do |resource_name|
        unless title_prefix.empty?
          resource_name = "#{title_prefix}_#{resource_name}"
        end
        results << resource_name        
      end
      results
      
    else
      nil
    end           
  end
  
  resource_refs.flatten.each do |ref|
    unless ref.nil?        
      unless ref.is_a?(::Puppet::Resource)
        ref = ref.match(title_regexp) ? ::Puppet::Resource.new(type_name, ref) : ::Puppet::Resource.new(ref)
      end
      values << ref unless ref.nil?
    end
  end
  
  return values[0] if allow_single && values.length == 1
  return values
end