-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, from_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", 26).
?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", 46).
?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 => 70})
    end.

-file("src/datebook/weekday.gleam", 82).
?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", 102).
?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", 136).
?DOC(
    " Returns the number of days elapsed between `since` and `day` in a `0..=6` range.\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.

-file("src/datebook/weekday.gleam", 228).
?DOC(
    " Returns the weekday corresponding to the number of `days` since `start`.\n"
    "\n"
    " If `days` is not between `0` and `6`, it will wrap around modulo 7.\n"
    "\n"
    " # Examples\n"
    "\n"
    " ```gleam\n"
    " 2 |> from_days_since(Monday)\n"
    " // -> Wednesday\n"
    " ```\n"
    "\n"
    " ```gleam\n"
    " -1 |> from_days_since(Sunday)\n"
    " // -> Saturday\n"
    " ```\n"
    "\n"
    " ```gleam\n"
    " 0 |> from_days_since(Thursday)\n"
    " // -> Thursday\n"
    " ```\n"
    "\n"
    " ```gleam\n"
    " 7 |> from_days_since(Tuesday)\n"
    " // -> Tuesday\n"
    " ```\n"
).
-spec from_days_since(integer(), weekday()) -> weekday().
from_days_since(Days, Start) ->
    Days@2 = case begin
        _pipe = Days,
        gleam@int:modulo(_pipe, 7)
    end of
        {ok, Days@1} -> Days@1;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"datebook/weekday"/utf8>>,
                        function => <<"from_days_since"/utf8>>,
                        line => 229,
                        value => _assert_fail,
                        start => 4437,
                        'end' => 4480,
                        pattern_start => 4448,
                        pattern_end => 4456})
    end,
    case {Start, Days@2} of
        {monday, 0} ->
            monday;

        {sunday, 1} ->
            monday;

        {saturday, 2} ->
            monday;

        {friday, 3} ->
            monday;

        {thursday, 4} ->
            monday;

        {wednesday, 5} ->
            monday;

        {tuesday, 6} ->
            monday;

        {monday, 1} ->
            tuesday;

        {sunday, 2} ->
            tuesday;

        {saturday, 3} ->
            tuesday;

        {friday, 4} ->
            tuesday;

        {thursday, 5} ->
            tuesday;

        {wednesday, 6} ->
            tuesday;

        {tuesday, 0} ->
            tuesday;

        {monday, 2} ->
            wednesday;

        {sunday, 3} ->
            wednesday;

        {saturday, 4} ->
            wednesday;

        {friday, 5} ->
            wednesday;

        {thursday, 6} ->
            wednesday;

        {wednesday, 0} ->
            wednesday;

        {tuesday, 1} ->
            wednesday;

        {monday, 3} ->
            thursday;

        {sunday, 4} ->
            thursday;

        {saturday, 5} ->
            thursday;

        {friday, 6} ->
            thursday;

        {thursday, 0} ->
            thursday;

        {wednesday, 1} ->
            thursday;

        {tuesday, 2} ->
            thursday;

        {monday, 4} ->
            friday;

        {sunday, 5} ->
            friday;

        {saturday, 6} ->
            friday;

        {friday, 0} ->
            friday;

        {thursday, 1} ->
            friday;

        {wednesday, 2} ->
            friday;

        {tuesday, 3} ->
            friday;

        {monday, 5} ->
            saturday;

        {sunday, 6} ->
            saturday;

        {saturday, 0} ->
            saturday;

        {friday, 1} ->
            saturday;

        {thursday, 2} ->
            saturday;

        {wednesday, 3} ->
            saturday;

        {tuesday, 4} ->
            saturday;

        {monday, 6} ->
            sunday;

        {sunday, 0} ->
            sunday;

        {saturday, 1} ->
            sunday;

        {friday, 2} ->
            sunday;

        {thursday, 3} ->
            sunday;

        {wednesday, 4} ->
            sunday;

        {tuesday, 5} ->
            sunday;

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