human_time

defmodule HumanTime.Repeating.Filters do
  @moduledoc false
  
  @day_map %{
    "monday"    => [1],
    "tuesday"   => [2],
    "wednesday" => [3],
    "thursday"  => [4],
    "friday"    => [5],
    "saturday"  => [6],
    "sunday"    => [7],
    "weekday"   => [1, 2, 3, 4, 5],
    "weekend"   => [6, 7],
    "day"       => [1, 2, 3, 4, 5, 6, 7],
  }
  
  @sector_indexes %{
    "first"  => 0,
    "second" => 1,
    "third"  => 2,
    "fourth" => 3,
    "last"   => -1,
  }
  
  # def always_true(_) do
  #   fn _ ->
  #     true
  #   end
  # end
  
  @spec weekday(map) :: (DateTime.t -> DateTime.t | nil)
  def weekday(match) do
    day_numbers = @day_map[match["principle"]]
    
    fn the_date ->
      Timex.weekday(the_date) in day_numbers
    end
  end
  
  # If we catch an after then it means this function was triggered incorrectly
  @spec identifier_in_month(map) :: (DateTime.t -> DateTime.t | nil)
  def identifier_in_month(match) do
    selector  = match["selector"]
    the_day   = match["principle"]
    
    acceptable_days = @day_map[the_day]
    selector_index = @sector_indexes[selector]
    
    fn the_date ->
      if Timex.weekday(the_date) in acceptable_days do
        the_date = Timex.to_date(the_date)
        
        xs_in_month = get_xs_in_month(the_day, the_date)
        
        Enum.at(xs_in_month, selector_index) == the_date
      end
    end
  end
  
  @spec identifier_in_month_after(map) :: (DateTime.t -> DateTime.t | nil)
  def identifier_in_month_after(match) do
    selector1  = match["selector1"]
    the_day1   = match["principle1"]
    selector2  = match["selector2"]
    the_day2   = match["principle2"]
    
    fn the_date ->
      # Calculate an "after date", we won't accept a value prior to this date
      selector_index = @sector_indexes[selector2]
      after_date = Enum.at(get_xs_in_month(the_day2, the_date), selector_index)
      
      # Get the Xs in a month which are after the after_date
      xs_in_month = get_xs_in_month(the_day1, the_date)
      |> Enum.filter(fn d -> Timex.compare(d, after_date) == 1 end)
      
      # Calcualte an acceptable day from the Xs
      selector_index = @sector_indexes[selector1]
      
      # Is today the date we find to be acceptable?
      Enum.at(xs_in_month, selector_index) == the_date |> Timex.to_date
    end
  end
  
  @spec day_number_in_month(map) :: (DateTime.t -> DateTime.t | nil)
  def day_number_in_month(match) do
    day_number = match["selector"]
    |> String.to_integer
    
    fn the_date ->
      Timex.to_date(the_date).day == day_number
    end
  end
  
  @spec end_of_month(map) :: (DateTime.t -> DateTime.t | nil)
  def end_of_month(_match) do
    fn the_date ->
      Timex.to_date(the_date) == Timex.end_of_month(the_date) |> Timex.to_date
    end
  end
  
  
  # Used to get all Xs from a month where X is something like tuesday
  @spec get_xs_in_month(String.t(), DateTime.t | Date.t) :: list
  defp get_xs_in_month(x, the_date) do
    the_date = the_date |> Timex.to_date
    
    # We shift the end of the month by one day to include the last day of the month in our interval
    month_start = Timex.beginning_of_month(the_date)
    month_end = Timex.shift(Timex.end_of_month(the_date), days: 1)
    
    day_index = hd @day_map[x]
    
    # For each day in month, select only those with the same weekday number as x
    Timex.Interval.new(from: month_start, until: month_end)
    |> Enum.filter(fn d ->
      Timex.weekday(d) == day_index
    end)
    |> Enum.map(&Timex.to_date/1)
  end
end