# encoding: utf-8
class Bulletin
  include Mongoid::Document
  include Mongoid::Timestamps
  include Mongoid::MultiParameterAttributes
  include Impressionist::Impressionable

  include OrbitCategory::Categorizable
  include OrbitCoreLib::Preview
  # include OrbitModel::Approval
  include OrbitModel::LanguageRestrict
  include OrbitModel::Status
  include OrbitModel::TimeFrame
  include OrbitTag::Taggable

  # include Tire::Model::Search
  # include Tire::Model::Callbacks

  is_impressionable :counter_cache => { :column_name => :view_count }

  field :title, localize: true
  field :subtitle, localize: true
  field :text, localize: true

  field :create_user_id
  field :update_user_id, :class_name => "User"
  
  field :is_top, :type => Boolean, :default => false
  field :is_hot, :type => Boolean, :default => false
  field :is_hidden, :type => Boolean, :default => false
  field :is_checked, :type => Boolean, :default => false
  field :is_pending, :type => Boolean, :default => true 
  field :is_rejected, :type => Boolean, :default => false 
  field :view_count, :type => Integer, :default => 0
  
  field :not_checked_reason
  
  field :public, :type => Boolean, :default => true

  field :email_sent, :type => Boolean, :default => false
  field :email_sentdate , :type => DateTime
  field :email_user_ids
  field :other_mailaddress
  
  scope :can_display, where(is_checked: true, is_rejected: false, is_pending: false)
  scope :available_for_lang, ->(locale){ where("available_for_#{locale}".to_sym => true) }

  mount_uploader :image, ImageUploader

  has_many :bulletin_links, :autosave => true, :dependent => :destroy
  has_many :bulletin_files, :autosave => true, :dependent => :destroy
  
  accepts_nested_attributes_for :bulletin_files, :allow_destroy => true
  accepts_nested_attributes_for :bulletin_links, :allow_destroy => true
  
  validates :title, :at_least_one => true

  # def to_indexed_json
  #   self.to_json
  # end

  # search_in :title, :subtitle, :text

  #before_save :clean_values, :save_bulletin_links, :save_bulletin_files

  # def self.search(str, options={})
  #     options[:limit] = options[:limit] || 50
  #     # default limit: 50 (mongoDB default: 100)
 
  #     res = self.mongo_session.command({ text: self.collection.name,
  #                   search: str}.merge(options))
 
  #     # We shall now return a criteria of resulting objects!!
  #     self.where(:id.in => res['results'].collect {|o| o['obj']['_id']})
  # end
  
  def bulletin_category_with_title
    self.category.title
  end

  def get_bulletin_category
    self.category
  end

  def share_item
      Item.first(conditions:{name: 'announcement'})
  end  

  def enabled_for_lang(lang)
    eval("self.available_for_#{lang}") rescue false
  end

  def publish_month
    published_at.strftime("%B %Y")
  end

  # def self.search( search = nil, category_id = nil )
  #   if category_id.to_s.size > 0 and search.to_s.size > 0
  #     key = /#{search}/
  #     find(:all, :conditions => {title: key, category_id: category_id}).desc( :is_top, :postdate )
  #   elsif category_id.to_s.size > 0 and search.to_s.size < 1
  #     find(:all, :conditions => {category_id: category_id}).desc( :is_top, :postdate )
  #   elsif search.to_s.size > 0 and category_id.to_s.size < 1
  #     key = /#{search}/
  #     find(:all, :conditions => {title: key}).desc( :is_top, :postdate )
  #   else
  #     find(:all).desc( :is_top, :postdate)
  #   end
  # end


  def self.widget_datas( category_id = nil )
  
    date_now = Time.now
 
   # find(:all, :conditions => {:postdate => {"$lte" => Date.today}, deadline: nil} ).desc( :is_top, :postdate)
   # where( :postdate.lte => date_now ).where( :deadline => nil ).desc(:is_top, :postdate)
   # any_of({ :title => "test" },{:deadline => nil, :title => "123"})
   
   if category_id.to_s.size > 0
     find(:all, :conditions => {category_id: category_id}).any_of( {deadline: nil,:postdate.lte => date_now} , {:deadline.gte => date_now,:postdate.lte => date_now} ).desc( :is_top, :postdate)
   else
     any_of( {deadline: nil,:postdate.lte => date_now} , {:deadline.gte => date_now,:postdate.lte => date_now} ).desc( :is_top, :postdate)
   end
   
  end

  def proc_check(check,not_pass_info = "")
    self.is_checked = true
      if check =="true"
        self.is_rejected = false
      elsif check == "false"
        self.is_rejected = true
        self.not_checked_reason = not_pass_info
      end
  end

  def de_pending
    self.is_pending = false
  end

  def de_pending!
    de_pending
    self.save!
  end

  def is_checked?
    !self.is_pending && self.is_checked && (self.is_rejected == false)
  end
  
  def is_pending?
    self.is_pending
  end
  
  def is_rejected?
    !self.is_pending && self.is_rejected && (self.is_rejected == true)
  end 
  
  def save_bulletin_links
	self.bulletin_links.each do |t|
	  if t.should_destroy
		t.destroy
	  end
    end
  end
  
  def save_bulletin_files
	self.bulletin_files.each do |t|
	  if t.should_destroy
		t.destroy
	  end
    end
  end

  def self.filter(bulletins)
    bulletins.each do |bulletin|
      p "#{bulletin.id}/#{bulletin.is_top}/#{bulletin.is_hot}/#{bulletin.is_hidden}"
    end
    return nil
  end

  def to_preview
    preview_object = Preview.new(:expired_at=>DateTime.now+30.minutes,:preview_at_link=>"panel_announcement_front_end_bulletin_path",:object_class_type=>"Bulletin")

    self.bulletin["bulletin_files_attributes"].each_with_index do |atr,idx| 
      preview_object.preview_files.build(:file=>self.bulletin["bulletin_files_attributes"][idx.to_s],:field_name_for_rebuild=>'bulletin_files',:file_in_array=>true)
    end unless self.bulletin["bulletin_files_attributes"].nil?

    self.bulletin["bulletin_links_attributes"].each_with_index do |atr,idx| 
      preview_object.preview_associations.build(:object=>self.bulletin["bulletin_links_attributes"][idx.to_s],:field_name_for_rebuild=>'bulletin_links',:object_in_array=>true)
    end unless self.bulletin["bulletin_links_attributes"].nil?


    preview_object.object = self.bulletin.except("bulletin_files_attributes","bulletin_links_attributes")
    preview_object
  end

  def get_email_users
    User.find(self.email_user_ids) rescue []
  end

  protected

  # def clean_values
  #   self.bulletin_links.each do |link|
  #     link.delete if link.url.blank? && link.title.blank?
  #   end
  #   self.tag_ids.delete('')
  # end


end