// SPDX-License-Identifier: GPL-3.0-or-later
// Copyright © 2026 Aurélien Pierre

package com.aurelienpierre.sioul;

import android.app.AlarmManager;
import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.graphics.drawable.Icon;
import android.net.Uri;
import android.os.UserManager;
import android.util.Log;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import java.time.ZoneId;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;

/**
 * Reminders before events while Sioul is not on the screen (docs/android.md,
 * "Events"): Android freezes an app it does not show, so Rust hands the
 * coming reminders of events ahead (crates/sioul-app/src/eventalarms.rs:
 * their own alarms, Sioul's before them, the working day before), and each
 * is given to Android's alarm clock, as the doses are (DoseAlarms). At its
 * time EventReceiver asks Rust what to say: the event read again, sleep or a
 * pause holding it or not, the time left said as it is then. Rust shows it
 * through `show`: Sioul's reminders before an event and the working day
 * before in the "Events" channel, at low importance (no sound, no banner);
 * an alarm the event carries in "An event's alarms", at Android's default
 * importance (its sound, no banner), or, while one of Sioul's modes lets
 * them through, in its twin that passes do-not-disturb (PauseMode); each
 * yours to change in Android's settings. A tap opens the event in Sioul
 * (ReminderOpener). Rust silent, the words given with the list are shown
 * instead: never nothing. Apart from the doses: its own list, alarms,
 * channels and receiver. The list also holds when the end of work's notice
 * and the night's may come (kind "day"): Rust decides those at their alarm
 * and shows them through DayNotes, or nothing; no words are kept for them.
 */
final class EventAlarms
{
    static final String RING = "com.aurelienpierre.sioul.action.EVENT_REMINDER";
    static final String LOOK = "com.aurelienpierre.sioul.action.EVENT_LOOK";
    /** The "Events" channel: Sioul's reminders before an event, and the working day before; quiet. */
    static final String CHANNEL = "events";
    /** "An event's alarms": the alarms an event carries, with their sound. */
    static final String ALARMS = "event-alarms";

    private static final String SCHEME = "sioul-event";
    private static final String KEPT = "sioul-events";
    private static final String LIST = "list";
    private static final String WORDS = "words";
    private static final String OPENED = "opened";
    /** A reminder is known by its key (its tag) and this number. */
    private static final int NOTE = 2;
    /** The question asked again once a day, nothing having rung meanwhile. */
    private static final int LOOK_CODE = 0x5801;
    /** A reminder stays in the shade until an hour after its event began. */
    private static final long KEPT_AFTER_MS = 60 * 60 * 1000L;

    private EventAlarms() {}

    /** At a reminder's time (eventalarms.rs, `sioul_event_decide`): {"shown"}, {"again_at"}, {}; null when Rust failed. */
    static native String nativeDecide(String key);
    /** The coming reminders, in the phone's `zone` (`sioul_event_coming`); "" when Rust failed. */
    static native String nativeComing(String zone);

    // ---------------------------------------------------------------- the list

    /**
     * Rust's coming reminders: JSON {reminders: [{key, at (Unix ms), title,
     * body}], look (Unix ms), words}. Their alarms replace those given
     * before, as `merged` says; the list is kept for Android's restarts. Any thread.
     */
    static synchronized void set(Context context, String json)
    {
        final JSONObject given;
        try {
            given = new JSONObject(json);
        } catch (JSONException e) {
            Log.e(DoseAlarms.TAG, "Events: the list does not read; the one kept stays. " + e);
            return;
        }
        JSONArray coming = given.optJSONArray("reminders");
        if (coming == null)
            coming = new JSONArray();
        Set<String> keys = new HashSet<>();
        for (int i = 0; i < coming.length(); i++)
            keys.add(key(coming.optJSONObject(i)));
        JSONArray before = list(context);
        for (int i = 0; i < before.length(); i++) {
            String key = key(before.optJSONObject(i));
            if (!key.isEmpty() && !keys.contains(key))
                cancel(context, key);
        }
        List<Arm> armed = new ArrayList<>();
        JSONArray list = merged(before, coming, System.currentTimeMillis(), armed);
        JSONObject words = given.optJSONObject("words");
        SharedPreferences.Editor kept = kept(context).edit().putString(LIST, list.toString());
        if (words != null)
            kept.putString(WORDS, words.toString());
        kept.commit();
        channel(context);
        for (Arm arm : armed)
            alarm(context, arm.key, arm.at);
        look(context, given.optLong("look"));
        Log.i(DoseAlarms.TAG, "Events: " + coming.length() + " reminders given, " + armed.size() + " alarms set, " + (DoseAlarms.exact(context) ? "on time." : "inexact (no \"Alarms & reminders\")."));
    }

    /** An alarm to set: its reminder's key, and when (Unix ms). */
    static final class Arm
    {
        final String key;
        final long at;

        Arm(String key, long at)
        {
            this.key = key;
            this.at = at;
        }
    }

    /** Whether a reminder of the list rang and was answered (`done`): kept while Rust lists it, never set again. */
    static final String DONE = "done";

    /** The time Rust gave a reminder last (Unix ms), kept apart from its "at", the time its alarm is set for, which `again` moves. */
    static final String GIVEN = "given";

    /**
     * The list kept once Rust gives `coming` (`set`), and the alarms to set
     * for it, put in `armed`: a reminder new to the list, at its time (one
     * past rings at once: Rust says whether it still makes sense); one kept
     * already, at a time Rust moved into the future, or moved earlier than
     * it said before while it is not done, though that be past (the hours
     * edited so that today's end of work was a few minutes ago; a hold that
     * ended early): it rings at once; never one kept already again in the
     * past at the time Rust said before: it rang already, or rings at the
     * time `again` gave it, and keeps that time and whether it is done. So a
     * list given again and again with a past reminder in it (the end of
     * work's, while its ten minutes last) never rings it again and again:
     * Rust's times for it stay put, or only grow ("a second from now"). Pure,
     * checked on a JVM (android/jvm-checks/DayNotesCheck.java).
     *
     * @param kept the list kept until now
     * @param coming the list Rust gives
     * @param now the time now (Unix ms)
     * @param armed the alarms to set, added to
     * @return the list to keep
     */
    static JSONArray merged(JSONArray kept, JSONArray coming, long now, List<Arm> armed)
    {
        Map<String, JSONObject> before = new HashMap<>();
        for (int i = 0; i < kept.length(); i++) {
            JSONObject reminder = kept.optJSONObject(i);
            if (!key(reminder).isEmpty())
                before.put(key(reminder), reminder);
        }
        JSONArray out = new JSONArray();
        for (int i = 0; i < coming.length(); i++) {
            JSONObject reminder = coming.optJSONObject(i);
            if (reminder == null)
                continue;
            String key = key(reminder);
            long at = reminder.optLong("at");
            JSONObject old = before.get(key);
            JSONObject listed = copied(reminder);
            put(listed, GIVEN, at);
            // Moved earlier than Rust said last; an entry an older Sioul kept says nothing of it.
            boolean moved = old != null && old.has(GIVEN) && !old.optBoolean(DONE) && at < old.optLong(GIVEN);
            if (old != null && at <= now && !moved) {
                put(listed, "at", old.optLong("at"));
                if (old.optBoolean(DONE))
                    put(listed, DONE, true);
                out.put(listed);
                continue;
            }
            out.put(listed);
            if (!key.isEmpty() && at > 0)
                armed.add(new Arm(key, at));
        }
        return out;
    }

    /**
     * The list with `key` asked about again at `at` (`again`), set again,
     * not done. Pure (DayNotesCheck).
     *
     * @param kept the list kept
     * @param key the reminder's key
     * @param at when (Unix ms)
     * @return the list to keep
     */
    static JSONArray asked(JSONArray kept, String key, long at)
    {
        JSONArray out = new JSONArray();
        for (int i = 0; i < kept.length(); i++) {
            JSONObject reminder = copied(kept.optJSONObject(i));
            if (key.equals(key(reminder))) {
                put(reminder, "at", at);
                reminder.remove(DONE);
            }
            out.put(reminder);
        }
        return out;
    }

    /**
     * The list with `key` done with (`done`): kept, marked, while Rust lists
     * it, so that it is never set again; gone with the next list without it.
     * Pure (DayNotesCheck).
     *
     * @param kept the list kept
     * @param key the reminder's key
     * @return the list to keep
     */
    static JSONArray answered(JSONArray kept, String key)
    {
        JSONArray out = new JSONArray();
        for (int i = 0; i < kept.length(); i++) {
            JSONObject reminder = copied(kept.optJSONObject(i));
            if (key.equals(key(reminder)))
                put(reminder, DONE, true);
            out.put(reminder);
        }
        return out;
    }

    /** A copy of `reminder`, or an empty one. */
    private static JSONObject copied(JSONObject reminder)
    {
        try {
            return reminder == null ? new JSONObject() : new JSONObject(reminder.toString());
        } catch (JSONException e) {
            return new JSONObject();
        }
    }

    /** The alarms given again from the list kept: Android forgets them when it restarts. One whose time went by rings at once: Rust says whether it still makes sense. Those done with stay unset. */
    static synchronized void restore(Context context, String why)
    {
        JSONArray coming = list(context);
        schedule(context, coming);
        Log.i(DoseAlarms.TAG, "Events: " + coming.length() + " reminders given again (" + why + ").");
    }

    /**
     * Rust asked for the coming reminders, then given them (EventReceiver, on
     * a thread of its own): after a restart, an update, a change of time or
     * of zone, once a day. Not before the phone's first unlock: Sioul's files
     * cannot be read then. No answer: the list kept goes on.
     */
    static void ask(Context context, String why)
    {
        if (!context.getSystemService(UserManager.class).isUserUnlocked())
            return;
        String answer = null;
        try {
            DoseAlarms.load(context);
            answer = nativeComing(ZoneId.systemDefault().getId());
        } catch (Throwable e) {
            Log.e(DoseAlarms.TAG, "Events: Sioul did not answer (" + why + "); the list kept goes on.", e);
        }
        if (answer != null && !answer.isEmpty())
            set(context, answer);
    }

    /** A reminder asked about again at `at`: held now (you sleep), still worth telling then. */
    static synchronized void again(Context context, String key, long at)
    {
        kept(context).edit().putString(LIST, asked(list(context), key, at).toString()).commit();
        alarm(context, key, at);
    }

    /** A reminder done with (told, gone): marked, not to ring again, after a restart neither (`answered`). */
    static synchronized void done(Context context, String key)
    {
        kept(context).edit().putString(LIST, answered(list(context), key).toString()).commit();
    }

    private static void schedule(Context context, JSONArray coming)
    {
        for (int i = 0; i < coming.length(); i++) {
            JSONObject reminder = coming.optJSONObject(i);
            String key = key(reminder);
            long at = reminder == null ? 0 : reminder.optLong("at");
            if (!key.isEmpty() && at > 0 && !reminder.optBoolean(DONE))
                alarm(context, key, at);
        }
    }

    /**
     * A reminder's alarm, at its time even while the phone sleeps (Doze);
     * without "Alarms &amp; reminders", as close as Android allows: up to an hour
     * late. Never Android's alarm clock: no alarm icon for an appointment.
     */
    private static void alarm(Context context, String key, long at)
    {
        AlarmManager alarms = context.getSystemService(AlarmManager.class);
        PendingIntent ring = PendingIntent.getBroadcast(context, key.hashCode(), ringIntent(context, key),
                                                        PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_UPDATE_CURRENT);
        try {
            if (DoseAlarms.exact(context)) {
                alarms.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, at, ring);
                return;
            }
        } catch (SecurityException e) {
            // Taken back between the question and the alarm.
        }
        alarms.setAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, at, ring);
    }

    private static void cancel(Context context, String key)
    {
        PendingIntent ring = PendingIntent.getBroadcast(context, key.hashCode(), ringIntent(context, key),
                                                        PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_NO_CREATE);
        if (ring != null) {
            context.getSystemService(AlarmManager.class).cancel(ring);
            ring.cancel();
        }
    }

    /** The list asked for again at `at` (inexact: nothing hangs on its minute). */
    private static void look(Context context, long at)
    {
        PendingIntent look = PendingIntent.getBroadcast(context, LOOK_CODE, new Intent(context, EventReceiver.class).setAction(LOOK),
                                                        PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_UPDATE_CURRENT);
        if (at > System.currentTimeMillis())
            context.getSystemService(AlarmManager.class).setAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, at, look);
    }

    private static Intent ringIntent(Context context, String key)
    {
        return new Intent(context, EventReceiver.class).setAction(RING).setData(Uri.fromParts(SCHEME, key, null));
    }

    /** The reminder an intent is about; "" when none. */
    static String key(Intent intent)
    {
        Uri address = intent == null ? null : intent.getData();
        if (address == null || !SCHEME.equals(address.getScheme()))
            return "";
        String key = address.getSchemeSpecificPart();
        return key == null ? "" : key;
    }

    private static String key(JSONObject reminder)
    {
        return reminder == null ? "" : reminder.optString("key");
    }

    /** The words given with a reminder in the list, shown when Rust cannot be asked; null when not kept. */
    static synchronized JSONObject kept(Context context, String key)
    {
        JSONArray coming = list(context);
        for (int i = 0; i < coming.length(); i++) {
            JSONObject reminder = coming.optJSONObject(i);
            if (key.equals(key(reminder)))
                return reminder;
        }
        return null;
    }

    private static void put(JSONObject object, String name, Object value)
    {
        try {
            object.put(name, value);
        } catch (JSONException e) {
            // Only for a name that is null or a number that is not one.
        }
    }

    // ---------------------------------------------------------------- kept

    private static SharedPreferences kept(Context context)
    {
        return context.getSharedPreferences(KEPT, Context.MODE_PRIVATE);
    }

    private static JSONArray list(Context context)
    {
        try {
            return new JSONArray(kept(context).getString(LIST, "[]"));
        } catch (JSONException e) {
            return new JSONArray();
        }
    }

    /** A tapped notification's thing, kept until Sioul takes it (ReminderOpener): "event" and its file, "porch". */
    static synchronized void opened(Context context, String kind, String key)
    {
        JSONObject thing = new JSONObject();
        put(thing, "kind", kind);
        put(thing, "key", key == null ? "" : key);
        kept(context).edit().putString(OPENED, thing.toString()).apply();
    }

    /** What a tapped notification opens, once, as JSON {kind, key}; null when nothing (android/main.cpp, for Rust). */
    static synchronized String takeOpened(Context context)
    {
        SharedPreferences kept = kept(context);
        String thing = kept.getString(OPENED, null);
        if (thing != null)
            kept.edit().remove(OPENED).apply();
        return thing;
    }

    // ---------------------------------------------------------------- the reminders

    /**
     * The channels: "Events" at low importance, without sound or banner, for
     * Sioul's reminders before an event and the working day before; "An
     * event's alarms" at Android's default importance (its sound, no banner),
     * for the alarms an event carries. Yours to change.
     */
    static void channel(Context context)
    {
        NotificationManager notifications = context.getSystemService(NotificationManager.class);
        notifications.createNotificationChannel(Channels.quiet(CHANNEL, word(context, "channel"), NotificationManager.IMPORTANCE_LOW));
        notifications.createNotificationChannel(Channels.quiet(ALARMS, word(context, "alarms"), NotificationManager.IMPORTANCE_DEFAULT));
    }

    /**
     * Whether a reminder is an alarm its event carries: as Rust says it
     * ("kind": "alarm", "before", "event"), else by its key (`alarm:…`, a
     * list given by an older Sioul). Pure, checked on a JVM
     * (android/jvm-checks/ModeCheck.java).
     */
    static boolean isAlarm(String kind, String key)
    {
        if (kind != null && !kind.isEmpty())
            return "alarm".equals(kind);
        return key != null && key.startsWith("alarm:");
    }

    /**
     * Rust's reminder (eventalarms.rs, `show`): JSON {key, kind, title, body,
     * event (its file), until (Unix ms, when the event begins), words}. A
     * tap, or Open, brings Sioul up on the event. Any thread.
     */
    static void show(Context context, String json)
    {
        final JSONObject said;
        try {
            said = new JSONObject(json);
        } catch (JSONException e) {
            Log.e(DoseAlarms.TAG, "Events: a reminder that does not read. " + e);
            return;
        }
        JSONObject words = said.optJSONObject("words");
        if (words != null)
            kept(context).edit().putString(WORDS, words.toString()).apply();
        String key = said.optString("key");
        post(context, key, isAlarm(said.optString("kind"), key), said.optString("title"), said.optString("body"), said.optString("event"), said.optLong("until"));
        // Told (from the window's minute, maybe): its alarm has nothing left to do.
        cancel(context, key);
        done(context, key);
    }

    /**
     * The words given with the list, said when Rust cannot be asked at a
     * reminder's time: never nothing. Not the end of work's notice nor the
     * night's (kind "day"): said by Rust alone, or not at all, as on a
     * computer (Rust's notice may not come: the day closed, a meeting, the
     * notice told on another device).
     */
    static void fallback(Context context, String key)
    {
        JSONObject reminder = kept(context, key);
        if (reminder == null || isDay(reminder.optString("kind")))
            return;
        post(context, key, isAlarm(reminder.optString("kind"), key), reminder.optString("title"), reminder.optString("body"), "", 0);
    }

    /**
     * Whether an entry of the list is the end of work's notice or the
     * night's (DayNotes), which have no words kept. Pure, checked on a JVM
     * (android/jvm-checks/DayNotesCheck.java).
     *
     * @param kind the entry's kind, as Rust gave it
     * @return whether it is one of the day's
     */
    static boolean isDay(String kind)
    {
        return "day".equals(kind);
    }

    /** A reminder said for nothing (by the fallback) taken away. */
    static void dismiss(Context context, String key)
    {
        context.getSystemService(NotificationManager.class).cancel(key, NOTE);
    }

    /**
     * A reminder in the shade: an alarm the event carries in "An event's
     * alarms", or in its twin that passes do-not-disturb while every one of
     * Sioul's modes on lets an event's alarms through (PauseMode); Sioul's
     * own reminders in the quiet "Events".
     */
    private static void post(Context context, String key, boolean alarm, String title, String body, String event, long until)
    {
        channel(context);
        String channel = alarm ? PauseMode.alarmsChannelNow(context) : CHANNEL;
        // Without its event's file (said from the words kept): Sioul as by its icon.
        Intent sioul = new Intent(context, ReminderOpener.class).setData(Uri.fromParts(ReminderOpener.SCHEME, event.isEmpty() ? "app" : "event", null))
                           .putExtra(ReminderOpener.KEY, event).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        PendingIntent open = PendingIntent.getActivity(context, key.hashCode(), sioul, PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_UPDATE_CURRENT);
        Notification.Builder reminder = new Notification.Builder(context, channel)
            .setSmallIcon(R.drawable.sioul_notification)
            .setColor(context.getColor(R.color.sioul_green))
            .setContentTitle(title.isEmpty() ? "Sioul" : title)
            .setContentText(body)
            .setStyle(new Notification.BigTextStyle().bigText(body))
            .setCategory(Notification.CATEGORY_REMINDER)
            .setContentIntent(open)
            .setAutoCancel(true)
            .setOnlyAlertOnce(true)
            .addAction(new Notification.Action.Builder(Icon.createWithResource(context, R.drawable.sioul_notification), word(context, "open"), open).build());
        long left = until - System.currentTimeMillis();
        if (until > 0 && left > -KEPT_AFTER_MS)
            reminder.setTimeoutAfter(left + KEPT_AFTER_MS);
        context.getSystemService(NotificationManager.class).notify(key, NOTE, reminder.build());
    }

    // ---------------------------------------------------------------- the words said here

    private static final String[][] FALLBACK_WORDS = {
        { "channel", "Events", "Événements" },
        { "alarms", "An event's alarms", "Alarmes des événements" },
        { "alarms-pause", "An event's alarms during a pause", "Alarmes des événements pendant une pause" },
        { "mail", "New mail", "Nouveaux courriels" },
        { "mail-through", "New mail from people always let through", "Courriels des personnes qui passent toujours" },
        { "day", "End of the day", "Fin de journée" },
        { "open", "Open", "Ouvrir" },
    };

    /**
     * The words said here, as Rust gave them with the list (in the person's
     * language, crates/sioul-core/locales); before any list, these, by the
     * phone's language.
     */
    static String word(Context context, String which)
    {
        try {
            String said = new JSONObject(kept(context).getString(WORDS, "{}")).optString(which);
            if (!said.isEmpty())
                return said;
        } catch (JSONException e) {
            // The phone's own words below.
        }
        boolean french = "fr".equals(Locale.getDefault().getLanguage());
        for (String[] word : FALLBACK_WORDS)
            if (word[0].equals(which))
                return word[french ? 2 : 1];
        return which;
    }
}