require "test_helper"

class TartifletteScoringServiceTest < ActiveSupport::TestCase
  setup do
    @tartiflette = tartiflettes(:one)
    @existing_score = scores(:one)
    @session = { id: @existing_score.session_id }
  end

  test "should check if tartiflette is already scored" do
    @session[:scored_tartiflettes] = [ @tartiflette.id ]
    assert TartifletteScoringService.scored?(@tartiflette, @session)
  end

  test "should mark tartiflette as scored" do
    TartifletteScoringService.mark_as_scored(@tartiflette, @session)
    assert_includes @session[:scored_tartiflettes], @tartiflette.id
  end

  test "should process scores for tartiflette" do
    scores = {
      "1" => { value: 4, id: nil },   # New score for criterium_id 1
      "2" => { value: 5, id: @existing_score.id } # Update existing score
    }

    assert_nothing_raised do
      TartifletteScoringService.process_scores(@tartiflette, scores, @session)
    end

    # Assertions for new score
    new_score = Score.find_by(scoring_criterium_id: 1, tartiflette: @tartiflette)
    assert_equal 4, new_score.value
    assert_equal @session[:id], new_score.session_id

    # Assertions for updated score
    @existing_score.reload
    assert_equal 5, @existing_score.value
  end

  test "should raise error for invalid data" do
    scores = {
      "1" => { value: nil, id: nil }, # Missing value
      "2" => { value: 5, id: nil }    # Valid score
    }

    assert_raises(StandardError, /Failed to process scores/) do
      TartifletteScoringService.process_scores(@tartiflette, scores, @session)
    end
  end

  test "should mark tartiflette as scored in session" do
    session = { scored_tartiflettes: [] }
    TartifletteScoringService.mark_as_scored(@tartiflette, session)
    assert_includes session[:scored_tartiflettes], @tartiflette.id
  end

  test "should calculate average of all scores for a tartiflette" do
    Score.create!(tartiflette: @tartiflette,
                  scoring_criterium: scoring_criteria(:one),
                  value: 4)
    Score.create!(tartiflette: @tartiflette,
                  scoring_criterium: scoring_criteria(:two),
                  value: 5)
    assert_equal 4.5, TartifletteScoringService.average_score(@tartiflette)
  end

  test "should calculate average score by category for a tartiflette" do
    Score.create!(tartiflette: @tartiflette,
                  scoring_criterium: scoring_criteria(:one),
                  value: 1)
    Score.create!(tartiflette: @tartiflette,
                  scoring_criterium: scoring_criteria(:one),
                  value: 2)
    Score.create!(tartiflette: @tartiflette,
                  scoring_criterium: scoring_criteria(:four),
                  value: 4)
    Score.create!(tartiflette: @tartiflette,
                  scoring_criterium: scoring_criteria(:four),
                  value: 5)
    average_score_by_category = { scoring_criteria(:one)[:category] => 1.5,
                                  scoring_criteria(:four)[:category] => 4.5
                                }
    assert_equal average_score_by_category,
                 TartifletteScoringService.average_score_by_category(@tartiflette)
  end
end