require 'zonefile'
require 'puppet/functions/zones'

Puppet::Type.type(:dns_record).provide(:zonefile) do

  # def initialize(*args)
  #   super
  #   # zone_name = resource[:zone]
  #   resource[:notify] = [
  #     "Dns_zone[adrift.space]"
  #   ]
  #   puts "notify = #{resource[:notify]}"
  # end

  def self.instances
    puts "Instances"
    [ new(type: :A,
          value: '1.2.3.4',
          name: "Test",
          zone: 'adrift.space',
         ),
    ]

  end

  def create
    # context.notice("Creating #{name} with #{should}")
    zone = get_zone(resource[:zone])
    type = resource[:type]
    data = {
      :name => resource[:key],
    }

    if resource[:ttl]
      data[:ttl] = resource[:ttl]
    end

    # :SOA

    case type
    when :A, :MX, :CNAME, :A4, :AAAA, :PTR, :SRV
      data[:host] = resource[:value]
    when :TXT
      data[:text] = resource[:value]
    end

    remove_record(zone, resource)

    case type
    when :AAAA
      zone.add_record(:a4, data)
    else
      zone.add_record(type, data)
    end
  end

  # private
  def remove_record(zone, record_to_remove)
    case type
    when :AAAA
      zone.a4.reject! {|record| record[:name] == record_to_remove[:key] }
    when nil
      Zonefile::RECORDS.map{|t| t.downcase.intern}.each do |t|
        zone.records[t].reject! {|record| record[:name] == record_to_remove[:key] }
      end
    else
      zone.records[type.downcase.intern].reject! {|record| record[:name] == record_to_remove[:key] }
    end
  end

  def destroy
    zone = get_zone(resource[:zone])
    remove_record(zone, resource)
  end

  def exists?
    !! find_self
  end

  def find_self
    zone = get_zone(resource[:zone])
    t = resource[:type]
    case t
    when nil
      dataset = Zonefile::RECORDS.map {|t| t.downcase.intern}.map {|t| zone.records[t]}.flatten
      dataset.find {|record| record[:name] == resource[:key]}
    when :AAAA
      zone.a4.find {|record| record[:name] == resource[:key]}
    else
      zone.records[t.downcase.intern].find {|record| record[:name] == resource[:key]}
    end
  end

  # Setting new values on type or key doesn't make sense, since they
  # are our primary keys.

  def type
    resource[:type]
  end

  def key
    resource[:key]
  end

  def value
    record = find_self
    record && record[:host]
  end

  def value=(value)
    record = find_self
    # Puppet creates the resources instead of setting it the fetch
    # method failed
    record[:host] = value
  end

  def ttl
    record = find_self
    record && record[:ttl]
  end

  def ttl=(value)
    record = find_self
    record[:ttl] = value
  end
end