require 'puppet/provider/parsedfile'
sudoers = "/etc/sudoers"

#
# crontab does the same thing, it uses a comment to specify uniqueness
#
 
Puppet::Type.type(:sudoers).provide(
  :parsed, 
  :parent => Puppet::Provider::ParsedFile, 
  :default_target => '/etc/sudoers', 
  :filetype => :flat
) do
 
  desc "The sudoers provider that uses the ParsedFile class"

  commands :visudo => 'visudo'

  # this is just copied from hosts
  text_line :comment, :match => %r{^#}, 
    :post_parse => proc { |record|
    # shameful NAMEVAR hack :(
      if record[:line] =~ /Puppet NAMEVAR (.+)\s*$/
        record[:name] = $1
      end
    } 

  text_line :blank, :match => /^\s*$/;

  #
  # parse lines as either a Defaults, Alias, or User spec.
  #
  # match everything and process entire line
  record_line :parsed, :fields => %w{line},
    :match => /(.*)/,
    :post_parse => proc { |hash|
      Puppet.debug("sudoers post_parse for line #{hash[:line]}")
      # create records for aliases
      parsed = Puppet::Type.type(:sudoers).provider(:parsed)
      if (hash[:line] =~ /^\s*((User|Runas|Host|Cmnd)_Alias)\s+(\S+)\s*=\s*(.+)$/)
        Puppet.debug("parsed line as Alias")
        parsed.parse_alias($1, $3, $4, hash)
      elsif (hash[:line] =~ /^\s*(Defaults\S*)\s*(.*)$/)
        Puppet.debug("parsed line as Defaults")
        parsed.parse_defaults($1, $2, hash)
      elsif (hash[:line] =~ /^\s*(.*)?=(.*)$/)
        Puppet.debug("parsed line as User Spec")
        parsed.parse_user_spec($1, $2, hash)
      else 
        raise Puppet::Error, "invalid line #{hash[:line]}"
      end
#      puts hash.to_yaml
#      hash
    }

  # parse alias lines
  def self.parse_alias(sudo_alias, name, items, hash)
    hash[:type] = 'alias'
    hash[:sudo_alias] = sudo_alias
    hash[:name] = name
    hash[:items] = clean_list(items) 
    hash 
  end

  # parse existing user spec lines from sudoers
  def self.parse_user_spec(users_hosts, commands, hash) 
    hash[:type] = 'user_spec'
    #hash[:name] = user
    #hash[:hosts] = hosts.gsub(/\s/, '').split(',')
    hash[:commands] = clean_list(commands)
    hash_array = users_hosts.split(',')  
    # every element will be a user until the hit the delim
    currentsymbol = :users
    hash[:users] = Array.new
    hash[:hosts] = Array.new
    # parsing users and hosts is kind of complicated, sorry
    hash_array.each do |element|
#puts "!! #{element}"
    # the element that splits users and hosts will be 2 white space delimited strings 
      if element =~ /^\s*(\S+)\s+(\S+)\s*$/
        user, host  = $1, $2
        if currentsymbol == :hosts
          raise Exception, 'found more than one whitespace delim in users_hosts' 
        end
        # sweet we found the delim between user and host
        hash[currentsymbol] << user.gsub(/\s/, '')
        # now everything else will be a host
        currentsymbol=:hosts
        hash[currentsymbol] << host.gsub(/\s/, '')
      elsif element =~ /\s*\S+\s*/
        hash[currentsymbol] << element.gsub(/\s/, '')
      else
        raise Exception, "Malformed user spec line lhs: #{lhs}"
      end
    end
  end 

  # create record for defaults line
  def self.parse_defaults(default, parameters, hash)
    hash[:name] = default
    hash[:type] = 'default'
    hash[:parameters] = parameters.gsub(/\s/, '').split(',')
  end
  
  # can I override this?
  def type=(value)
    raise Puppet::Error, 'not supporting switching NAMEVAR between record types'
  end
  
  # I could use prefetch_hook to support multi-line entries
  # will use the prefetch_hook to determine if
  # the line before us is a commented namevar line
  # only used for user spec.
  # Most of this code is shameless taken from provider crontab.rb
  # NAMEVAR comments leave me in need of a shower, but it seems to be the only way.
  def self.prefetch_hook(records)
    # store comment name vars when we find them
    name=nil
    results = records.each do |record|
      if(record[:record_type] == :comment)
        # if we are a namevar comment
#puts "found a comment: #{record.to_yaml}"
        if record[:name]
#puts "found a comment with :name"
          name = record[:name]
          record[:skip] = true
        end
       # if we are a spec record, check the namevar
      elsif record[:type] == 'user_spec'
        if name
#puts "adding to a record"
          record[:name] = name
          name = nil
        else
          Puppet.info "spec record not created by puppet"
          # probably a pre-exting record not created by puppet
        end 
      end
    end.reject{|record| record[:skip]}
    results
  end

 # overriding how lines are written to the file
  def self.to_line(hash) 
    #puts "\nEntering self.to_line for #{hash[:name]}"
    #puts "\n#{hash.to_yaml}\n"
#    # dynamically call a function based on the value of hash[:type]
    if(hash[:record_type] == :blank || hash[:record_type] == :comment)
      hash[:line]
    elsif(hash[:type] == 'alias')
      self.alias_to_line(hash) 
    elsif(hash[:type] == 'user_spec')
      self.spec_to_line(hash)
    elsif(hash[:type] == 'default')
      self.default_to_line(hash)
    else
      raise Puppet::Error, "dont understand how to write out record \n|#{hash.to_yaml}\n|"
    end
  end

  # write line for user spec records
  def self.spec_to_line(hash)
#puts hash.to_yaml
    #required
    #users=self.array_convert(hash[:users])
    # required
    hosts=self.array_convert(hash[:hosts])
    users=self.array_convert(hash[:users])
    # required
    commands=self.array_convert(hash[:commands])
    str = "#Puppet NAMEVAR #{hash[:name]}"
    str << "\n#{users} #{hosts}=#{commands}"
    Puppet.notice "adding line:  #{str}"
    str
  end

  # write line for alias records
  def self.alias_to_line(hash) 
    # do I need to ensure that the required elements are here?
    # shouldnt the type do that? check file, its similar
    # since different attributes make sense based on ensure value (dir/file/symlink)
    items=self.array_convert(hash[:items])
    str = "#{hash[:sudo_alias]} #{hash[:name]}=#{items}"
    Puppet.notice "adding line: #{str}"
    str
  end

  # write line for default records
  # this is not implemented yet.
  def self.default_to_line(hash)
    parameters=self.array_convert(hash[:parameters])
    str = "#{hash[:name]} #{parameters}"
    Puppet.notice "Adding line #{str}"
    str
  end

  # convert arrays into to , joined lists
  def self.array_convert(list)
    if list.class == Array
      list.join(',')
    else
      list
    end
  end

  # split a list on delim,  trim leading and trailing white-spaces
  def self.clean_list(list, delim=',')
    list.split(delim).collect do |x| 
      x.gsub(/\s*(.*)?\s*/, '\1')
    end
  end

  # used to verify files with visudo before they are flushed 
  # flush seems to be called more than one time?
  def self.flush_target(target)
    Puppet.info("We are flushing #{target}")
    #  a little pre-flush hot visudo action
    #puts File.read(target)
    visudo("-cf", target) unless (File.zero?(target) or !File.exists?(target))
    super(target)
  end
end