#This is the Hacker class. Every user of Hackety Hack gets one!
#most of the stuff in this is based off of then sinatra-authentication plugin.
class Hacker
  #our Hacker model is a full-fledged Document
  include MongoMapper::Document

  #we're storing a unique username
  key :username, String, :unique => true

  #and a unique email
  key :email, String, :unique => true

  #a little bit about the Hacker
  key :about, String

  #we don't store the passwords themselves, we store a 'hash' of them. More about this down in password=
  key :hashed_password, String
  key :salt, String

  #this is a flag to let us know if this Hacker can administrate the site or not.
  key :admin, Boolean, :default => false

  #the list of hackers this hacker is following
  key :following_ids, Array
  many :following, :in => :following_ids, :class_name => 'Hacker'

  #the list of hackers that are following this hacker
  key :followers_ids, Array
  many :followers, :in => :followers_ids, :class_name => 'Hacker'

  #after we create a hacker, we want to have them follow steve, and vice versa!
  after_create :follow_steve

  #we don't want to store the password (or the confirmation), so we just make an accessor
  attr_accessor :password, :password_confirmation

  #okay, this is the method that sets the password
  def password=(pass)
    @password = pass
    #okay, we need to get a 'salt'. You can read about salts here: http://en.wikipedia.org/wiki/Salt_(cryptography)
    #basically, we combine the password with the salt, and then encrypt it, and store that in the database.
    #The reason that we do this is because we don't want to keep someone's
    #password in the database, because you never want to write those down!
    #So when we go to look up a password, we can do the same procedure.

    #anyway, let's check if we've got a salt yet. If not, make one.
    self.salt = random_string(10) if !self.salt

    #then, we set the hashed password to the encrypted password + salt.
    self.hashed_password = Hacker.encrypt(@password, self.salt)
  end

  #this method lets will return the user if we've given the right username
  #and password for the user. Otherwise, it returns nil.
  def self.authenticate(username, pass)
    #first we have to dig up the record from the database
    current_user = Hacker.first(:username => username)

    #and return nil if we didn't find one.
    return nil if current_user.nil?

    #then, we do the same thing that we did when we stored the hashed password:
    #encrypt the password using the salt, and compare it to the one we saved
    #if they're the same, we know they entered the right password.
    return current_user if Hacker.encrypt(pass, current_user.salt) == current_user.hashed_password

    #if that didn't work, well, you're all out of luck!
    nil
  end

  #this is just a nice helper function to see if a hacker is an admin
  def admin?
    return self.admin == true
  end

  #a helper function for gravatar urls
  def gravatar_url
    require 'digest/md5'
    "http://www.gravatar.com/avatar/#{Digest::MD5.hexdigest(email.downcase)}"
  end

  #this method makes the hacker follow the followee
  def follow! followee
    following << followee
    save
    followee.followers << self
    followee.save
  end

  #this method makes the hacker unfollow the followee
  def unfollow! followee
    following_ids.delete(followee.id)
    save
    followee.followers_ids.delete(id)
    followee.save
  end

  #this method returns true if we're following the given Hacker, and
  #false otherwise
  def following? hacker
    following.include? hacker
  end

  #this method looks up the programs for a given user
  def programs
    Program.all(:creator_username => username)
  end

  private

  #we're going to use the SHA1 encryption method for now.
  def self.encrypt(password, salt)
    Digest::SHA1.hexdigest(password + salt)
  end

  #this is a nifty little method to give us a random string of characters
  def random_string(len)
    #first, we make a bunch of random characters in an array
    chars = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a
    newpass = ""
    #then we grab a random element of that array, and add it onto our newpass
    1.upto(len) { |i| newpass << chars[rand(chars.size-1)] }
    return newpass
  end

  def follow_steve
    return if username == "steve"
    steve = Hacker.first(:username => 'steve')
    return if steve.nil?

    follow! steve
    steve.follow! self
  end

end