class CreateAccountsClientsAndUsers < ActiveRecord::Migration
  def self.up
    create_table :accounts do |t|
      t.column :crypted_password, :string, :limit => 255
      t.column :email, :string, :null => false, :limit => 255
      t.column :login, :string, :null => false, :limit => 255
      t.column :name, :string, :null => false
      t.column :remember_token_expires_at, :datetime
      t.column :remember_token, :string, :limit => 255
      t.column :salt, :string, :limit => 255
      t.column :type, :string, :limit => 255, :null => false
      t.timestamps
    end
    create_table :clients do |t|
      t.column :user_id, :integer, :null => false
      t.column :enable_report_access, :boolean, :default => false
    end
    create_table :users do |t|
      t.column :admin, :boolean, :default => false, :null => false
      t.column :company, :string, :limit => 255
      t.column :country, :string, :limit => 255
      t.column :credits, :float, :default => 0, :null => false
      t.column :discount, :integer, :default => 0, :null => false
      t.column :timezone, :string, :limit => 255
      t.column :report_domain, :string, :limit => 255
      t.column :report_logout_address, :string, :limit => 255
      t.column :report_title, :string, :limit => 255
    end
  end

  def self.down
    drop_table :accounts
    drop_table :clients
    drop_table :users
  end
end

require 'digest/sha1'

class Account < ActiveRecord::Base
  acts_as_ferret :fields => [:name, :email, :login]
  attr_accessible :login, :email, :password, :password_confirmation
  attr_accessor :password
  before_save :encrypt_password
  validates_email_veracity_of :email, :timeout => 3
  validates_presence_of :login, :email, :name
  validates_presence_of :password_confirmation, :if => :password_required?
  validates_length_of :password, :within => 4..40, :if => :password_required?
  validates_confirmation_of :password, :if => :password_required?
  validates_length_of :login, :within => 3..40
  validates_length_of :email, :within => 3..100
  validates_uniqueness_of :login, :email, :case_sensitive => false

  # Authenticates a user by their login name and unencrypted password.  Returns the user or nil.
  def self.authenticate(login, password)
    u = find_by_login(login) # need to get the salt
    u && u.authenticated?(password) ? u : nil
  end

  # Encrypts some data with the salt.
  def self.encrypt(password, salt)
    Digest::SHA1.hexdigest("--#{salt}--#{password}--")
  end

  # Encrypts the password with the user salt
  def encrypt(password)
    self.class.encrypt(password, salt)
  end

  def authenticated?(password)
    crypted_password == encrypt(password)
  end

  def remember_token?
    remember_token_expires_at && Time.now.utc < remember_token_expires_at
  end

  # These create and unset the fields required for remembering users between browser closes
  def remember_me
    remember_me_for 2.weeks
  end

  def remember_me_for(time)
    remember_me_until time.from_now.utc
  end

  def remember_me_until(time)
    self.remember_token_expires_at = time
    self.remember_token            = encrypt("#{email}--#{remember_token_expires_at}")
    save(false)
  end

  def forget_me
    self.remember_token_expires_at = nil
    self.remember_token            = nil
    save(false)
  end

  protected

  # before filter
  def encrypt_password
    return if password.blank?
    self.salt = Digest::SHA1.hexdigest("--#{Time.now.to_s}--#{login}--") if new_record?
    self.crypted_password = encrypt(password)
  end

  def password_required?
    crypted_password.blank? || !password.blank?
  end
end

class Client < Account
  belongs_to :user
  has_many :campaigns
  has_many :lists
  has_many :domains
  validates_presence_of :login, :if => Proc.new { |thismodel| thismodel.enable_report_access == true }
  validates_presence_of :password, :if => Proc.new { |thismodel| thismodel.enable_report_access == true }
  validates_uniqueness_of :login, :if => Proc.new { |thismodel| thismodel.enable_report_access == true }
  attr_accessible :enable_report_access
end

class User < Account
  attr_accessible :company, :country, :timezone
  has_many :clients
  has_many :campaigns, :through => :clients
  has_many :lists, :through => :clients
  validates_inclusion_of :discount, :in => 0..100
end