path: root/app/src/main/java/com/camilstaps/taize/Taize.java

package com.camilstaps.taize;

import android.content.Context;
import android.preference.PreferenceManager;
import android.widget.Toast;

import com.camilstaps.common.Date;
import com.camilstaps.common.DatedString;
import com.camilstaps.common.DatedStringPreferenceSet;
import com.camilstaps.common.Listener;
import com.camilstaps.rss.RetrieveFeedTask;
import com.camilstaps.rss.RssParser;

import org.json.JSONException;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Class specific to methods for Taize
 * @author Camil Staps
 */
public class Taize {

    private static final String url_reading_feed = "http://www.taize.fr/readingrss.php";
    private static final String url_reading_feed_en = "http://www.taize.fr/readingrss.php?lang=en";
    private static final String url_meditation_feed = "http://www.taize.fr/pdcrss.xml";
    private static final String url_podcasts_feed = "http://www.taize.fr/podcast";

    private static final int MAX_DIFFDATE_READING = 10;

    /**
     * Get the bible text corresponding to the daily reading of a certain date
     * @param context
     * @param listener
     */
    public static void getDailyReadingBibleText(final Context context, final Listener<String> listener, Date date) {
        Set<DatedString> texts = (Set) DatedStringPreferenceSet.get(context, "dailyreadingbibletexts", DatedString.class);
        for (DatedString text : texts) {
            if (text.getDate().equals(date)) {
                listener.success(text.getString());
                return;
            }
        }
        fetchDailyReadingBibleText(context, listener, date);
    }

    /**
     * Fetch the bible text corresponding to the daily reading of a certain date
     * @param context
     * @param listener
     * @param date
     */
    private static void fetchDailyReadingBibleText(final Context context, final Listener<String> listener, final Date date) {
        DatedStringPreferenceSet.add(context, "dailyreadingbibletexts", new DatedString(date, "Fetching bible text..."));

        getEnglishDailyReading(context, new Listener<DailyReading>() {
            @Override
            public void success(DailyReading reading) {
                BibleText text = reading.getBibleReference();
                if (text == null) {
                    failure();
                    return;
                }

                text.getText(context, new Listener<String>() {
                    @Override
                    public void success(String s) {
                        DatedStringPreferenceSet.updateOrAdd(context, "dailyreadingbibletexts", new DatedString(date, s));
                        listener.success(s);
                    }

                    @Override
                    public void failure() {
                        listener.failure();
                        DatedStringPreferenceSet.remove(context, "dailyreadingbibletexts", date);
                    }
                });
            }

            @Override
            public void failure() {
                listener.failure();
                DatedStringPreferenceSet.remove(context, "dailyreadingbibletexts", date);
            }
        }, date);
    }

    /**
     * Get the English daily reading (needed for the English Bible reference)
     * @param context
     * @param listener
     */
    private static void getEnglishDailyReading(final Context context, final Listener<DailyReading> listener, Date date) {
        Set<DailyReading> englishDailyReadings = (Set) DatedStringPreferenceSet.get(context, "englishdailyreadings", DailyReading.class);

        for (DailyReading reading : englishDailyReadings) {
            if (reading.getDate().equals(date)) {
                listener.success(reading);
                return;
            }
        }

        fetchEnglishDailyReading(context, listener, date);
    }

    /**
     * Fetch the English daily reading (needed for the English Bible reference)
     * @param context
     * @param listener
     * @param date
     */
    private static void fetchEnglishDailyReading(final Context context, final Listener<DailyReading> listener, final Date date) {

        RetrieveFeedTask retrieve = new RetrieveFeedTask();
        retrieve.setRssDownloadListener(new Listener<RssParser>() {
            @Override
            public void success(RssParser parser) {
                try {
                    String text = parser.getItem(0).description.trim();
                    DailyReading reading = new DailyReading(date, text);

                    DatedStringPreferenceSet.add(context, "englishdailyreadings", reading);

                    listener.success(reading);
                } catch (Exception e) {
                    failure();
                }
            }

            @Override
            public void failure() {
                Toast.makeText(context, "Failed to fetch daily reading.", Toast.LENGTH_SHORT).show();
                listener.failure();
            }
        });

        try {
            retrieve.execute(url_reading_feed_en + "&date=" + date.toString()).get();
        } catch (Exception e) {
            e.printStackTrace();
            listener.failure();
        }

    }

    /**
     * Get the daily reading of a Date
     * @param context
     * @param listener
     * @param date
     */
    public static void getDailyReading(final Context context, final Listener<DailyReading> listener, Date date) {

        Set<DailyReading> dailyReadings = (Set) DatedStringPreferenceSet.get(context, "dailyreadings", DailyReading.class);

        for (DailyReading reading : dailyReadings) {
            if (reading.getDate().equals(date)) {
                listener.success(reading);
                return;
            }
        }

        fetchDailyReading(context, listener, date);

    }

    /**
     * Fetch the daily reading of a Date
     * @param context
     * @param listener
     * @param date
     */
    private static void fetchDailyReading(final Context context, final Listener<DailyReading> listener, final Date date) {

        RetrieveFeedTask retrieve = new RetrieveFeedTask();
        retrieve.setRssDownloadListener(new Listener<RssParser>() {
            @Override
            public void success(RssParser parser) {
                try {
                    String text = parser.getItem(0).description.trim();
                    DailyReading reading = new DailyReading(date, text);

                    DatedStringPreferenceSet.add(context, "dailyreadings", reading);

                    listener.success(reading);
                } catch (Exception e) {
                    failure();
                }
            }

            @Override
            public void failure() {
                Toast.makeText(context, "Failed to fetch daily reading.", Toast.LENGTH_SHORT).show();
                listener.failure();
            }
        });

        try {
            retrieve.execute(url_reading_feed
                    + "?lang=" + PreferenceManager.getDefaultSharedPreferences(context).getString(SettingsActivity.SettingsFragment.PREF_LANGUAGE_READINGS, "en")
                    + "&date=" + date.toString()
            ).get();
        } catch (Exception e) {
            e.printStackTrace();
            listener.failure();
        }

    }

    /**
     * Get the daily meditation of a date
     * @param context
     * @param listener
     * @param date
     */
    public static void getDailyMeditation(final Context context, final Listener<DailyMeditation> listener, Date date) {

        Set<DailyMeditation> dailyMeditations = (Set) DatedStringPreferenceSet.get(context, "dailymeditations", DailyMeditation.class);

        for (DailyMeditation meditation : dailyMeditations) {
            if (meditation.getDate().equals(date)) {
                listener.success(meditation);
                return;
            }
        }

        fetchDailyMeditation(context, listener, date);

    }

    /**
     * Fetch the daily meditation of a date
     * @param context
     * @param listener
     * @param date
     */
    private static void fetchDailyMeditation(final Context context, final Listener<DailyMeditation> listener, final Date date) {

        RetrieveFeedTask retrieve = new RetrieveFeedTask();
        retrieve.setRssDownloadListener(new Listener<RssParser>() {
            @Override
            public void success(RssParser parser) {
                try {
                    String text = parser.getItem(0).description.trim();
                    DailyMeditation reading = new DailyMeditation(date, text);

                    DatedStringPreferenceSet.add(context, "dailymeditations", reading);

                    listener.success(reading);
                } catch (Exception e) {
                    failure();
                }
            }

            @Override
            public void failure() {
                Toast.makeText(context, "Failed to fetch daily meditation.", Toast.LENGTH_SHORT).show();
                listener.failure();
            }
        });

        try {
            retrieve.execute(url_meditation_feed
                    + "?lang=" + PreferenceManager.getDefaultSharedPreferences(context).getString(
                            SettingsActivity.SettingsFragment.PREF_LANGUAGE_READINGS,
                            context.getString(R.string.pref_language_dailyreading_default))
                    + "&date=" + date.toString()
            ).get();
        } catch (Exception e) {
            e.printStackTrace();
            listener.failure();
        }

    }

    /**
     * Get the podcasts
     * @param context
     * @param listener
     *
     * @todo now that Taizé uses "Dom Radio" as title, we can't search for dates in the title anymore...
     */
    public static void getPodcasts(final Context context, final Listener<List<Podcast>> listener) {

        RetrieveFeedTask retrieve = new RetrieveFeedTask();
        retrieve.setRssDownloadListener(new Listener<RssParser>() {
            @Override
            public void success(RssParser data) {
                Set<Podcast> podcasts = new HashSet<>();
                for (RssParser.Item item : data.getItems()) {
                    Pattern datePattern = Pattern.compile("^(\\d{4})-(\\d{1,2})-(\\d{1,2})[\\s:]*(.*)");
                    Matcher dateMatcher = datePattern.matcher(item.title);
                    if (dateMatcher.find()) {
                        Date date = new Date(Integer.parseInt(dateMatcher.group(1)), Integer.parseInt(dateMatcher.group(2)), Integer.parseInt(dateMatcher.group(3)));
                        try {
                            podcasts.add(new Podcast(date, dateMatcher.group(4), item.guid));
                        } catch (JSONException e) {}
                    }
                }

                List<Podcast> sortedPodcasts = new ArrayList<>(podcasts);
                Collections.sort(sortedPodcasts);
                listener.success(sortedPodcasts);
            }

            @Override
            public void failure() {
                Toast.makeText(context, context.getResources().getText(R.string.failure_fetching_podcasts), Toast.LENGTH_LONG).show();
                listener.failure();
            }
        });

        try {
            retrieve.execute(url_podcasts_feed).get();
        } catch (Exception e) {
            e.printStackTrace();
            listener.failure();
        }

    }

    /**
     * Clean text sets to remove texts related to dates too far away
     * @param context
     */
    public static void cleanTextSets(Context context) {
        cleanDailyReadingsSet(context, "dailyreadings");
        cleanDailyReadingsSet(context, "englishdailyreadings");
        //DatedStringPreferenceSet.clear(context, "dailyreadingbibletexts");
    }

    /**
     * Clean a specific DatedStringPreferenceSet to remove duplicate items and items related to dates too far away
     * @param context
     * @param key
     */
    public static void cleanDailyReadingsSet(Context context, String key) {
        Set<DailyReading> set = (Set) DatedStringPreferenceSet.get(context, key, DailyReading.class);
        Iterator<DailyReading> iterator = set.iterator();
        while (iterator.hasNext()) {
            DailyReading reading = iterator.next();
            if (reading.getDate().diffDays(new Date()) > MAX_DIFFDATE_READING) {
                // Remove too old / too new
                iterator.remove();
            }
        }
        DatedStringPreferenceSet.put(context, key, (Set) set);
    }

}