require 'rails_helper'

describe SubcategoryPresenter do
  let(:academic_year) { create(:academic_year, range: '1989-90') }
  let(:school) { create(:school, name: 'Best School') }
  let(:subcategory) do
    create(:subcategory, name: 'A great subcategory', subcategory_id: 'A', description: 'A great description')
  end
  let(:survey_respondents) do
    create(:respondent, school:, total_students: SurveyItemResponse::STUDENT_RESPONSE_THRESHOLD,
                        total_teachers: 10.0, academic_year:)
  end
  let(:subcategory_presenter) do
    survey_respondents
    measure1 = create(:measure, subcategory:)
    survey_item1 = create(:teacher_survey_item, measure: measure1, watch_low_benchmark: 4, growth_low_benchmark: 4.25,
                                                approval_low_benchmark: 4.5, ideal_low_benchmark: 4.75)
    survey_item2 = create(:student_survey_item, measure: measure1, watch_low_benchmark: 4, growth_low_benchmark: 4.25,
                                                approval_low_benchmark: 4.5, ideal_low_benchmark: 4.75)
    create_list(:survey_item_response, SurveyItemResponse::TEACHER_RESPONSE_THRESHOLD, survey_item: survey_item1,
                                                                                       academic_year:, school:, likert_score: 1)
    create_list(:survey_item_response, SurveyItemResponse::TEACHER_RESPONSE_THRESHOLD, survey_item: survey_item1,
                                                                                       academic_year:, school:, likert_score: 5)
    create_list(:survey_item_response, SurveyItemResponse::STUDENT_RESPONSE_THRESHOLD / 2, survey_item: survey_item2,
                                                                                           academic_year:, school:, likert_score: 3)
    create_list(:survey_item_response, SurveyItemResponse::STUDENT_RESPONSE_THRESHOLD / 2, survey_item: survey_item2,
                                                                                           academic_year:, school:, likert_score: 3)

    measure2 = create(:measure, subcategory:)
    survey_item3 = create(:teacher_survey_item, measure: measure2, watch_low_benchmark: 1.25,
                                                growth_low_benchmark: 1.5, approval_low_benchmark: 1.75, ideal_low_benchmark: 2.0)
    survey_item4 = create(:student_survey_item, measure: measure2, watch_low_benchmark: 1.25,
                                                growth_low_benchmark: 1.5, approval_low_benchmark: 1.75, ideal_low_benchmark: 2.0)
    create_list(:survey_item_response, SurveyItemResponse::TEACHER_RESPONSE_THRESHOLD, survey_item: survey_item3,
                                                                                       academic_year:, school:, likert_score: 1)
    create_list(:survey_item_response, SurveyItemResponse::TEACHER_RESPONSE_THRESHOLD, survey_item: survey_item3,
                                                                                       academic_year:, school:, likert_score: 5)
    create_list(:survey_item_response, SurveyItemResponse::STUDENT_RESPONSE_THRESHOLD / 2, survey_item: survey_item4,
                                                                                           academic_year:, school:, likert_score: 3)
    create_list(:survey_item_response, SurveyItemResponse::STUDENT_RESPONSE_THRESHOLD / 2, survey_item: survey_item4,
                                                                                           academic_year:, school:, likert_score: 3)

    # Adding responses corresponding to different years and schools should not pollute the score calculations
    create_survey_item_responses_for_different_years_and_schools(survey_item1)

    return SubcategoryPresenter.new(subcategory:, academic_year:, school:)
  end

  it 'returns the name of the subcategory' do
    expect(subcategory_presenter.name).to eq 'A great subcategory'
  end

  it 'returns the description of the subcategory' do
    expect(subcategory_presenter.description).to eq 'A great description'
  end

  it 'returns the id of the subcategory' do
    expect(subcategory_presenter.id).to eq 'A'
  end

  it 'returns a gauge presenter responsible for the aggregate admin data and survey item response likert scores' do
    expect(subcategory_presenter.gauge_presenter.title).to eq 'Growth'
  end

  it 'returns the student response rate' do
    expect(subcategory_presenter.student_response_rate).to eq 100.0
  end

  it 'returns the teacher response rate' do
    expect(subcategory_presenter.teacher_response_rate).to eq 100
  end

  it 'returns the admin collection rate' do
    expect(subcategory_presenter.admin_collection_rate).to eq %w[N A]
  end

  it 'creates a measure presenter for each measure in a subcategory' do
    expect(subcategory_presenter.measure_presenters.count).to eq subcategory.measures.count
  end

  context 'When there are no measures populated with student or teacher surveys' do
    let(:empty_subcategory) { create :subcategory }
    let(:empty_subcategory_presenter) do
      SubcategoryPresenter.new(subcategory: empty_subcategory, academic_year:, school:)
    end
    it 'should make a subcategory presenter return insufficient data' do
      expect(empty_subcategory_presenter.subcategory_card_presenter.insufficient_data?).to eq true
    end
  end

  def create_survey_item_responses_for_different_years_and_schools(survey_item)
    create_list(:survey_item_response, SurveyItemResponse::TEACHER_RESPONSE_THRESHOLD, survey_item:,
                                                                                       school: School.new(name: 'Worst School', dese_id: 2), likert_score: 1)
    create_list(:survey_item_response, SurveyItemResponse::TEACHER_RESPONSE_THRESHOLD, survey_item:,
                                                                                       academic_year: AcademicYear.create(range: '2000-01'), likert_score: 1)
  end

  context 'When there are admin data items' do
    context 'and the school is not a high school' do
      context 'and the measure does not include high-school-only admin data items' do
        before do
          measure_of_only_admin_data = create(:measure, subcategory:)
          create(:admin_data_item, measure: measure_of_only_admin_data, hs_only_item: false)
          create(:admin_data_item, measure: measure_of_only_admin_data, hs_only_item: false)
        end
        it 'returns the admin collection rate' do
          expect(subcategory_presenter.admin_collection_rate).to eq [0, 2]
        end
      end

      context 'and the measure includes high-school-only items' do
        before do
          measure_of_only_admin_data = create(:measure, subcategory:)
          create(:admin_data_item, measure: measure_of_only_admin_data, hs_only_item: true)
          create(:admin_data_item, measure: measure_of_only_admin_data, hs_only_item: true)
        end
        it 'returns the admin collection rate' do
          expect(subcategory_presenter.admin_collection_rate).to eq %w[N A]
        end
      end
    end

    context 'and the school is a high school' do
      context 'and the measure does not include high-school-only admin data items' do
        before do
          school.is_hs = true
          school.save
          measure_of_only_admin_data = create(:measure, subcategory:)
          create(:admin_data_item, measure: measure_of_only_admin_data, hs_only_item: false)
          create(:admin_data_item, measure: measure_of_only_admin_data, hs_only_item: false)
        end
        it 'returns the admin collection rate' do
          expect(subcategory_presenter.admin_collection_rate).to eq [0, 2]
        end
      end

      context 'and the measure includes high-school-only items' do
        before do
          school.is_hs = true
          school.save
          measure_of_only_admin_data = create(:measure, subcategory:)
          create(:admin_data_item, measure: measure_of_only_admin_data, hs_only_item: true)
          create(:admin_data_item, measure: measure_of_only_admin_data, hs_only_item: true)
        end
        it 'returns the admin collection rate' do
          expect(subcategory_presenter.admin_collection_rate).to eq [0, 2]
        end
      end
    end
  end
end