/*
 * Copyright (C) 2011 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.calendar;

import android.app.Activity;
import android.app.Dialog;
import android.app.TimePickerDialog;
import android.content.ComponentName;
import android.content.Intent;
import android.content.SharedPreferences;
import android.os.Bundle;
import android.preference.CheckBoxPreference;
import android.preference.ListPreference;
import android.preference.Preference;
import android.preference.Preference.OnPreferenceChangeListener;
import android.preference.PreferenceFragment;
import android.preference.PreferenceManager;
import android.preference.PreferenceScreen;
import android.text.format.DateFormat;
import android.text.format.Time;
import android.util.Log;
import android.widget.TimePicker;

public class OtherPreferences extends PreferenceFragment  implements OnPreferenceChangeListener{
    private static final String TAG = "CalendarOtherPreferences";

    // The name of the shared preferences file. This name must be maintained for
    // historical reasons, as it's what PreferenceManager assigned the first
    // time the file was created.
    static final String SHARED_PREFS_NAME = "com.android.calendar_preferences";

    // Must be the same keys that are used in the other_preferences.xml file.
    public static final String KEY_OTHER_COPY_DB = "preferences_copy_db";
    public static final String KEY_OTHER_QUIET_HOURS = "preferences_reminders_quiet_hours";
    public static final String KEY_OTHER_REMINDERS_RESPONDED = "preferences_reminders_responded";
    public static final String KEY_OTHER_QUIET_HOURS_START =
            "preferences_reminders_quiet_hours_start";
    public static final String KEY_OTHER_QUIET_HOURS_START_HOUR =
            "preferences_reminders_quiet_hours_start_hour";
    public static final String KEY_OTHER_QUIET_HOURS_START_MINUTE =
            "preferences_reminders_quiet_hours_start_minute";
    public static final String KEY_OTHER_QUIET_HOURS_END =
            "preferences_reminders_quiet_hours_end";
    public static final String KEY_OTHER_QUIET_HOURS_END_HOUR =
            "preferences_reminders_quiet_hours_end_hour";
    public static final String KEY_OTHER_QUIET_HOURS_END_MINUTE =
            "preferences_reminders_quiet_hours_end_minute";
    public static final String KEY_OTHER_1 = "preferences_tardis_1";

    public static final int QUIET_HOURS_DEFAULT_START_HOUR = 22;
    public static final int QUIET_HOURS_DEFAULT_START_MINUTE = 0;
    public static final int QUIET_HOURS_DEFAULT_END_HOUR = 8;
    public static final int QUIET_HOURS_DEFAULT_END_MINUTE = 0;

    private static final int START_LISTENER = 1;
    private static final int END_LISTENER = 2;
    private static final String format24Hour = "%H:%M";
    private static final String format12Hour = "%I:%M%P";

    private Preference mCopyDb;
    private ListPreference mSkipReminders;
    private CheckBoxPreference mQuietHours;
    private Preference mQuietHoursStart;
    private Preference mQuietHoursEnd;

    private TimePickerDialog mTimePickerDialog;
    private TimeSetListener mQuietHoursStartListener;
    private TimePickerDialog mQuietHoursStartDialog;
    private TimeSetListener mQuietHoursEndListener;
    private TimePickerDialog mQuietHoursEndDialog;
    private boolean mIs24HourMode;

    public OtherPreferences() {
    }

    @Override
    public void onCreate(Bundle icicle) {
        super.onCreate(icicle);
        PreferenceManager manager = getPreferenceManager();
        manager.setSharedPreferencesName(SHARED_PREFS_NAME);
        SharedPreferences prefs = manager.getSharedPreferences();

        addPreferencesFromResource(R.xml.other_preferences);
        mCopyDb = findPreference(KEY_OTHER_COPY_DB);
        mSkipReminders = (ListPreference) findPreference(KEY_OTHER_REMINDERS_RESPONDED);
        String skipPreferencesValue = null;
        if (mSkipReminders != null) {
            skipPreferencesValue = mSkipReminders.getValue();
            mSkipReminders.setOnPreferenceChangeListener(this);
        }
        updateSkipRemindersSummary(skipPreferencesValue);

        Activity activity = getActivity();
        if (activity == null) {
            Log.d(TAG, "Activity was null");
        }
        mIs24HourMode = DateFormat.is24HourFormat(activity);

        mQuietHours =
                (CheckBoxPreference) findPreference(KEY_OTHER_QUIET_HOURS);

        int startHour = prefs.getInt(KEY_OTHER_QUIET_HOURS_START_HOUR,
                QUIET_HOURS_DEFAULT_START_HOUR);
        int startMinute = prefs.getInt(KEY_OTHER_QUIET_HOURS_START_MINUTE,
                QUIET_HOURS_DEFAULT_START_MINUTE);
        mQuietHoursStart = findPreference(KEY_OTHER_QUIET_HOURS_START);
        mQuietHoursStartListener = new TimeSetListener(START_LISTENER);
        mQuietHoursStartDialog = new TimePickerDialog(
                activity, mQuietHoursStartListener,
                startHour, startMinute, mIs24HourMode);
        mQuietHoursStart.setSummary(formatTime(startHour, startMinute));

        int endHour = prefs.getInt(KEY_OTHER_QUIET_HOURS_END_HOUR,
                QUIET_HOURS_DEFAULT_END_HOUR);
        int endMinute = prefs.getInt(KEY_OTHER_QUIET_HOURS_END_MINUTE,
                QUIET_HOURS_DEFAULT_END_MINUTE);
        mQuietHoursEnd = findPreference(KEY_OTHER_QUIET_HOURS_END);
        mQuietHoursEndListener = new TimeSetListener(END_LISTENER);
        mQuietHoursEndDialog = new TimePickerDialog(
                activity, mQuietHoursEndListener,
                endHour, endMinute, mIs24HourMode);
        mQuietHoursEnd.setSummary(formatTime(endHour, endMinute));
    }

    @Override
    public boolean onPreferenceChange(Preference preference, Object objValue) {
        final String key = preference.getKey();

        if (KEY_OTHER_REMINDERS_RESPONDED.equals(key)) {
            String value = String.valueOf(objValue);
            updateSkipRemindersSummary(value);
        }

        return true;
    }

    @Override
    public boolean onPreferenceTreeClick(PreferenceScreen screen, Preference preference) {
        if (preference == mCopyDb) {
            Intent intent = new Intent(Intent.ACTION_MAIN);
            intent.setComponent(new ComponentName("com.android.providers.calendar",
                    "com.android.providers.calendar.CalendarDebugActivity"));
            startActivity(intent);
        } else if (preference == mQuietHoursStart) {
            if (mTimePickerDialog == null) {
                mTimePickerDialog = mQuietHoursStartDialog;
                mTimePickerDialog.show();
            } else {
                Log.v(TAG, "not null");
            }
        } else if (preference == mQuietHoursEnd) {
            if (mTimePickerDialog == null) {
                mTimePickerDialog = mQuietHoursEndDialog;
                mTimePickerDialog.show();
            } else {
                Log.v(TAG, "not null");
            }
        } else {
            return super.onPreferenceTreeClick(screen, preference);
        }
        return true;
    }

    private class TimeSetListener implements TimePickerDialog.OnTimeSetListener {
        private int mListenerId;

        public TimeSetListener(int listenerId) {
            mListenerId = listenerId;
        }

        @Override
        public void onTimeSet(TimePicker view, int hourOfDay, int minute) {
            mTimePickerDialog = null;

            SharedPreferences prefs = getPreferenceManager().getSharedPreferences();
            SharedPreferences.Editor editor = prefs.edit();

            String summary = formatTime(hourOfDay, minute);
            switch (mListenerId) {
                case (START_LISTENER):
                    mQuietHoursStart.setSummary(summary);
                    editor.putInt(KEY_OTHER_QUIET_HOURS_START_HOUR, hourOfDay);
                    editor.putInt(KEY_OTHER_QUIET_HOURS_START_MINUTE, minute);
                    break;
                case (END_LISTENER):
                    mQuietHoursEnd.setSummary(summary);
                    editor.putInt(KEY_OTHER_QUIET_HOURS_END_HOUR, hourOfDay);
                    editor.putInt(KEY_OTHER_QUIET_HOURS_END_MINUTE, minute);
                    break;
                default:
                    Log.d(TAG, "Set time for unknown listener: "+mListenerId);
            }

            editor.commit();
        }
    }

    /**
     * @param hourOfDay the hour of the day (0-24)
     * @param minute
     * @return human-readable string formatted based on 24-hour mode.
     */
    private String formatTime(int hourOfDay, int minute) {
        Time time = new Time();
        time.hour = hourOfDay;
        time.minute = minute;

        String format = mIs24HourMode? format24Hour : format12Hour;
        return time.format(format);
    }

    /**
     * Update the summary for the SkipReminders preference.
     * @param value The corresponding value of which summary to set. If null, the default summary
     * will be set, and the value will be set accordingly too.
     */
    private void updateSkipRemindersSummary(String value) {
        if (mSkipReminders != null) {
            // Default to "declined". Must match with R.array.preferences_skip_reminders_values.
            int index = 0;

            CharSequence[] values = mSkipReminders.getEntryValues();
            CharSequence[] entries = mSkipReminders.getEntries();
            for(int value_i = 0; value_i < values.length; value_i++) {
                if (values[value_i].equals(value)) {
                    index = value_i;
                    break;
                }
            }
            mSkipReminders.setSummary(entries[index].toString());
            if (value == null) {
                // Value was not known ahead of time, so the default value will be set.
                mSkipReminders.setValue(values[index].toString());
            }
        }
    }
}