-module(datebook@weekday).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/datebook/weekday.gleam").
-export([to_string/1, from_date/1, next/1, previous/1, days_since/2]).
-export_type([weekday/0]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

?MODULEDOC(" The day of the week.\n").

-type weekday() :: monday |
    tuesday |
    wednesday |
    thursday |
    friday |
    saturday |
    sunday.

-file("src/datebook/weekday.gleam", 25).
?DOC(
    " Returns the English name for a `Weekday`.\n"
    "\n"
    " # Examples\n"
    "\n"
    " ```gleam\n"
    " to_string(Wednesday)\n"
    " // -> Wednesday\n"
    " ```\n"
).
-spec to_string(weekday()) -> binary().
to_string(Weekday) ->
    case Weekday of
        monday ->
            <<"Monday"/utf8>>;

        tuesday ->
            <<"Tuesday"/utf8>>;

        wednesday ->
            <<"Wednesday"/utf8>>;

        thursday ->
            <<"Thursday"/utf8>>;

        friday ->
            <<"Friday"/utf8>>;

        saturday ->
            <<"Saturday"/utf8>>;

        sunday ->
            <<"Sunday"/utf8>>
    end.

-file("src/datebook/weekday.gleam", 45).
?DOC(
    " Returns the `Weekday` for a given `Date`.\n"
    "\n"
    " # Examples\n"
    "\n"
    " ```gleam\n"
    " from_date(calendar.Date(1970, calendar.January, 1))\n"
    " // -> Thursday\n"
    " ```\n"
).
-spec from_date(gleam@time@calendar:date()) -> weekday().
from_date(Date) ->
    {Seconds, _} = begin
        _pipe = Date,
        _pipe@1 = gleam@time@timestamp:from_calendar(
            _pipe,
            {time_of_day, 0, 0, 0, 0},
            {duration, 0, 0}
        ),
        gleam@time@timestamp:to_unix_seconds_and_nanoseconds(_pipe@1)
    end,
    Days_since_epoch = Seconds div 86400,
    Weekday = case Days_since_epoch >= -4 of
        true ->
            (Days_since_epoch + 4) rem 7;

        false ->
            ((Days_since_epoch + 5) rem 7) + 6
    end,
    case Weekday of
        0 ->
            sunday;

        1 ->
            monday;

        2 ->
            tuesday;

        3 ->
            wednesday;

        4 ->
            thursday;

        5 ->
            friday;

        6 ->
            saturday;

        _ ->
            erlang:error(#{gleam_error => panic,
                    message => <<"`panic` expression evaluated."/utf8>>,
                    file => <<?FILEPATH/utf8>>,
                    module => <<"datebook/weekday"/utf8>>,
                    function => <<"from_date"/utf8>>,
                    line => 69})
    end.

-file("src/datebook/weekday.gleam", 81).
?DOC(
    " Returns the next `Weekday` for the given `Weekday`.\n"
    "\n"
    " # Examples\n"
    "\n"
    " ```gleam\n"
    " next(Tuesday)\n"
    " // -> Wednesday\n"
    " ```\n"
).
-spec next(weekday()) -> weekday().
next(Weekday) ->
    case Weekday of
        monday ->
            tuesday;

        tuesday ->
            wednesday;

        wednesday ->
            thursday;

        thursday ->
            friday;

        friday ->
            saturday;

        saturday ->
            sunday;

        sunday ->
            monday
    end.

-file("src/datebook/weekday.gleam", 101).
?DOC(
    " Returns the previous `Weekday` for the given `Weekday`.\n"
    "\n"
    " # Examples\n"
    "\n"
    " ```gleam\n"
    " previous(Sunday)\n"
    " // -> Saturday\n"
    " ```\n"
).
-spec previous(weekday()) -> weekday().
previous(Weekday) ->
    case Weekday of
        monday ->
            sunday;

        tuesday ->
            monday;

        wednesday ->
            tuesday;

        thursday ->
            wednesday;

        friday ->
            thursday;

        saturday ->
            friday;

        sunday ->
            saturday
    end.

-file("src/datebook/weekday.gleam", 135).
?DOC(
    " Returns the number of days elapsed between `right` and `left`.\n"
    "\n"
    " You can use this function to map a weekday to a number based on the\n"
    " first day of the week in a given region (e.g. Monday for Europe,\n"
    " Sunday for the US, Saturday for Afghanistan).\n"
    "\n"
    " # Examples\n"
    "\n"
    " ```gleam\n"
    " Monday |> days_since(Monday)\n"
    " // -> 0\n"
    " ```\n"
    " \n"
    " ```gleam\n"
    " Sunday |> days_since(Tuesday)\n"
    " // -> 5\n"
    " ```\n"
    " \n"
    " ```gleam\n"
    " Wednesday |> days_since(Sunday)\n"
    " // -> 3\n"
    " ```\n"
).
-spec days_since(weekday(), weekday()) -> integer().
days_since(Day, Since) ->
    case {Since, Day} of
        {monday, monday} ->
            0;

        {tuesday, tuesday} ->
            0;

        {wednesday, wednesday} ->
            0;

        {thursday, thursday} ->
            0;

        {friday, friday} ->
            0;

        {saturday, saturday} ->
            0;

        {sunday, sunday} ->
            0;

        {monday, tuesday} ->
            1;

        {tuesday, wednesday} ->
            1;

        {wednesday, thursday} ->
            1;

        {thursday, friday} ->
            1;

        {friday, saturday} ->
            1;

        {saturday, sunday} ->
            1;

        {sunday, monday} ->
            1;

        {monday, wednesday} ->
            2;

        {tuesday, thursday} ->
            2;

        {wednesday, friday} ->
            2;

        {thursday, saturday} ->
            2;

        {friday, sunday} ->
            2;

        {saturday, monday} ->
            2;

        {sunday, tuesday} ->
            2;

        {monday, thursday} ->
            3;

        {tuesday, friday} ->
            3;

        {wednesday, saturday} ->
            3;

        {thursday, sunday} ->
            3;

        {friday, monday} ->
            3;

        {saturday, tuesday} ->
            3;

        {sunday, wednesday} ->
            3;

        {monday, friday} ->
            4;

        {tuesday, saturday} ->
            4;

        {wednesday, sunday} ->
            4;

        {thursday, monday} ->
            4;

        {friday, tuesday} ->
            4;

        {saturday, wednesday} ->
            4;

        {sunday, thursday} ->
            4;

        {monday, saturday} ->
            5;

        {tuesday, sunday} ->
            5;

        {wednesday, monday} ->
            5;

        {thursday, tuesday} ->
            5;

        {friday, wednesday} ->
            5;

        {saturday, thursday} ->
            5;

        {sunday, friday} ->
            5;

        {monday, sunday} ->
            6;

        {tuesday, monday} ->
            6;

        {wednesday, tuesday} ->
            6;

        {thursday, wednesday} ->
            6;

        {friday, thursday} ->
            6;

        {saturday, friday} ->
            6;

        {sunday, saturday} ->
            6
    end.