require "spec_helper"
require "action_controller"
require "simple_calendar/calendar"
require_relative "support/fake_event"
require_relative "support/view_context"

describe SimpleCalendar::Calendar do
  let(:calendar) { SimpleCalendar::Calendar.new(ViewContext.new) }

  it "renders a partial with the same name as the class" do
    expect(calendar.send(:partial_name)).to eq("simple_calendar/calendar")
  end

  context "event sorting attribute" do
    it "has start_time as the default attribute" do
      expect(calendar.send(:attribute)).to eq(:start_time)
    end

    it "allows you to override the default attribute" do
      expect(SimpleCalendar::Calendar.new(ViewContext.new, attribute: :starts_at).send(:attribute)).to eq(:starts_at)
    end

    it "set a default when `partial` option isn't present" do
      expect(SimpleCalendar::Calendar.new(ViewContext.new).send(:partial_name)).to eq("simple_calendar/calendar")
      expect(SimpleCalendar::MonthCalendar.new(ViewContext.new).send(:partial_name)).to eq("simple_calendar/month_calendar")
      expect(SimpleCalendar::WeekCalendar.new(ViewContext.new).send(:partial_name)).to eq("simple_calendar/week_calendar")
    end

    it "allows to override the default partial" do
      expect(SimpleCalendar::Calendar.new(ViewContext.new, partial: "simple_calendar/custom_calendar").send(:partial_name)).to eq("simple_calendar/custom_calendar")
    end
  end

  describe "#sorted_events" do
    it "converts an array of events to a hash sorted by days" do
      today, tomorrow = Date.today, Date.tomorrow

      event1 = double(start_time: today.at_midnight)
      event2 = double(start_time: today.at_noon)
      event3 = double(start_time: tomorrow.at_noon)

      events = [event1, event2, event3].shuffle
      calendar = SimpleCalendar::Calendar.new(ViewContext.new, events: events)

      sorted_events = calendar.send(:sorted_events)

      expect(sorted_events[today]).to eq([event1, event2])
      expect(sorted_events[tomorrow]).to eq([event3])
    end

    it "converts an array of multi-day events to a hash sorted by days" do
      today, tomorrow = Date.today, Date.tomorrow

      event1 = double(start_time: today.at_midnight, end_time: tomorrow.at_midnight)
      event2 = double(start_time: today.at_noon)
      event3 = double(start_time: tomorrow.at_noon)

      events = [event1, event2, event3].shuffle
      calendar = SimpleCalendar::Calendar.new(ViewContext.new, events: events)

      sorted_events = calendar.send(:sorted_events)

      expect(sorted_events[today]).to eq([event1, event2])
      expect(sorted_events[tomorrow]).to eq([event1, event3])
    end

    it "handles events without a start time" do
      event = double(start_time: nil)
      calendar = SimpleCalendar::Calendar.new(ViewContext.new, events: [event])

      expect { calendar.send(:sorted_events) }.not_to raise_error
    end
  end

  describe "#start_date" do
    it "defaults to today's date" do
      view_context = ViewContext.new
      calendar = SimpleCalendar::Calendar.new(view_context)
      expect(calendar.send(:start_date)).to eq(Date.today)
    end

    it "uses the view context's params start_date to override" do
      view_context = ViewContext.new(Date.yesterday)
      calendar = SimpleCalendar::Calendar.new(view_context)
      expect(calendar.send(:start_date)).to eq(Date.yesterday)
    end

    it "uses the optional argument's start_date to override view_context's start_date" do
      view_context = ViewContext.new(Date.yesterday)
      calendar = SimpleCalendar::Calendar.new(view_context, start_date: Date.tomorrow)
      expect(calendar.send(:start_date)).to eq(Date.tomorrow)
    end

    it "takes an option to override the start_date parameter" do
      view_context = ViewContext.new(Date.yesterday, start_date_param: :date)
      calendar = SimpleCalendar::Calendar.new(view_context, start_date_param: :date)
      expect(calendar.send(:start_date)).to eq(Date.yesterday)
    end
  end

  describe "current week class" do
    it "should have the current week" do
      calendar = SimpleCalendar::Calendar.new(ViewContext.new)
      week = calendar.date_range.each_slice(7).to_a[0]
      expect(calendar.send(:tr_classes_for, week)).to include("current-week")
    end

    it "should not have the current week if it does not contain today" do
      calendar = SimpleCalendar::MonthCalendar.new(ViewContext.new(6.months.ago))
      week = calendar.date_range.each_slice(7).to_a[0]
      expect(calendar.send(:tr_classes_for, week)).to_not include("current-week")
    end
  end

  it "has a param that determines the start date of the calendar" do
    calendar = SimpleCalendar::Calendar.new(ViewContext.new)

    rendering_variables = calendar.render[:locals]

    expect(rendering_variables[:start_date]).not_to be_nil
  end

  it "generates a default date if no start date is present" do
    calendar = SimpleCalendar::Calendar.new(ViewContext.new)

    calendar_start_date = calendar.render[:locals][:start_date]

    expect(calendar_start_date).not_to be_nil
    expect(calendar_start_date).to be_a(Date)
  end

  it "has a range of dates" do
    calendar = SimpleCalendar::Calendar.new(ViewContext.new)

    calendar_date_range = calendar.date_range

    expect(calendar_date_range).to be_an(Array)
    expect(calendar_date_range).to all(be_an(Date))
  end

  it "can split the range of dates into weeks"
  it "has a title"
  it "has a next view link"
  it "has a previous view link"

  it "accepts an array of events" do
    first_event = FakeEvent.new("event1", Date.today)
    second_event = FakeEvent.new("event2", Date.today + 1.day)
    events = [first_event, second_event]
    calendar = SimpleCalendar::Calendar.new(ViewContext.new, events: events)

    calendar_sorted_events = calendar.render[:locals][:sorted_events]

    expect(calendar_sorted_events.length).to eq(2)
  end

  it "sorts the events" do
    first_event = FakeEvent.new("event1", Date.today + 2.days)
    second_event = FakeEvent.new("event2", Date.today + 1.day)
    third_event = FakeEvent.new("event3", Date.today)
    events = [first_event, third_event, second_event]
    calendar = SimpleCalendar::Calendar.new(ViewContext.new, events: events)

    calendar_sorted_events = calendar.render[:locals][:sorted_events]
    first_key = calendar_sorted_events.keys[0]
    second_key = calendar_sorted_events.keys[1]
    third_key = calendar_sorted_events.keys[2]

    expect(calendar_sorted_events[first_key][0]).to eq(third_event)
    expect(calendar_sorted_events[second_key][0]).to eq(second_event)
    expect(calendar_sorted_events[third_key][0]).to eq(first_event)
  end

  it "yields the events for each day"
  it "doesn't crash when an event has a nil start_time"
end