class Message < ActiveRecord::Base

  belongs_to :message_content
  belongs_to :parent, :class_name => "Message", :foreign_key => "parent_id"
  belongs_to :user

  has_one :offsetting, :class_name => "Message", :foreign_key => "offsetting_id"
  belongs_to :offsetting, :class_name => "Message", :foreign_key => "offsetting_id"

  has_one :defensive, :class_name => "Message", :foreign_key => "defensive_id"
  belongs_to :defensive, :class_name => "Message", :foreign_key => "defensive_id"

  validates_presence_of :user, :folder, :message_content

  attr_accessor :is_offsetting

  after_create :create_messages

  named_scope :folder, lambda{|folder|
    folder = INBOX if folder.blank?
    {:conditions => {:folder => folder}}
  }
  named_scope :unread, :conditions => {:read => false}
  named_scope :read, :conditions => {:read => true}

  INBOX = 0
  SENT = 1

  def user_title
    if self.folder == INBOX
      self.message_content.from
    else
      self.message_content.to
    end
  end

  def self.get_message(user=nil, folder=0)
    msgs = Message.find(:all, :conditions => ["user_id=? and folder=?", user.id, folder], :select => "DISTINCT ON(thread) *")
    d_msgs = msgs.dup
    d_msgs.each { |m|
      if m.threads.size == 1 && m.message_content.from == user && folder == Message::INBOX
        msgs.delete(m)
      elsif m.threads.size > 1 && m.message_content.from == user && folder == Message::INBOX
        reply = false
        m.threads.each do |mt|
          reply = true if (mt != m) && (mt.message_content.from == m.message_content.to)
        end
        msgs.delete(m) unless reply
      elsif m.threads.size == 1 && m.message_content.to == user && folder == Message::SENT
        msgs.delete(m)
      end
    }
    msgs
  end

  def self.delete_thread(m_id)
    msg = Message.find(m_id)
    threads = msg.threads
    threads.each do |th|
      mc = th.message_content
      th.destroy
      if mc.messages.size == 0
        mc.destroy
      end
    end
  end


  def defensive
    Message.find(:first, :conditions => ["user_id=? and folder=? and message_content_id=?", self.user_id, (self.folder == INBOX ? SENT : INBOX), self.message_content_id])
  end

  def reverse_folder
    self.folder == INBOX ? SENT : INBOX
  end

  def threads
    Message.find(:all, :conditions => { :user_id => self.user_id, :folder => self.folder, :thread => self.thread })
  end

  def offsetting
    user = (self.message_content.to == self.user) ? self.message_content.from : self.message_content.to
    Message.find(:first, :conditions => { :user_id => user.id, :message_content_id => self.message_content.id, :folder => self.reverse_folder, :thread => self.thread })
  end

  def previous
    max_thread = Message.maximum("thread")
    p_thread = self.thread + 1
    while(p_thread <= max_thread)
      p_msg = Message.find(:first, :conditions => { :user_id => self.user_id, :thread => p_thread, :folder => self.folder})
      return p_msg if p_msg
      p_thread = p_thread + 1
    end
    return nil
  end

  def next
    p_thread = self.thread - 1
    while(p_thread > 0)
      p_msg = Message.find(:first, :conditions => { :user_id => self.user_id, :thread => p_thread, :folder => self.folder})
      return p_msg if p_msg
      p_thread = p_thread - 1
    end
    return nil
  end

  def self.max_thread
    max_thread = Message.maximum("thread")
    max_thread ? max_thread + 1 : 1
  end

  private

    def create_messages
      self.read = true
      unless self.is_offsetting
        p = {}
        p[:folder] = INBOX
        p[:is_offsetting] = true
        p[:message_content] = self.message_content
        p[:user] = (self.user == self.message_content.to ? self.message_content.from : self.message_content.to)

        if self.thread
          thread = self.thread
        else
          self.thread = Message.max_thread
          thread = self.thread
          self.save
        end
        p[:thread] = thread

        clone_msg = self.clone
        clone_msg.folder = self.reverse_folder
        clone_msg.is_offsetting = true
        clone_msg.save

        offsetting = Message.create(p)
        clone_offsetting = offsetting.clone
        clone_offsetting.folder = offsetting.reverse_folder
        clone_offsetting.is_offsetting = true
        clone_offsetting.read = true
        clone_offsetting.save
      end
    end

end