# cgi's for the tutorial sign up

require 'cgi'
class CgiDb

  def initialize(fName, paramList)
    @fileName = fName
    @paramList = paramList
    @db = DataFile.new(fName)
  end


  def get_value(name)
    ans = ""
    @param[name].each{ |n|
      if !n
	next
      end
      n.strip!
      if n.size == 0
	next
      end
      if ans.size > 0
	ans = ans + ";" + n
      else
	ans = ans + n
      end
    }
    return nil if ans == ""
    return ans;
  end

  def getEntryKey
    if ! f = get_value("first")
      return nil
    end
    if ! l = get_value("last")
      return nil
    end
    if ! s = get_value("nospam")
      return nil
    end
    if s != "machine"
      return nil
    end
    f + " " + l
  end


  def insertEntry(cgi)
    @param = cgi.params
    if ! entry_key = getEntryKey
      return nil
    end
    @db[entry_key] = ""
    @paramList.each { |name, key|
      n = get_value(key)
      if n
	@db.append(entry_key, name, n)
      end
    }
    return entry_key
  end

  def writeToFile
    @db.writeToFile
  end

  def writeEntry(fd, section)
    @db.writeEntry(fd, section)
  end

end # class CgiDb


class DataFile < Hash

  def initialize(fName)
    @fileName = fName
    if ! fd = open(fName,"r")
      $stderr.puts "Cannot open #{fName}"
    end
    parse_db(fd)
    fd.close
  end

  def appendToDb(key, str)
    if !self[key]
      self[key] = ""
    end
    self[key] = self[key]+str+"\n"
  end

  def append(section, name, val)
    appendToDb(section, "#{name}: #{val}")
    appendToDb(section, "<br/>")
  end

  def parse_db(dbFile)
    key = nil
    dbFile.each {|l|
      if m = /\[(.*)\]/.match(l)  # check to see if it is a new entry
	key = m[1]
	self[key]=""
	next # same as continue
      end
      self[key] = self[key]+l if key
    }
  end

  # yield each section name contained in the buffer (same as each)
  def each_section
    each_key { |k|
      yield k
    }
    nil
  end

  # For the given section, yield the entry key-value pairs
  def each_entry(section)
    self[section].scan(/(.*):(.*)/) { |k,v|
      k.strip!
      v.strip!
      yield k,v
    }
  end

  # return the section as a Hash instance
  def getSection(section_name)
    h = Hash.new
    each_entry(section_name) { |k,v| h[k] = v }
    h
  end

  def getEntry(section_key, entry_key)
    if val = self[section_key] 
      each_entry(section_key) { |k,v|
	if entry_key == k
	  return v
	end
      }
    end
    nil
  end

  def writeEntry(fd, k, v = nil)
    fd.puts "["+k+"]"
    # make sure val is well formed and we don't keep adding lines to
    # the file for a simple rewrite of the record.
    db = self
    if ! v
      if !(v = db[k]) 
	return nil;
      end
    end
    val = v.strip
    fd.puts "<br/>" if val.index("<br") != 0
    fd.write val+"\n"
    return true
  end

  def writeToFile(fd = nil)
    iOpenedIt = nil
    if ! fd
      fd = open(@fileName,"w")
      iOpenedIt = true
    end
    self.each{ |k,v|
      if ! writeEntry(fd, k, v)
	return nil
      end
    }
    fd.close if iOpenedIt
  end
end