# == Schema Information
# Schema version: 20090120184410
#
# Table name: orders
#
#  id                 :integer(4)      not null, primary key
#  supplier_id        :integer(4)
#  note               :text
#  starts             :datetime
#  ends               :datetime
#  state              :string(255)     default("open")
#  lock_version       :integer(4)      default(0), not null
#  updated_by_user_id :integer(4)
#

class Order < ActiveRecord::Base
  extend ActiveSupport::Memoizable    # Ability to cache method results. Use memoize :expensive_method
  acts_as_ordered :order => "ends"    # easyier find of next or previous model

  # Associations
  has_many :order_articles, :dependent => :destroy
  has_many :articles, :through => :order_articles
  has_many :group_orders, :dependent => :destroy
  has_many :ordergroups, :through => :group_orders
  has_one :invoice
  has_many :comments, :class_name => "OrderComment", :order => "created_at"
  belongs_to :supplier
  belongs_to :updated_by, :class_name => "User", :foreign_key => "updated_by_user_id"

  # Validations
  validates_presence_of :supplier_id, :starts
  validate_on_create :starts_before_ends, :include_articles

  # Callbacks
  after_update :update_price_of_group_orders
 
  # Finders
  named_scope :open, :conditions => { :state => 'open' },
    :order => 'ends DESC'
  named_scope :finished, :conditions => "state = 'finished' OR state = 'closed'",
    :order => 'ends DESC'
  named_scope :finished_not_closed, :conditions => { :state => 'finished' },
    :order => 'ends DESC'
  named_scope :closed, :conditions => { :state => 'closed' },
    :order => 'ends DESC'

  # Create or destroy OrderArticle associations on create/update
  def article_ids=(ids)
    # fetch selected articles
    articles_list = Article.find(ids)
    # create new order_articles
    (articles_list - articles).each { |article| order_articles.build(:article => article) }
    # delete old order_articles
    articles.reject { |article| articles_list.include?(article) }.each do |article|
      order_articles.detect { |order_article| order_article.article_id == article.id }.destroy
    end
  end

  def open?
    state == "open"
  end

  def finished?
    state == "finished"
  end

  def closed?
    state == "closed"
  end

  # search GroupOrder of given Ordergroup
  def group_order(ordergroup)
    group_orders.first :conditions => { :ordergroup_id => ordergroup.id }
  end
  
  # Returns OrderArticles in a nested Array, grouped by category and ordered by article name.
  # The array has the following form:
  # e.g: [["drugs",[teethpaste, toiletpaper]], ["fruits" => [apple, banana, lemon]]]
  def get_articles
    order_articles.all(:include => [:article, :article_price], :order => 'articles.name').group_by { |a|
      a.article.article_category.name
    }.sort { |a, b| a[0] <=> b[0] }
  end
  memoize :get_articles
  
  # Returns the defecit/benefit for the foodcoop
  # Requires a valid invoice, belonging to this order
  def profit(options = {})
    markup = options[:with_markup] || true
    if invoice
      groups_sum = markup ? sum(:groups) : sum(:groups_without_markup)
      groups_sum - invoice.net_amount
    end
  end
  
  # Returns the all round price of a finished order
  # :groups returns the sum of all GroupOrders
  # :clear returns the price without tax, deposit and markup
  # :gross includes tax and deposit. this amount should be equal to suppliers bill
  # :fc, guess what...
  def sum(type = :gross)
    total = 0
    if type == :clear || type == :gross || type == :fc
      for oa in order_articles.ordered.all(:include => [:article,:article_price])
        quantity = oa.units_to_order * oa.price.unit_quantity
        case type
        when :clear
          total += quantity * oa.price.price
        when :gross
          total += quantity * oa.price.gross_price
        when :fc
          total += quantity * oa.price.fc_price
        end
      end
    elsif type == :groups || type == :groups_without_markup
      for go in group_orders
        for goa in go.group_order_articles
          case type
          when :groups
            total += goa.quantity * goa.order_article.price.fc_price
          when :groups_without_markup
            total += goa.quantity * goa.order_article.price.gross_price
          end
        end
      end
    end
    total
  end

  # Finishes this order. This will set the order state to "finish" and the end property to the current time.
  # Ignored if the order is already finished.
  def finish!(user)
    unless finished?
      Order.transaction do
        # Update order_articles. Save the current article_price to keep price consistency
        order_articles.all(:include => :article).each do |oa|
          oa.update_attribute(:article_price, oa.article.article_prices.first)
        end
        # set new order state (needed by notify_order_finished)
        update_attributes(:state => 'finished', :ends => Time.now, :updated_by => user)

        # TODO: delete data, which is no longer required ...
        # group_order_article_quantities... order_articles with units_to_order == 0 ? ...
      end

      # notify order groups
      notify_order_finished
    end
  end

  # TODO: I can't understand, why its going out from the group_order_articles perspective.
  # Why we can't just iterate through the order_articles?
  #
  # Updates the ordered quantites of all OrderArticles from the GroupOrderArticles.
  # This method is fired after an ordergroup has saved/updated his order.
  def update_quantities
    indexed_order_articles = {}  # holds the list of updated OrderArticles indexed by their id
    # Get all GroupOrderArticles for this order and update OrderArticle.quantity/.tolerance/.units_to_order from them...
    group_order_articles = GroupOrderArticle.all(:conditions => ['group_order_id IN (?)', group_order_ids],
                                                 :include => [:order_article])
    for goa in group_order_articles
      if (order_article = indexed_order_articles[goa.order_article.id.to_s])
        # order_article has already been fetched, just update...
        order_article.quantity = order_article.quantity + goa.quantity
        order_article.tolerance = order_article.tolerance + goa.tolerance
        order_article.units_to_order = order_article.article.calculate_order_quantity(order_article.quantity, order_article.tolerance)
      else
        # First update to OrderArticle, need to store in orderArticle hash...
        order_article = goa.order_article
        order_article.quantity = goa.quantity
        order_article.tolerance = goa.tolerance
        order_article.units_to_order = order_article.article.calculate_order_quantity(order_article.quantity, order_article.tolerance)
        indexed_order_articles[order_article.id.to_s] = order_article
      end
    end
    # Commit changes to database...
    OrderArticle.transaction do
      indexed_order_articles.each_value { | value | value.save! }
    end
  end
  
  # Sets order.status to 'close' and updates all Ordergroup.account_balances
  def close!(user)
    raise "Bestellung wurde schon abgerechnet" if closed?
    transaction_note = "Bestellung: #{supplier.name}, bis #{ends.strftime('%d.%m.%Y')}"

    gos = group_orders.all(:include => :ordergroup)       # Fetch group_orders
    gos.each { |group_order| group_order.update_price! }  # Update prices of group_orders

    transaction do                                        # Start updating account balances
      for group_order in gos
        price = group_order.price * -1                    # decrease! account balance
        group_order.ordergroup.addFinancialTransaction(price, transaction_note, user)
      end
      self.update_attributes! :state => 'closed', :updated_by => user
    end
  end
  
  protected

  def starts_before_ends
     errors.add(:ends, "muss nach dem Bestellstart liegen (oder leer bleiben)") if (ends && starts && ends <= starts)
  end

  def include_articles
    errors.add(:order_articles, "Es muss mindestens ein Artikel ausgewählt sein") if order_articles.empty?
  end

  private
  
  # Updates the "price" attribute of GroupOrders or GroupOrderResults
  # This will be either the maximum value of a current order or the actual order value of a finished order.
  def update_price_of_group_orders
    group_orders.each { |group_order| group_order.update_price! }
  end

  # Sends "order finished" messages to users who have participated in this order.
  def notify_order_finished
    for group_order in self.group_orders
      ordergroup = group_order.ordergroup
      logger.debug("Send 'order finished' message to #{ordergroup.name}")
      # Determine users that want a notification message:
      users = ordergroup.users.reject{|u| u.settings["notify.orderFinished"] != '1'}
      unless users.empty?
        # Create user notification messages:
        Message.from_template(
          'order_finished',
          {:group => ordergroup, :order => self, :group_order => group_order},
          {:recipients_ids => users.collect(&:id), :subject => "Bestellung beendet: #{supplier.name}"}
        ).save!
      end
    end
  end

end