# frozen_string_literal: true

module Cryptum
  # This plugin is used to indicate if the Weighted Executed Buy Orders are less than the Weighted Excuted Sell Orders

  module OrderBook
    module WeightedAvg
      # Supported Method Parameters::
      # Cryptum::OrderBook::WeightedAvg.status(
      #   order_book: 'required - order_book data structure'
      # )

      public_class_method def self.status(opts = {})
        order_book = opts[:order_book]
        order_history = order_book[:order_history]
        indicator_status = opts[:indicator_status]
        invested = opts[:invested]

        indicator_hash = {}
        indicator_hash[:invested] = invested

        buy_orders_done = order_history.select do |orders|
          orders[:side] == 'buy' &&
            orders[:status] == 'done' &&
            orders[:done_reason] == 'filled'
        end

        total_buy_orders_done = buy_orders_done.length
        avg_buy_exec = format('%0.7f', 0.00).to_f
        # total_buy_executed = 0.00
        # total_invested = 0.00
        # buy_fees = 0.00
        if total_buy_orders_done.positive?
          # Calculate Weighted Avg. of Completed Buy Orders
          weighted_buy_prices_arr = []
          buy_orders_done.each do |order|
            weighted_hash = {}
            executed_value = order[:executed_value].to_f
            filled_size = order[:filled_size].to_f
            weighted_hash[:price] = (executed_value / filled_size).to_f
            weighted_hash[:filled_size] = filled_size
            weighted_hash[:price_times_filled_size] = weighted_hash[:price] * filled_size
            weighted_buy_prices_arr.push(weighted_hash)
          end

          price_times_filled_size = weighted_buy_prices_arr.sum do |orders|
            orders[:price_times_filled_size].to_f
          end

          this_filled_size = weighted_buy_prices_arr.sum do |orders|
            orders[:filled_size]
          end

          calc_avg_buy_exec = price_times_filled_size / this_filled_size
          avg_buy_exec = format('%0.7f', calc_avg_buy_exec).to_f

          executed_value = buy_orders_done.sum do |orders|
            orders[:executed_value].to_f
          end

          # total_buy_executed = format('%0.7f', executed_value).to_f

          # fill_fees = buy_orders_done.sum do |orders|
          #   orders[:fill_fees].to_f
          # end

          # buy_fees = format('%0.7f', fill_fees).to_f

          # calc_total_invested = total_buy_executed.to_f - buy_fees.to_f
          # total_invested = format('%0.7f', calc_total_invested).to_f
        end
        order_book[:avg_buy_exec] = avg_buy_exec

        sell_orders_done = order_history.select do |orders|
          orders[:side] == 'sell' &&
            orders[:status] == 'done' &&
            orders[:done_reason] == 'filled'
        end

        total_sell_orders_done = sell_orders_done.length
        avg_sell_exec = format('%0.7f', 0.00).to_f
        # total_sell_executed = format('%0.7f', 0.00).to_f
        # total_return = format('%0.7f', 0.00).to_f
        # sell_fees = format('%0.7f', 0.00).to_f
        if total_sell_orders_done.positive?
          # Calculate Weighted Avg. of Completed Sell Orders
          weighted_sell_prices_arr = []
          sell_orders_done.each do |order|
            weighted_hash = {}
            executed_value = order[:executed_value].to_f
            filled_size = order[:filled_size].to_f
            weighted_hash[:price] = (executed_value / filled_size).to_f
            weighted_hash[:filled_size] = filled_size
            weighted_hash[:price_times_filled_size] = weighted_hash[:price] * filled_size
            weighted_sell_prices_arr.push(weighted_hash)
          end

          price_times_filled_size = weighted_sell_prices_arr.sum do |orders|
            orders[:price_times_filled_size].to_f
          end

          this_filled_size = weighted_sell_prices_arr.sum do |orders|
            orders[:filled_size]
          end

          calc_avg_sell_exec = price_times_filled_size / this_filled_size
          avg_sell_exec = format('%0.7f', calc_avg_sell_exec).to_f

          executed_value = sell_orders_done.sum do |orders|
            orders[:executed_value].to_f
          end

          # total_sell_executed = format('%0.7f', executed_value).to_f

          # fill_fees = sell_orders_done.sum do |orders|
          #   orders[:fill_fees].to_f
          # end

          # sell_fees = format('%0.7f', fill_fees).to_f
          # calc_total_made = total_sell_executed.to_f - sell_fees.to_f
          # total_return = format('%0.7f', calc_total_made).to_f
        end
        order_book[:avg_sell_exec] = avg_sell_exec

        if avg_buy_exec < avg_sell_exec
          indicator_hash[:color] = :green
          weight_op = '<'
        elsif avg_buy_exec > avg_sell_exec
          indicator_hash[:color] = :red
          weight_op = '>'
        else
          indicator_hash[:color] = :yellow
          weight_op = '=='
        end
        weighted_avg_status_out = "VWAPB #{weight_op} VWAPS"
        order_book[:candles].last[:weighted_avg_status] = weighted_avg_status_out
        indicator_hash[:status] = weighted_avg_status_out
        # indicator_hash[:order_book] = order_book

        indicator_status.weighted_avg = indicator_hash
        # indicator_hash
      rescue StandardError => e
        raise e
      end

      # Display Usage for this Module

      public_class_method def self.help
        puts "USAGE:
         weighted_avg_indicator_hash = #{self}.status(
           order_book: 'required - order_book data structure'
         )
        "
      end
    end
  end
end