# frozen_string_literal: true

#
# Copyright (C) 2013 - present Instructure, Inc.
#
# This file is part of Canvas.
#
# Canvas is free software: you can redistribute it and/or modify it under
# the terms of the GNU Affero General Public License as published by the Free
# Software Foundation, version 3 of the License.
#
# Canvas is distributed in the hope that it will be useful, but WITHOUT ANY
# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
# A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
# details.
#
# You should have received a copy of the GNU Affero General Public License along
# with this program. If not, see <http://www.gnu.org/licenses/>.
#

module Outcomes
  module ResultAnalytics
    include CanvasOutcomesHelper
    include OutcomeResultResolverHelper
    Rollup = Struct.new(:context, :scores)
    Result = Struct.new(:learning_outcome, :score, :count, :hide_points) # rubocop:disable Lint/StructNewOverride

    # Public: Queries learning_outcome_results for rollup.
    #
    # user - User requesting results.
    # opts - The options for the query. In a later version of ruby, these would
    #        be named parameters.
    #        :users    - The users to lookup results for (required)
    #        :context  - The context to lookup results for (required)
    #        :outcomes - The outcomes to lookup results for (required)
    #
    # Returns a relation of the results, suitably ordered.
    def find_outcome_results(user, opts)
      required_opts = %i[users context outcomes]
      required_opts.each { |p| raise "#{p} option is required" unless opts[p] }
      users, context, outcomes = opts.values_at(*required_opts)
      results = LearningOutcomeResult.active.with_active_link.where(
        context_code: context.asset_string,
        user_id: users.map(&:id),
        learning_outcome_id: outcomes.map(&:id)
      )
      # muted associations is applied to remove assignments that students
      # are not yet allowed to view:
      # Assignment Grades have not be posted yet (i.e. Submission.posted_at = nil)
      # PostPolicy.post_manually is false & the submission is not posted
      # Assignment grading_type is not_graded
      # see result_analytics_spec.rb for more details around what is excluded/included
      unless context.grants_any_right?(user, :manage_grades, :view_all_grades)
        results = results.exclude_muted_associations
      end
      # LOR hidden is populated for non-scoring rubrics only which is set
      # by checking Don't post Outcomes results to Learning Mastery Gradebook`
      # when adding a rubric to an assignment
      # also see rubric_assessment.create_outcome_result
      unless opts[:include_hidden]
        results = results.where(hidden: false)
      end
      order_results_for_rollup results
    end

    # Public: Queries Outcome Service to return for outcome results.
    #
    # user - User requesting results.
    # opts - The options for the query. In a later version of ruby, these would
    #        be named parameters.
    #        :users    - The users to lookup results for (required)
    #        :context  - The context to lookup results for (required)
    #        :outcomes - The outcomes to lookup results for (required)
    #        :assignments - The assignments to lookup results for (required)
    #
    # Returns json object
    def find_outcomes_service_outcome_results(opts)
      required_opts = %i[users context outcomes assignments]
      required_opts.each { |p| raise "#{p} option is required" unless opts[p] }
      users, context, outcomes, assignments = opts.values_at(*required_opts)
      user_uuids = users.pluck(:uuid).join(",")
      assignment_ids = assignments.pluck(:id).join(",")

      outcome_ids = outcomes.pluck(:id).join(",")
      get_lmgb_results(context, assignment_ids, "canvas.assignment.quizzes", outcome_ids, user_uuids)
    end

    # Converts json results from OS API to LearningOutcomeResults and removes duplicate result data
    # Tech debt: decouple conversion and removing duplicates
    #
    # results - OS api results json (see get_lmgb_results)
    # context - results context (aka current course)
    #
    # Returns an array of LearningOutcomeResult objects
    def handle_outcomes_service_results(results, context, outcomes, users, assignments)
      # if results are nil - FF is turned off for the given context
      # if results are empty - no results were matched
      if results.blank?
        Rails.logger.warn("No Outcome Service outcome results found for context: #{context.uuid}")
        return nil
      end
      # return resolved results list of Rollup objects
      resolve_outcome_results(results, context, outcomes, users, assignments)
    end

    # Internal: Add an order clause to a relation so results are returned in an
    # order suitable for rollup calculations.
    #
    # relation - The relation to add an order clause to.
    #
    # Returns the resulting relation
    def order_results_for_rollup(relation)
      relation.joins(:user)
              .order(User.sortable_name_order_by_clause)
              .order("users.id ASC, learning_outcome_results.learning_outcome_id ASC, learning_outcome_results.id ASC")
    end

    # Public: Generates a rollup of each outcome result for each user.
    #
    # results - An Enumeration of properly sorted LearningOutcomeResult objects.
    #           The results should be sorted by user id and then by outcome id.
    #
    # users - (Optional) Ensure rollups are included for users in this list.
    #         A listed user with no results will have an empty score array.
    #
    # excludes - (Optional) Specify additional values to exclude. "missing_user_rollups" excludes
    #            rollups for users without results.
    #
    # context - (Optional) The current context making the function call which will be used in
    #            determining the current_method chosen for calculating rollups.
    #
    # Returns an Array of Rollup objects.
    def outcome_results_rollups(results:, users: [], excludes: [], context: nil)
      rollups = results.group_by(&:user_id).map do |_, user_results|
        Rollup.new(user_results.first.user, rollup_user_results(user_results, context))
      end
      if excludes.include? "missing_user_rollups"
        rollups
      else
        add_missing_user_rollups(rollups, users)
      end
    end

    # Public: Calculates an average rollup for the specified results
    #
    # results - An Enumeration of properly sorted LearningOutcomeResult objects.
    # context - The context to use for the resulting rollup.
    #
    # Returns a Rollup.
    def aggregate_outcome_results_rollup(results, context, stat = "mean")
      rollups = outcome_results_rollups(results:, context:)
      rollup_scores = rollups.map(&:scores).flatten
      outcome_results = rollup_scores.group_by(&:outcome).values
      aggregate_results = outcome_results.map do |scores|
        scores.map { |score| Result.new(score.outcome, score.score, score.count, score.hide_points) }
      end
      opts = { aggregate_score: true, aggregate_stat: stat, **mastery_scale_opts(context) }
      aggregate_rollups = aggregate_results.map do |result|
        RollupScore.new(outcome_results: result, opts:)
      end
      Rollup.new(context, aggregate_rollups)
    end

    # Internal: Generates a rollup of the outcome results, Assuming all the
    # results are for the same user.
    #
    # user_results - An Enumeration of LearningOutcomeResult objects for a user
    #                sorted by outcome id.
    #
    # Returns an Array of RollupScore objects
    def rollup_user_results(user_results, context = nil)
      filtered_results = user_results.reject { |r| r.score.nil? }
      opts = mastery_scale_opts(context)
      filtered_results.group_by(&:learning_outcome_id).map do |_, outcome_results|
        RollupScore.new(outcome_results:, opts:)
      end
    end

    def mastery_scale_opts(context)
      return {} unless context.is_a?(Course) && context.root_account.feature_enabled?(:account_level_mastery_scales)

      @mastery_scale_opts ||= {}
      @mastery_scale_opts[context.asset_string] ||= begin
        method = context.resolved_outcome_calculation_method
        mastery_scale = context.resolved_outcome_proficiency
        {
          calculation_method: method&.calculation_method,
          calculation_int: method&.calculation_int,
          points_possible: mastery_scale&.points_possible,
          mastery_points: mastery_scale&.mastery_points,
          ratings: mastery_scale&.ratings_hash
        }
      end
    end

    # Internal: Adds rollups rows for users that did not have any results
    #
    # rollups - The list of rollup objects based on existing results.
    # users   - The list of User objects that should have results.
    #
    # Returns the modified rollups list. Users without rollups will have a
    #   rollup row with an empty scores array.
    def add_missing_user_rollups(rollups, users)
      missing_users = users - rollups.map(&:context)
      rollups + missing_users.map { |u| Rollup.new(u, []) }
    end

    # Public: Gets rating percents for outcomes based on rollup
    #
    # Returns a hash of outcome id to array of rating percents
    def rating_percents(rollups, context: nil)
      counts = {}
      outcome_proficiency_ratings = if context&.root_account&.feature_enabled?(:account_level_mastery_scales)
                                      context.resolved_outcome_proficiency.ratings_hash
                                    end
      rollups.each do |rollup|
        rollup.scores.each do |score|
          next unless score.score

          outcome = score.outcome
          next unless outcome

          ratings = outcome_proficiency_ratings || outcome.rubric_criterion[:ratings]
          next unless ratings

          counts[outcome.id] = Array.new(ratings.length, 0) unless counts[outcome.id]
          idx = ratings.find_index { |rating| rating[:points] <= score.score }
          counts[outcome.id][idx] = counts[outcome.id][idx] + 1 if idx
        end
      end
      counts.each { |k, v| counts[k] = to_percents(v) }
      counts
    end

    def to_percents(count_arr)
      total = count_arr.sum
      return count_arr if total.zero?

      count_arr.map { |v| (100.0 * v / total).round }
    end

    class << self
      include ResultAnalytics
    end
  end
end