require_dependency "vulgata/application_controller"

module Vulgata
  class AdminController < ApplicationController
    before_action :authorize_admin

    def index
      @languages_count = Vulgata::Helpers.available_locales.count
      @collaborators = vulgata_users.count

      @total_items = Vulgata::TranslationState.group(:item_type, :item_id).count.count
      @pending_items = Vulgata::TranslationState.where(status: Vulgata::TranslationState.statuses[:pending]).group(:item_type, :item_id).count.count

      if Vulgata::TranslationState.any?
        total_translation_states = Vulgata::TranslationState.where.not(status: Vulgata::TranslationState.statuses[:source]).count
        approved_translation_states = Vulgata::TranslationState.where(status: Vulgata::TranslationState.statuses[:approved]).count
        @total_progress = (approved_translation_states.to_f / total_translation_states.to_f * 100).floor
      end
      
      count_translations_by_class      
      count_translations_per_day
    end

    private

    def count_translations_per_day
      sub_query = (Vulgata::TranslationStateVersion.select("vulgata_translation_state_id, MIN(created_at) AS created_at").where(status: Vulgata::TranslationState.statuses[:approved]).group(:vulgata_translation_state_id)).to_sql
      count_by_day = Vulgata::TranslationStateVersion.from("(#{sub_query}) AS sub").select('date(sub.created_at)').where("created_at > ?", 1.month.ago.midnight).group("DATE(sub.created_at)").count
      done_sum = Vulgata::TranslationState.where(status: Vulgata::TranslationState.statuses[:approved]).where(item_type: @classes_translating).count

      sum = done_sum - count_by_day.values.sum
      @approved_per_day = count_by_day.map { |x,y| { x => (sum += y) } }.reduce({}, :merge)
    end

    def count_translations_by_class
      status_count_per_class = {}
      status_count_per_class_query = Vulgata::TranslationState.select("item_type, status, COUNT(status) as count_status").where.not(status: 0).group(:item_type, :status)
      status_count_per_class_query.each do |klass|
        next unless klass.item_type.safe_constantize
        next unless klass.item_type.constantize.respond_to?(:vulgata_name)
        single_status_count = {}
        single_status_count[klass.status] = klass.count_status
        status_count_per_class[klass.item_type] =
          (status_count_per_class[klass.item_type] || {}).merge(single_status_count)
        status_count_per_class[klass.item_type][:sum] = (status_count_per_class[klass.item_type][:sum] || 0) + klass.count_status
      end
      
      @status_percentage_per_class = []
      status_count_per_class.keys.each do |class_name|
        pending_count = status_count_per_class[class_name][:pending] || 0
        in_progress_count = status_count_per_class[class_name][:in_progress] || 0
        done_count = status_count_per_class[class_name][:done] || 0
        approved_count = status_count_per_class[class_name][:approved] || 0
        sum = (status_count_per_class[class_name][:sum] || 0).to_f

        in_progress_percentage = (sum != 0 ? (in_progress_count / sum) * 100 : 0).round(1)
        done_percentage = (sum != 0 ? (done_count / sum) * 100 : 0).round(1)
        approved_percentage = (sum != 0 ? (approved_count / sum) * 100 : 0).round(1)
        pending_percentage = 100 - in_progress_percentage - done_percentage - approved_percentage

        @status_percentage_per_class << { class_name: class_name.constantize.vulgata_name.pluralize,
                                          pending: pending_percentage,
                                          in_progress: in_progress_percentage,
                                          done: done_percentage,
                                          approved: approved_percentage }
      end
    end
  end
end