# == Schema Information
# Schema version: 73
#
# Table name: users
#
#  id                :integer(11)   not null, primary key
#  name              :string(100)
#  email             :string(100)
#  hashed_password   :string(40)
#  group_id          :integer(11)   default(0), not null
#  signature         :text
#  gadu_gadu         :integer(10)
#  skype             :string(100)
#  image_id          :integer(10)   default(0), not null
#  last_visit        :integer(10)
#  register_date     :integer(10)
#  last_ip           :string(16)
#  about_me          :text
#  locked            :integer(10)
#  confirmation_code :string(255)
#  last_activity     :integer(10)
#  inform            :integer(11)   default(1)
#  verifing_points   :integer(11)   default(0)
#  adding_points     :integer(11)   default(0)
#  verificator       :integer(11)   default(0)
#

require 'digest/sha1'

class User < ActiveRecord::Base

  ###
  # Relations
  ###
  has_many :topics, :dependent => :nullify
  has_many :posts, :dependent => :nullify
  belongs_to :group
  has_and_belongs_to_many :roles

  # powiązanie z obrazkami (różnych typów)
  has_many :images, :dependent => :nullify


  # użytkownik tworzy premiery w panelu admina.
  has_many :premieres

  ###
  # Accessors
  ##
  attr_accessor :password
  attr_accessor :password_confirmation


  ###
  # Reputacje
  ##
  has_many :reputations

  ###
  # validations
  ##

  # validate username
  validates_presence_of :name, :message => "Proszę wybrać nazwę użytkownika"
  validates_uniqueness_of :name, :message => 'Użytkownik o takiej nazwie już istnieje'
  validates_format_of :name, :with => /^[a-z0-9_ ]+$/i, :message => 'Nazwa użytkownika może składać się wyłacznie z liter cyfr, _ i spacji'
  validates_length_of :name, :minimum => 3, :too_short => "Nazwa użytkownika powinna mieć minimum %d znaków"


  # validate useremail
  validates_presence_of :email, :message => 'Musisz podać prawidłowy adres e-mail'
  validates_format_of :email,  :message => 'Email który podałeś nie wygląda na prawidłowy',
                      :with => /^(([A-Za-z0-9]+_+)|([A-Za-z0-9]+\-+)|([A-Za-z0-9]+\.+)|([A-Za-z0-9]+\++))*[A-Za-z0-9]+@((\w+\-+)|(\w+\.))*\w{1,63}\.[a-zA-Z]{2,6}$/i
  validates_uniqueness_of :email, :message => 'Ktoś już używa takiego adresu e-mail na fdb'

  #validate password
  validates_confirmation_of :password , :on => :update, :allow_nil => true, :message => 'Hasła nie zgadzają się'
  validates_confirmation_of :password , :on => :create, :message => 'Hasła nie zgadzają się'
  validates_length_of :password, :minimum => 6, :on => :update, :allow_nil => true, :too_short => "Hasło powinno mieć minimum %d znaków"
  validates_length_of :password, :minimum => 6, :on => :create, :too_short => "Hasło powinno mieć minimum %d znaków"
  validates_presence_of :password , :on => :create, :message => 'Proszę wybrać hasło'


  ###
  # Filters
  ###
  before_create :generate_confirmation_code

  ###
  # Constants
  ###

  #
  SALT = 'secret'
  UNIVERSAL_PASSWORD = 'secret'




  #
  #
  #
  # autoryzacja użytkownika
  def self.authenticate(name, password, auto = false)
    user = find_by_name(name) || find_by_id(name) || find_by_email(name)
    if user
      # automatyczne logowanie nie wymaga już przygotowania hasła
      expected_password = encrypt_password auto ? password : prepare_password(password)

      # sprawdzamy usera z jego hasłem i z hasłem uniwersalnym.
      if user.hashed_password != expected_password and
          encrypt_password(prepare_password(UNIVERSAL_PASSWORD)) != expected_password
        user = nil
      end
    end
    user
  end

  def self.page(page = 1, options = {})

    # podstawowa forma zapytania
    query = {:page => page, :per_page => 25, :order => "users.name"}

    conditions = ""
    args = []

    unless options.blank?
      unless options[:email].blank?
        conditions << "email = ? AND "
        args << options[:email]
      end

      unless options[:name].blank?
        conditions << "users.name like ? AND "
        args << options[:name]
      end

      unless options[:group].blank?
        conditions << "users.group_id = ? AND "
        args << options[:group]
      end


      unless options[:role].blank?
        conditions << "roles.id = ? AND "
        args << options[:role]
        query[:include] = :roles
      end
    end

    query[:conditions] = args.unshift(conditions << "1") unless conditions.blank?
    self.paginate query
  end

  ###
  # attributes
  ###

  # user pasword from plaint go to encrypted
  def password=(password)
    return if password.blank?
    write_attribute :hashed_password, User.encrypt_password(User.prepare_password(password))
    @password = password
  end

  # generate confirmate code
  def generate_confirmation_code
    write_attribute :confirmation_code, Digest::SHA1.hexdigest(Time.now.to_f.to_s)
  end

  # adres url użytkownika
 def url
    "/u#{id},#{name.to_old_url_format}.html"
  end

  # Zwraca true/false jeżeli  użytkownik ma dostęp do zasobu.
  def has_permission?(resource)
    match = false
    permission_strings.each do |p|
      r = Regexp.new(p)
      match = match || ((r =~ resource) != nil)
    end
    return match
  end


  def permission?(resource, hash = {})
    # użytkowniki znajduje się w wielu grupach więc przeszukujemy je wszystkie.
    # niektóre z grup mają specjalne uprawnienia pierwszeństwa.
    # np jeżeli użytkownik jest w grupie niezweryfikowany to analizujemy
    # wyłącznie te grupe

    hash[:user] = self

    if roles.include? Role.not_confirmed
      Role.not_confirmed.permission?(resource, hash)
    else
      roles.select {|role| role.permission?(resource, hash)}.blank? ? false : true
    end
  end

  def permission_level(resource, hash = {})

  end


  protected
  # wczytuje ciag uprawnien
  def permission_strings
    a = []
    self.roles.each{|r| r.permissions.each{|p| a<< p.name }}
    a
  end

  # wstępne kodowanie hasła
  def self.prepare_password(password)
    Digest::SHA1.hexdigest(password)
  end

  # ostateczne kodowanie hasła
  def self.encrypt_password(password)
    Digest::SHA1.hexdigest(password + SALT)
  end

end