module Effective
  class Log < ActiveRecord::Base
    self.table_name = EffectiveLogging.logs_table_name.to_s

    # These 3 attr_accessors are set on the controller #show actions
    attr_accessor :datatable
    attr_accessor :next_log
    attr_accessor :prev_log

    # Self-Referencing relationship
    belongs_to :parent, class_name: 'Effective::Log', counter_cache: true
    has_many :logs, class_name: 'Effective::Log', foreign_key: :parent_id

    # The user this log item is referring to
    # An associated object, if we wanna add anything extra
    belongs_to :user
    belongs_to :associated, polymorphic: true

    serialize :details, Hash

    # structure do
    #   logs_count          :integer  # Rails Counter Cache
    #   message             :string, :validates => [:presence]
    #   details             :text
    #   status              :string, :validates => [:presence, :inclusion => {:in => EffectiveLogging.statuses }]
    #   timestamps
    # end

    validates :message, presence: true
    validates :status, presence: true, inclusion: { in: (EffectiveLogging.statuses + [EffectiveLogging.log_changes_status, EffectiveLogging.trashable_status]) }

    default_scope -> { order(updated_at: :desc) }

    scope :logged_changes, -> { where(status: EffectiveLogging.log_changes_status)}
    scope :changes, -> { where(status: EffectiveLogging.log_changes_status)}
    scope :trash, -> { where(status: EffectiveLogging.trashable_status)}

    def to_s
      case status
      when EffectiveLogging.trashable_status
        [associated_type, associated_id].join(' ').presence || 'New Trash item'
      else
        "Log #{id}"
      end
    end

    def log(message, status = EffectiveLogging.statuses.first, options = {})
      EffectiveLogger.log(message, status, (options || {}).merge({:parent => self}))
    end

    def details
      self[:details] || {}
    end

    # So this is a Trash item
    # When we delete ourselves, we restore this trash item first
    def restore_trashable!
      raise 'no attributes to restore from' unless details.kind_of?(Hash) && details[:attributes].present?
      associated_type.constantize.new(details[:attributes]).save!
    end

    # def next_log
    #   @next_log ||= Log.unscoped.order(:id).where(:parent_id => self.parent_id).where('id > ?', self.id).first
    # end

    # def prev_log
    #   @prev_log ||= Log.unscoped.order(:id).where(:parent_id => self.parent_id).where('id < ?', self.id).last
    # end

    # Dynamically add logging methods based on the defined statuses
    # EffectiveLogging.info 'my message'
    (EffectiveLogging.statuses || []).each do |status|
      send(:define_method, status) { |message, options={}| log(message, status, options) }
    end

  end
end