class OrderItem < ApplicationRecord
  self.primary_key = "order_items_id"

  #primary key - need to be unique
  before_create :generate_custom_id

  #Associations
  belongs_to :order, autosave: true
  has_one :menu_item, foreign_key: "item_code", primary_key: "item_code"
  has_one :menu_category, through: :menu_item
  # belongs_to :order, counter_cache: true

  #Validation
  validates_presence_of :item_code, :item_name, :qty
  # validates :qty, numericality: { :greater_than => 0 }
  validates_associated :order

  after_save :update_stock_journal

  # after_save :add_to_journal, if: Proc.new { !self.id_changed? }
  # after_save :update_stock_journal, if: Proc.new { self.id_changed? }

  alias_attribute :order_at, :created_at
  alias_attribute :order_by, :item_order_by

  #This Method - handle how items is added into order
  # order_item : {
  #     order_item_code : "",
  #     item_instance_code : "",
  #     quantity : 0,
  #     option_values : [],
  #     sub_order_items : [],
  # }
  def self.processs_item (item_code, instance_code, menu_name, alt_name, account_id, qty,price, options, set_menu_items, order_id, item_order_by, taxable)

    orderitem = OrderItem.create do |oitem|
      oitem.order_id = order_id
      oitem.item_code = item_code
      oitem.item_instance_code = instance_code
      oitem.item_name = menu_name
      oitem.alt_name = alt_name
      oitem.account_id = account_id
      oitem.qty       = qty
      oitem.price   = price
      oitem.taxable = taxable
      oitem.options     = options
      oitem.set_menu_items = set_menu_items
      oitem.item_order_by = item_order_by #person who order this. * If emenu - it will be login user on the app
    end

    #logger.debug orderitem.to_yml
    orderitem.save!
  end

  #Origami : Cashier : to show order items details
  def self.get_order_items_details(booking_id)
    # booking_orders = BookingOrder.where("booking_id=?",booking.booking_id)
    # if booking_orders
    #    booking_orders.each do |book_order|
    #     order_details = OrderItem.select("order_items.item_name,order_items.qty,order_items.price,(order_items.qty*order_items.price) as total_price")
    #        .joins("left join orders on orders.order_id = order_items.order_id")
    #        .where("order_items.order_id=?",book_order.order)
    #     return order_details
    #   end
    # else
    #   return false
    # end

    order_details = OrderItem.select("order_items.item_name,order_items.qty,order_items.price,(order_items.qty*order_items.price) as total_price")
           .joins("left join orders on orders.order_id = order_items.order_id")
           .joins("left join booking_orders on booking_orders.order_id = order_items.order_id")
           .joins("left join bookings on bookings.booking_id = booking_orders.booking_id")
           .where("bookings.booking_id=?",booking_id)

    return order_details
  end

  def self.sync_order_item_records(order_items)
    if !order_items.nil?
      order_items.each do |item|
        order_item = OrderItem.find_by_order_items_id(item['order_items_id'])
        # unless OrderItem.exists?(item['order_items_id'])
        if order_item.nil?
          order_item = OrderItem.new
        end
        order_item.order_items_id = item['order_items_id']
        order_item.order_id = item['order_id']
        order_item.order_item_status = item['order_item_status']
        order_item.item_order_by = item['item_order_by']
        order_item.item_code = item['item_code']
        order_item.item_instance_code = item['item_instance_code']
        order_item.item_name = item['item_name']
        order_item.alt_name = item['alt_name']
        order_item.account_id = item['account_id']
        order_item.qty = item['qty']
        order_item.price = item['price']
        order_item.remark = item['remark']
        order_item.options = item['options']
        order_item.set_menu_items = item['set_menu_items']
        order_item.taxable = item['taxable']
        order_item.completed_by = item['completed_by']
        order_item.save
      end
      Rails.logger.debug '...... order item sync completed. .....'
    end
  end

  protected
  def self.generate_ids(count = 1)
    SeedGenerator.generate_ids(self.name, "ODI", count)
  end

  private

  def generate_custom_id
    if self.order_items_id.nil?
      self.order_items_id = SeedGenerator.generate_id(self.class.name, "ODI")
    end
  end

  def add_to_journal
    defination = InventoryDefinition.find_by_item_code(self.item_instance_code)
    stock = StockJournal.where('item_code = ?', self.item_instance_code).order("id DESC").first
    journal = StockJournal.create(
      item_code: self.item_instance_code,
      credit: 0,
      debit: self.qty,
      balance: stock.balance - self.qty,
      inventory_definition_id: defination.id,
      remark: 'ok',
      trans_ref: self.order.id,
      trans_type: StockJournal::SALES_TRANS
    )
  end

  def update_stock_journal

    unless MenuItemInstance.where("item_instance_name <> ''").pluck(:item_instance_code).include?(self.item_instance_code)
      if self.qty != self.qty_before_last_save
        found, inventory_definition = InventoryDefinition.find_product_in_inventory(self)
        if found
          InventoryDefinition.check_balance(self, inventory_definition)
        end
      end
    end
  end
end