require "ar_helper"
require "study_engine/assessment"
require "study_engine/config"
require "study_engine/result" # FIXME

module StudyEngine
  describe Assessment do
    let(:ids) { %w(Alpha Bravo Charlie Delta Echos) }

    before { StudyEngine.banks = ids }

    context "new" do
      its(:stream_id) { should be_nil }
      its(:study_id) { should be_nil }
      its(:event) { should be_nil }
      its(:percent_complete) { should == 0 }

      its(:group_index) { should be_nil }
      its(:group_index_name) { should == "" }

      describe "#results" do
        it "pads the list with unpersisted results for each cat assessment" do
          results = subject.results.map do |result|
            [result.bank_id, result.persisted?]
          end

          results.should == [
            ["Alpha", false],
            ["Bravo", false],
            ["Charlie", false],
            ["Delta", false],
            ["Echos", false],
          ]
        end
      end

      describe "#results_summary" do
        it "is a string of how many banks are completed" do
          subject.results_summary.should == "0/5"
        end
      end

      # straight up comparison fails
      its(:"current_result.bank_id") { should == "Alpha" }

      describe "#current_question" do
        it "delegates to current_result" do
          question = double
          result = double(current_question: question)
          subject.stub current_result: result

          subject.current_question.should == question
        end
      end


      describe "#save_answer" do
        it "delegates to current_result" do
          result = double
          answer = double
          subject.stub(current_result: result)

          result.should_receive(:save_answer).with(answer)

          # make valid
          subject.study_id = "OUT-BBB-1234"
          subject.event = "Baseline"
          subject.save_answer answer

          subject.should be_persisted
        end
      end

      it { should_not be_complete }
      it { should be_incomplete }
    end

    context "in progress" do
      before do
        subject.study_id = "OUT-BBB-1234"
        subject.event = "Baseline" # make valid
        subject.save!

        subject.results[0].update_attribute :finished, true
        subject.results[1].update_attribute :finished, true
      end

      its(:stream_id) { should == StudyID.new("STR-BBB-1001") }
      its(:study_id) { should == StudyID.new("OUT-BBB-1234") }

      its(:percent_complete) { should == 40 }

      its(:group_index) { should be_nil }

      # straight up comparison fails
      its(:"current_result.bank_id") { should == "Charlie" }

      describe "#results" do
        it "pads the list with unpersisted results for each cat assessment" do

          results = subject.results.map do |result|
            [result.bank_id, result.persisted?]
          end

          results.should == [
            ["Alpha", true],
            ["Bravo", true],
            ["Charlie", false],
            ["Delta", false],
            ["Echos", false],
          ]
        end
      end

      it { should_not be_complete }
      it { should be_incomplete }
    end

    context "complete" do
      before do
        subject.study_id = "OUT-BBB-1234"
        subject.event = "Baseline" # make valid

        subject.save!
        subject.results.each do |result|
          result.update_attribute :finished, true
        end
      end

      describe "#results" do
        it "pads the list with unpersisted results for each cat assessment" do
          results = subject.results.map do |result|
            [result.bank_id, result.persisted?]
          end

          results.should == [
            ["Alpha", true],
            ["Bravo", true],
            ["Charlie", true],
            ["Delta", true],
            ["Echos", true],
          ]
        end
      end

      its(:percent_complete) { should == 100 }

      its(:group_index) { should be_nil }
      its(:current_result) { should be_nil }

      describe "#current_question" do
        it "raises an error" do
          lambda { subject.current_question }.should raise_exception(StandardError)
        end
      end

      describe "#history=" do
        it "raises an error" do
          lambda { subject.history = double }.should raise_exception(StandardError)
        end
      end

      it { should be_complete }
      it { should_not be_incomplete }
    end

    describe "#study_id=" do
      it "assigns the parts" do
        subject.study_id = "FIX-BBB-0000"
        subject.study_id.study.should == "FIX"
        subject.study_id.site.should == "BBB"
        subject.study_id.id.should == "0000"
        subject.study_id.should == StudyID.new("FIX-BBB-0000")
      end
    end

    describe "groups" do
      def create_assessment attributes = {}
        attributes.reverse_merge! event: "12 month"
        described_class.new(attributes).tap do |assessment|
          assessment.save(validate: false)
        end
      end

      before do
        StudyEngine.groups = { "12 month" => %w(A B C) }
      end

      describe "#group_index" do
        it "is 0 when there is one twelve month assessment" do
          create_assessment.group_index.should == 0
        end

        it "is 1 when there are two twelve month assessments" do
          create_assessment
          create_assessment.group_index.should == 1
        end

        it "is 2 when there are three twelve month assessments" do
          2.times { create_assessment }
          create_assessment.group_index.should == 2
        end

        it "is 0 when there are four twelve month assessments" do
          3.times { create_assessment }
          create_assessment.group_index.should == 0
        end

        it "is nil when subject is not a twelve month assessment" do
          assessment = create_assessment(event: "baseline")
          assessment.group_index.should be_nil
        end

        it "doesnt change after subsequent assessments are added" do
          assessment = create_assessment
          assessment.group_index.should == 0
          create_assessment
          assessment.group_index.should == 0
        end

        it "retains previous group index if restarted" do
          a1 = create_assessment study_id: "ABC-DEF-1234"
          a2 = create_assessment study_id: "ABC-DEF-1234"
          a2.group_index.should == a1.group_index
        end
      end

      describe "#group_index_name" do
        it "is A when group_index is 0" do
          assessment = create_assessment
          assessment.group_index = 0
          assessment.group_index_name.should == "A"
        end

        it "is B when group_index is 1" do
          assessment = create_assessment
          assessment.group_index = 1
          assessment.group_index_name.should == "B"
        end

        it "is C when group_index is 2" do
          assessment = create_assessment
          assessment.group_index = 2
          assessment.group_index_name.should == "C"
        end
      end
    end
  end
end