class ModuleApp
  include Mongoid::Document
  include Mongoid::Timestamps

  field :title, type: String
  field :key, type: String
  field :taggable, type: Boolean, default: false
  field :categorizable, type: Boolean, default: false
  field :authorizable, type: Boolean, default: false
  field :frontend_enable, type: Boolean, default: false
  field :sidebar_order,type: Integer,default: 0
  field :authorizable_models, type: Array
  field :widget_enable, type: Boolean, default: false
  
  has_many :categories, dependent: :destroy, :autosave => true
  has_and_belongs_to_many :tags, dependent: :destroy, :autosave => true
  has_many :authorizations

  scope :frontend_enabled, ->{ where(:frontend_enable => true)}
  scope :widget_enabled, ->{ where(:widget_enable => true)}

  def refetch_setting!(reg)
    self[:taggable] = reg.is_taggable
    self[:categorizable] = reg.is_categorizable
    self[:authorizable] = reg.is_authorizable
    self[:authorizable_models] = reg.get_authorizable_models
    self[:frontend_enable] = reg.is_frontend_enabled
    self[:widget_enable] = reg.is_widget_enabled
  end

  def get_registration
    OrbitApp::Module::Registration.find_by_key(key)
  end

  def self.find_by_key(key)
  	self.find_by(:key => key)
  end

  def module_name
    I18n.t(get_registration.get_label_i18n)
  end

  def label
    I18n.t(label_i18n)
  end

  def label_i18n
    reg = get_registration
    reg.nil? ?  'Init is not defined completely' : get_registration.get_label_i18n
  end

  def taggable
    get_registration.is_taggable
  end

  def taggable_model
    get_registration.taggable_model
  end

  def categorizable
    get_registration.is_categorizable
  end

   def user_can_manage?
    self.workgroup.key.eql?("manager")
  end
  
  def authorizable
    get_registration.is_authorizable
  end

  def user_module_managers
    Authorization.module_authorized_users(self).pluck(:user_id)
  end

  def role_managers
    Authorization.module_authorized_users(self).pluck(:role_id)
  end
  
  def module_managers
    workgroup = Workgroup.find_by(key: 'sub_managers')
    authorized_users = Authorization.module_authorized_users(self).where(:user_id.ne => nil, :workgroup_id.ne => workgroup.id).map {|u| u.user} rescue nil
    authorized_members = Authorization.module_authorized_users(self).where(:role_id.ne => nil).map {|m| m.role.member_profiles}.first rescue nil
    users_authorized_by_role = authorized_members.map {|u| u.user} rescue []
    authorized_users.inject(users_authorized_by_role, :<<) rescue []
  end

  def data_count
    get_registration.get_data_count
  end
end