package com.vscool.os.alarm;

import android.annotation.SuppressLint;
import android.app.AlarmManager;
import android.app.PendingIntent;
import android.content.ContentValues;
import android.content.Context;
import android.content.Intent;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.os.Environment;
import android.text.TextUtils;
import android.util.Log;

import com.arialyy.aria.core.Aria;
import com.blankj.utilcode.util.FileUtils;
import com.vscool.os.BuildConfig;
import com.vscool.os.service.main.MainService;
import com.vscool.os.utils.FileUtil;
import com.vscool.os.utils.Utils;

import java.io.File;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.TimeZone;

public class AlarmUtils {
    private static final String TAG = "AlarmUtils";

    @SuppressLint("StaticFieldLeak")
    private static AlarmUtils sInstance;
    private Context mContext;
    private AlarmManager mAlarmManager;
    private SQLiteDatabase mDatabase;
    private AlarmOpenHelper mAlarmOpenHelper;
    private HashSet<PendingIntent> pendingIntents;

    public static final int ONE_DAY_TIME = 1000 * 60 * 60 * 24;

    /*一次性*/
    public static final int ONCE = 1;
    /*每天*/
    public static final int LOOP = 2;
    /*周一到周五*/
    public static final int WORKING_DAY = 3;
    /*休息日*/
    public static final int OFF_DAY = 4;

    private AlarmUtils(Context context) {
        this.mContext = context.getApplicationContext();
//        this.mAlarmOpenHelper = new AlarmOpenHelper(context, AlarmOpenHelper.DATABASE_NAME, null, AlarmOpenHelper.DATABASE_VERSION);
        if (BuildConfig.DEBUG) {
            this.mAlarmOpenHelper = new AlarmOpenHelper(context,
                    Environment.getExternalStorageDirectory() + File.separator + AlarmOpenHelper.DATABASE_NAME,
                    null, AlarmOpenHelper.DATABASE_VERSION);
        } else {
            this.mAlarmOpenHelper = new AlarmOpenHelper(context,
                    context.getExternalCacheDir() + File.separator + AlarmOpenHelper.DATABASE_NAME,
                    null, AlarmOpenHelper.DATABASE_VERSION);
        }
        this.mDatabase = mAlarmOpenHelper.getWritableDatabase();
        this.mAlarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
        pendingIntents = getOldPendingIntentsSet();
    }

    public static void init(Context context) {
        if (context == null) {
            throw new RuntimeException("context is NULL");
        }
        if (sInstance == null) {
            sInstance = new AlarmUtils(context);
        }
    }

    public static AlarmUtils getInstance() {
        if (sInstance == null) {
            throw new IllegalStateException("You must be init AlarmUtils first");
        }
        return sInstance;
    }

    private void openDatabase() {
//        if (mDatabase == null || !mDatabase.isOpen()) {
//            mDatabase = mAlarmOpenHelper.getWritableDatabase();
//        }
    }

    private ContentValues getValuesFromAlarmClock(AlarmClockData alarmClockData) {
        ContentValues values = new ContentValues();
        values.put(AlarmOpenHelper.KEY_ID, alarmClockData.getId());
        values.put(AlarmOpenHelper.KEY_TYPE, alarmClockData.getType());
        values.put(AlarmOpenHelper.KEY_TIME, alarmClockData.getTime());
        values.put(AlarmOpenHelper.KEY_TITLE, alarmClockData.getTitle());
        values.put(AlarmOpenHelper.KEY_VOICE, alarmClockData.getVoice());
        values.put(AlarmOpenHelper.KEY_VOICE_MD5, alarmClockData.getVoice_md5());
        values.put(AlarmOpenHelper.KEY_FILE, alarmClockData.getFile());
        values.put(AlarmOpenHelper.KEY_FILE_MD5, alarmClockData.getFile_md5());
        values.put(AlarmOpenHelper.KEY_REMIND_TYPE, alarmClockData.getRemind_type());
        values.put(AlarmOpenHelper.KEY_IS_ONOFF, alarmClockData.getIs_onoff());
        values.put(AlarmOpenHelper.KEY_CLAZZ, alarmClockData.getClazz());

        values.put(AlarmOpenHelper.KEY_FINISHED, alarmClockData.isFinished());
        values.put(AlarmOpenHelper.KEY_IS_LOCAL, alarmClockData.isIs_local());
        values.put(AlarmOpenHelper.KEY_EDITED, alarmClockData.isEdited());
        values.put(AlarmOpenHelper.KEY_DELETED, alarmClockData.isDeleted());
        return values;
    }

    /**
     * 增加数据
     *
     * @param alarmClockData
     * @return
     */
    public boolean addAlarmClock(AlarmClockData alarmClockData) {
        ContentValues values = getValuesFromAlarmClock(alarmClockData);
        long id = 0;
        mDatabase.beginTransaction();
        try {
            id = mDatabase.insertWithOnConflict(AlarmOpenHelper.TABLE_ALARM, null, values, SQLiteDatabase.CONFLICT_REPLACE);
            mDatabase.setTransactionSuccessful();
        } catch (Exception e) {
            Log.e(TAG, "addAlarmClock: " + e.getMessage());
        } finally {
            mDatabase.endTransaction();
        }
        setAlarm(alarmClockData);
        return id > 0;
    }

    /**
     * 增加数据
     *
     * @param alarmClockData
     * @return
     */
    public boolean addLocalAlarmClock(AlarmClockData alarmClockData) {
        ContentValues values = getValuesFromAlarmClock(alarmClockData);
        long id = 0;
        mDatabase.beginTransaction();
        try {
            id = mDatabase.insertWithOnConflict(AlarmOpenHelper.TABLE_ALARM, null, values, SQLiteDatabase.CONFLICT_REPLACE);
            mDatabase.setTransactionSuccessful();
        } catch (Exception e) {
            Log.e(TAG, "addLocalAlarmClock: " + e.getMessage());
        } finally {
            mDatabase.endTransaction();
        }
        return id > 0;
    }


    /**
     * 更新数据
     *
     * @param alarmClockData
     * @return
     */
    public boolean updateAlarmClock(AlarmClockData alarmClockData) {
        AlarmClockData old = getDatabaseSingleAlarm(alarmClockData);
        if (old != null) {
            PendingIntent pendingIntent = getPendingIntent(old);
            if (pendingIntent != null) {
                mAlarmManager.cancel(pendingIntent);
            }
        }
        ContentValues values = getValuesFromAlarmClock(alarmClockData);
        long id = 0;
        mDatabase.beginTransaction();
        try {
            id = mDatabase.insertWithOnConflict(AlarmOpenHelper.TABLE_ALARM, null, values, SQLiteDatabase.CONFLICT_REPLACE);
            mDatabase.setTransactionSuccessful();
        } catch (Exception e) {
            Log.e(TAG, "updateAlarmClock: " + e.getMessage());
        } finally {
            mDatabase.endTransaction();
        }
        setAlarm(alarmClockData);
        return id > 0;
    }

    public boolean updateAlarmClock(AlarmClockData alarmClockData, int newId) {
        int oldId = alarmClockData.getId();
        AlarmClockData old = getDatabaseSingleAlarm(alarmClockData);
        if (old != null) {
//            deleteAlarmClock(oldId);
            PendingIntent pendingIntent = getPendingIntent(old);
            if (pendingIntent != null) {
                mAlarmManager.cancel(pendingIntent);
            }
        }
        alarmClockData.setId(newId);
        ContentValues values = getValuesFromAlarmClock(alarmClockData);
        long id = 0;
        mDatabase.beginTransaction();
        try {
            id = mDatabase.update(AlarmOpenHelper.TABLE_ALARM, values, "id=" + oldId, null);
            mDatabase.setTransactionSuccessful();
        } catch (Exception e) {
            Log.e(TAG, "updateAlarmClock: " + e.getMessage());
        } finally {
            mDatabase.endTransaction();
        }
        setAlarm(alarmClockData);
        return id > 0;
    }

    /**
     * 批量插入数据
     *
     * @param list
     */
    public void insertAlarmClockList(List<AlarmClockData> list) {
        List<ContentValues> contentValuesList = new ArrayList<>();
        for (AlarmClockData alarmClockData : list) {
            ContentValues values = getValuesFromAlarmClock(alarmClockData);
            contentValuesList.add(values);
        }
        mDatabase.beginTransaction();
        try {
            for (ContentValues v : contentValuesList) {
                mDatabase.insertWithOnConflict(AlarmOpenHelper.TABLE_ALARM, null, v, SQLiteDatabase.CONFLICT_REPLACE);
            }
            mDatabase.setTransactionSuccessful();
        } catch (Exception e) {
            Log.e(TAG, "insertListValues: " + e.getMessage());
        } finally {
            mDatabase.endTransaction();
        }
    }

    /**
     * 删除数据
     *
     * @param alarmClockData
     * @return
     */
    public boolean deleteAlarmClock(AlarmClockData alarmClockData) {
        if (alarmClockData == null) {
            return true;
        }
        PendingIntent pendingIntent = getPendingIntent(alarmClockData);
        if (pendingIntent != null) {
            mAlarmManager.cancel(pendingIntent);
        }
        return deleteAlarmClock(alarmClockData.getId());
    }

    public boolean deleteAlarmClock(int RowID) {
        long id = 0;
        mDatabase.beginTransaction();
        try {
            id = mDatabase.delete(AlarmOpenHelper.TABLE_ALARM, " id =" + RowID, null);
            mDatabase.setTransactionSuccessful();
        } catch (Exception e) {
            Log.e(TAG, "deleteAlarmClock: " + e.getMessage());
        } finally {
            mDatabase.endTransaction();
        }
        return id > 0;
    }

    /**
     * 删除所有闹钟
     */
    public void deleteAllAlarmClock() {
        Log.e(TAG, "deleteAllAlarmClock: ");
        HashSet<PendingIntent> pendingIntents = getOldPendingIntentsSet();
        Iterator<PendingIntent> pendingIntentIterator = pendingIntents.iterator();
        while (pendingIntentIterator.hasNext()) {
            PendingIntent pendingIntent = pendingIntentIterator.next();
            mAlarmManager.cancel(pendingIntent);
            pendingIntentIterator.remove();
        }
        List<AlarmClockData> alarmClockData = getDatabaseAlarms();
        for (AlarmClockData data : alarmClockData) {
            Log.e(TAG, "deleteAllAlarmClock: id = " + data);
            if (data.isIs_local()) {
                continue;
            }
            deleteAlarmClock(data.getId());
        }
    }

    /**
     * 获取所有Alarm
     *
     * @return
     */
    public List<AlarmClockData> getDatabaseAlarms() {
        List<AlarmClockData> list = new ArrayList<>();
        String selectQuery = "SELECT * FROM " + AlarmOpenHelper.TABLE_ALARM;
        Cursor cursor = mDatabase.rawQuery(selectQuery, null);
        if (cursor.moveToFirst()) {
            do {
                AlarmClockData alarmClockData = new AlarmClockData();
                alarmClockData.setId(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_ID)));
                alarmClockData.setType(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_TYPE)));
                alarmClockData.setTime(cursor.getString(cursor.getColumnIndex(AlarmOpenHelper.KEY_TIME)));
                alarmClockData.setTitle(cursor.getString(cursor.getColumnIndex(AlarmOpenHelper.KEY_TITLE)));
                alarmClockData.setVoice(cursor.getString(cursor.getColumnIndex(AlarmOpenHelper.KEY_VOICE)));
                alarmClockData.setVoice_md5(cursor.getString(cursor.getColumnIndex(AlarmOpenHelper.KEY_VOICE_MD5)));
                alarmClockData.setFile(cursor.getString(cursor.getColumnIndex(AlarmOpenHelper.KEY_FILE)));
                alarmClockData.setFile_md5(cursor.getString(cursor.getColumnIndex(AlarmOpenHelper.KEY_FILE_MD5)));
                alarmClockData.setRemind_type(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_REMIND_TYPE)));
                alarmClockData.setIs_onoff(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_IS_ONOFF)));
                alarmClockData.setClazz(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_CLAZZ)));

                alarmClockData.setFinished(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_FINISHED)) == 1);
                alarmClockData.setIs_local(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_IS_LOCAL)) == 1);
                alarmClockData.setEdited(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_EDITED)) == 1);
                alarmClockData.setDeleted(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_DELETED)) == 1);
                list.add(alarmClockData);
            } while (cursor.moveToNext());
        }
        cursor.close();
        return list;
    }

    /**
     * @return 获取单个闹钟
     */
    public AlarmClockData getDatabaseSingleAlarm(AlarmClockData data) {
        return getDatabaseSingleAlarm(data.getId());
    }

    public AlarmClockData getDatabaseSingleAlarm(int id) {
        List<AlarmClockData> list = new ArrayList<>();
        String selectQuery = "SELECT * FROM " + AlarmOpenHelper.TABLE_ALARM + " where id =" + id;
        Cursor cursor = mDatabase.rawQuery(selectQuery, null);
        if (cursor.moveToFirst()) {
            do {
                AlarmClockData alarmClockData = new AlarmClockData();
                alarmClockData.setId(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_ID)));
                alarmClockData.setType(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_TYPE)));
                alarmClockData.setTime(cursor.getString(cursor.getColumnIndex(AlarmOpenHelper.KEY_TIME)));
                alarmClockData.setTitle(cursor.getString(cursor.getColumnIndex(AlarmOpenHelper.KEY_TITLE)));
                alarmClockData.setVoice(cursor.getString(cursor.getColumnIndex(AlarmOpenHelper.KEY_VOICE)));
                alarmClockData.setVoice_md5(cursor.getString(cursor.getColumnIndex(AlarmOpenHelper.KEY_VOICE_MD5)));
                alarmClockData.setFile(cursor.getString(cursor.getColumnIndex(AlarmOpenHelper.KEY_FILE)));
                alarmClockData.setFile_md5(cursor.getString(cursor.getColumnIndex(AlarmOpenHelper.KEY_FILE_MD5)));
                alarmClockData.setRemind_type(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_REMIND_TYPE)));
                alarmClockData.setIs_onoff(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_IS_ONOFF)));
                alarmClockData.setClazz(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_CLAZZ)));

                alarmClockData.setFinished(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_FINISHED)) == 1);
                alarmClockData.setIs_local(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_IS_LOCAL)) == 1);
                alarmClockData.setEdited(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_EDITED)) == 1);
                alarmClockData.setDeleted(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_DELETED)) == 1);
                list.add(alarmClockData);
            } while (cursor.moveToNext());
        }
        cursor.close();
        return list.size() == 0 ? null : list.get(0);
    }

    public List<AlarmClockData> getDeletedAlarm() {
        List<AlarmClockData> list = new ArrayList<>();
        String selectQuery = "SELECT * FROM " + AlarmOpenHelper.TABLE_ALARM + " where deleted = 1";
        Cursor cursor = mDatabase.rawQuery(selectQuery, null);
        if (cursor.moveToFirst()) {
            do {
                AlarmClockData alarmClockData = new AlarmClockData();
                alarmClockData.setId(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_ID)));
                alarmClockData.setType(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_TYPE)));
                alarmClockData.setTime(cursor.getString(cursor.getColumnIndex(AlarmOpenHelper.KEY_TIME)));
                alarmClockData.setTitle(cursor.getString(cursor.getColumnIndex(AlarmOpenHelper.KEY_TITLE)));
                alarmClockData.setVoice(cursor.getString(cursor.getColumnIndex(AlarmOpenHelper.KEY_VOICE)));
                alarmClockData.setVoice_md5(cursor.getString(cursor.getColumnIndex(AlarmOpenHelper.KEY_VOICE_MD5)));
                alarmClockData.setFile(cursor.getString(cursor.getColumnIndex(AlarmOpenHelper.KEY_FILE)));
                alarmClockData.setFile_md5(cursor.getString(cursor.getColumnIndex(AlarmOpenHelper.KEY_FILE_MD5)));
                alarmClockData.setRemind_type(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_REMIND_TYPE)));
                alarmClockData.setIs_onoff(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_IS_ONOFF)));
                alarmClockData.setClazz(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_CLAZZ)));

                alarmClockData.setFinished(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_FINISHED)) == 1);
                alarmClockData.setIs_local(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_IS_LOCAL)) == 1);
                alarmClockData.setEdited(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_EDITED)) == 1);
                alarmClockData.setDeleted(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_DELETED)) == 1);
                list.add(alarmClockData);
            } while (cursor.moveToNext());
        }
        cursor.close();
        return list;
    }

    public List<AlarmClockData> getLocalAddAlarm() {
        List<AlarmClockData> list = new ArrayList<>();
        String selectQuery = "SELECT * FROM " + AlarmOpenHelper.TABLE_ALARM + " where is_local = 1";
        Cursor cursor = mDatabase.rawQuery(selectQuery, null);
        if (cursor.moveToFirst()) {
            do {
                AlarmClockData alarmClockData = new AlarmClockData();
                alarmClockData.setId(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_ID)));
                alarmClockData.setType(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_TYPE)));
                alarmClockData.setTime(cursor.getString(cursor.getColumnIndex(AlarmOpenHelper.KEY_TIME)));
                alarmClockData.setTitle(cursor.getString(cursor.getColumnIndex(AlarmOpenHelper.KEY_TITLE)));
                alarmClockData.setVoice(cursor.getString(cursor.getColumnIndex(AlarmOpenHelper.KEY_VOICE)));
                alarmClockData.setVoice_md5(cursor.getString(cursor.getColumnIndex(AlarmOpenHelper.KEY_VOICE_MD5)));
                alarmClockData.setFile(cursor.getString(cursor.getColumnIndex(AlarmOpenHelper.KEY_FILE)));
                alarmClockData.setFile_md5(cursor.getString(cursor.getColumnIndex(AlarmOpenHelper.KEY_FILE_MD5)));
                alarmClockData.setRemind_type(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_REMIND_TYPE)));
                alarmClockData.setIs_onoff(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_IS_ONOFF)));
                alarmClockData.setClazz(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_CLAZZ)));

                alarmClockData.setFinished(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_FINISHED)) == 1);
                alarmClockData.setIs_local(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_IS_LOCAL)) == 1);
                alarmClockData.setEdited(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_EDITED)) == 1);
                alarmClockData.setDeleted(cursor.getInt(cursor.getColumnIndex(AlarmOpenHelper.KEY_DELETED)) == 1);
                list.add(alarmClockData);
            } while (cursor.moveToNext());
        }
        cursor.close();
        return list;
    }


    /**
     * 设置闹钟列表
     *
     * @param data
     */
    public void setAlarmClockData(List<AlarmClockData> data) {
        Log.e(TAG, "setAlarmClockData: ");
        if (pendingIntents == null) {
            pendingIntents = getOldPendingIntentsSet();
        }
        Iterator<PendingIntent> pendingIntentIterator = pendingIntents.iterator();
        while (pendingIntentIterator.hasNext()) {
            PendingIntent pendingIntent = pendingIntentIterator.next();
            mAlarmManager.cancel(pendingIntent);
            pendingIntentIterator.remove();
        }
        List<AlarmClockData> newData = mergeData(data);
        for (AlarmClockData clockData : newData) {
            setAlarm(clockData);
            checkResource(clockData.getFile());
        }
        insertAlarmClockList(newData);
    }

    /**
     * @param url 下载资源
     */
    private void checkResource(String url) {
        if (TextUtils.isEmpty(url)) {
            return;
        }
        String fileName = url.substring(url.lastIndexOf("/") + 1, url.length());
        String realPath = Utils.getDownLoadPath(mContext) + fileName;
        File file = new File(realPath);
        if (!file.exists()) {
            Aria.download(this)
                    .load(url)     //读取下载地址
                    .setFilePath(Utils.getDownLoadPath(mContext) + fileName)
                    .create();   //启动下载}
        }
    }

    /**
     * 合并闹钟列表，删除不存在闹钟
     *
     * @param newAlarmClockDataList
     * @return 新增的闹钟
     */
    private List<AlarmClockData> mergeData(List<AlarmClockData> newAlarmClockDataList) {
        HashMap<Integer, AlarmClockData> alarmClockDataMap = new HashMap<>();
        if (newAlarmClockDataList != null) {
            for (AlarmClockData alarmClockData : newAlarmClockDataList) {
                alarmClockDataMap.put(alarmClockData.getId(), alarmClockData);
            }
        }
        HashMap<Integer, AlarmClockData> oldData = getOldDataMap();
        List<AlarmClockData> deleteData = new ArrayList<>();
        for (Map.Entry<Integer, AlarmClockData> entry : oldData.entrySet()) {
            if (alarmClockDataMap.get(entry.getKey()) == null) {
                AlarmClockData alarmClockData = entry.getValue();
                if (!alarmClockData.isIs_local()) {
                    deleteData.add(alarmClockData);
                }
            }
        }
        for (AlarmClockData alarmClockData : deleteData) {
            if (alarmClockData.isIs_local() || alarmClockData.deleted) {
                Log.e(TAG, "mergeData: skip id = " + alarmClockData.getId());
                continue;
            }
            deleteAlarmClock(alarmClockData);
        }

        List<AlarmClockData> newData = new ArrayList<>();
        if (newAlarmClockDataList == null) {
            return newData;
        }
        for (AlarmClockData alarm : newAlarmClockDataList) {
            AlarmClockData oldAlarm = oldData.get(alarm.getId());
            if (oldAlarm == null) {
                newData.add(alarm);
            } else {
                if (oldAlarm.equals(alarm)) {
                    newData.add(oldAlarm);
                } else {
                    newData.add(alarm);
                }
            }
        }
        return newData;
    }

    /**
     * 更新完成状态
     *
     * @param mId 闹钟id
     * @return
     */
    public boolean updateAlarmFinished(int mId) {
        AlarmClockData alarmClockData = getDatabaseSingleAlarm(mId);
        alarmClockData.setFinished(true);
        return updateAlarmFinished(alarmClockData);
    }

    /**
     * 更新完成状态
     *
     * @param alarmClockData
     * @return
     */
    public boolean updateAlarmFinished(AlarmClockData alarmClockData) {
        ContentValues values = getValuesFromAlarmClock(alarmClockData);
        long id = 0;
        mDatabase.beginTransaction();
        try {
            id = mDatabase.update(AlarmOpenHelper.TABLE_ALARM, values, AlarmOpenHelper.KEY_ID + "=?", new String[]{String.valueOf(alarmClockData.getId())});
            mDatabase.setTransactionSuccessful();
        } catch (Exception e) {
            Log.e(TAG, "updateAlarmFinished: " + e.getMessage());
        } finally {
            mDatabase.endTransaction();
        }
        return id > 0;
    }

    public List<AlarmClockData> getOldData() {
        List<AlarmClockData> alarmClockData = new ArrayList<>();
        List<AlarmClockData> dataBaseAlarms = getDatabaseAlarms();
        if (dataBaseAlarms != null && dataBaseAlarms.size() != 0) {
            alarmClockData.addAll(dataBaseAlarms);
        }
        Log.e(TAG, "getOldData: " + alarmClockData);
        return alarmClockData;
    }

    public HashMap<Integer, AlarmClockData> getOldDataMap() {
        List<AlarmClockData> alarmClockData = getOldData();
        HashMap<Integer, AlarmClockData> hashMap = new HashMap<>();
        if (alarmClockData.size() != 0) {
            for (AlarmClockData clockData : alarmClockData) {
                hashMap.put(clockData.getId(), clockData);
            }
        }
        return hashMap;
    }

    /**
     * 获取最近一次的闹钟
     *
     * @return
     */
    public AlarmClockData getRecentAlarmClock() {
        List<AlarmClockData> alarmClockData = getDatabaseAlarms();
        if (alarmClockData == null || alarmClockData.size() == 0) {
            return null;
        } else {
            Collections.sort(alarmClockData, new Comparator<AlarmClockData>() {
                @Override
                public int compare(AlarmClockData o1, AlarmClockData o2) {
                    if ((o1.getTimeStamp()) <= (o2.getTimeStamp())) {
                        return 0;
                    } else {
                        return -1;
                    }
                }
            });
            return alarmClockData.get(0);
        }
    }

    private HashSet<PendingIntent> getOldPendingIntentsSet() {
        Log.e(TAG, "getOldPendingIntentsSet: ");
        HashSet<PendingIntent> pendingIntents = new HashSet<>();
        HashMap<Integer, AlarmClockData> data = getOldDataMap();
        for (AlarmClockData alarmClockData : data.values()) {
            if (!alarmClockData.isIs_local()) {
                pendingIntents.add(getPendingIntent(alarmClockData));
            }
        }
        return pendingIntents;
    }

    /**
     * 获取已设置闹钟的PendingIntent
     *
     * @param alarmClock
     * @return
     */
    private PendingIntent getPendingIntent(AlarmClockData alarmClock) {
        Log.e(TAG, "getPendingIntent: ");
        Intent intent = new Intent(MainService.ALARMWAKEUP);
        intent.putExtra("title", alarmClock.getTitle());
        intent.putExtra("id", alarmClock.getId());
        PendingIntent startPendingIntent = PendingIntent.getBroadcast(mContext, alarmClock.getId(), intent, PendingIntent.FLAG_CANCEL_CURRENT);
        return startPendingIntent;
    }

    private long getTimestamp(String timeString) {
        if (TextUtils.isEmpty(timeString)) {
            return 0;
        }
        if (timeString.length() == 5) {
            String[] timeSplit = timeString.split(":");
            int hour = Integer.parseInt(timeSplit[0]);
            int minute = Integer.parseInt(timeSplit[1]);
            Calendar c = Calendar.getInstance();
            int year = c.get(Calendar.YEAR);
            int month = c.get(Calendar.MONTH);
            int day = c.get(Calendar.DAY_OF_MONTH);
            c.set(year, month, day, hour, minute, 0);
            long mTimeInfo = c.getTimeInMillis();
            Log.e(TAG, "getTimestamp: " + mTimeInfo);
//            long actualTime = mTimeInfo > System.currentTimeMillis() ? mTimeInfo : mTimeInfo + ONE_DAY_TIME;
            return mTimeInfo;
        } else {
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm");
            try {
                Date date = simpleDateFormat.parse(timeString);
                long timestamp = date.getTime();
                Log.e(TAG, "getTimestamp2: " + timestamp);
                return timestamp;
            } catch (ParseException e) {
                return System.currentTimeMillis();
            }
        }
    }

    private long getZeroTiemstamp() {
        //设置时区
        Calendar calendar = Calendar.getInstance(TimeZone.getTimeZone("GMT+8"));
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        long zeroTime = calendar.getTimeInMillis();
        Log.e(TAG, "getZeroTiemstamp: " + zeroTime);
        return zeroTime;
    }


    /**
     * 设置闹钟
     *
     * @param alarm
     */
    public void setAlarm(AlarmClockData alarm) {
        if (pendingIntents == null) {
            pendingIntents = getOldPendingIntentsSet();
        }
        int id = alarm.getId();
        int type = alarm.getType();
        String timeString = alarm.getTime();
        String title = alarm.getTitle();
        Log.e(TAG, "setAlarm: title = " + title);
        Log.e(TAG, "setAlarm: id = " + id);
        long timeStamp = getTimestamp(timeString);
        Log.e(TAG, "setAlarm: timeStamp = " + timeStamp);
        boolean finished = alarm.isFinished();
        String voiceUrl = alarm.getVoice();
        String voiceMd5 = alarm.getVoice_md5();
        if (!TextUtils.isEmpty(voiceUrl)) {
            ariaDownload(voiceUrl, voiceMd5);
        }
        String fileUrl = alarm.getFile();
        String fileMd5 = alarm.getFile_md5();
        if (!TextUtils.isEmpty(fileUrl)) {
            ariaDownload(fileUrl, fileMd5);
        }
        boolean local = alarm.is_local;
        switch (type) {
            case ONCE:
                if (!finished) {
                    if (timeStamp < System.currentTimeMillis()) {
                        Intent intent = new Intent(MainService.ALARMWAKEUP);
                        intent.putExtra("title", title);
                        intent.putExtra("id", id);
                        mContext.sendBroadcast(intent);
                    } else {
                        setOnceAlarm(MainService.ALARMWAKEUP, title, id, timeStamp, local);
                    }
                }
                break;
            case LOOP:
                setDayLoopAlarm(MainService.ALARMWAKEUP, title, id, timeString, local);
                break;
            case WORKING_DAY:
                setWorkDayAlarm(MainService.ALARMWAKEUP, title, id, timeString, local);
                break;
            case OFF_DAY:
                setOffDayAlarm(MainService.ALARMWAKEUP, title, id, timeString, local);
                break;
            default:
        }
    }

    /**
     * @param action
     * @param requestCode
     * @param timestamp   设置一次性闹钟
     */
    public void setOnceAlarm(String action, String extra, int requestCode, long timestamp, boolean local) {
        Intent intent = new Intent(action);
        intent.putExtra("title", extra);
        intent.putExtra("id", requestCode);
        PendingIntent startPendingIntent = PendingIntent.getBroadcast(mContext, requestCode, intent, PendingIntent.FLAG_CANCEL_CURRENT);
        if (!local) {
            pendingIntents.add(startPendingIntent);
        }
        mAlarmManager.setAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, timestamp, startPendingIntent);
        Log.e(TAG, "setOnceAlarm: " + "id: " + requestCode + " title: " + extra + " timeString: " + timestamp);
    }

    /**
     * @param action
     * @param requestCode
     * @param timeString  设置循环周期为一天的闹钟
     */
    public void setDayLoopAlarm(String action, String extra, int requestCode, String timeString, boolean local) {
        long timestamp = getTimestamp(timeString);
        if (System.currentTimeMillis() > timestamp) {
            timestamp += AlarmManager.INTERVAL_DAY;
        }
        Intent intent = new Intent(action);
        intent.putExtra("title", extra);
        intent.putExtra("id", requestCode);
        PendingIntent startPendingIntent = PendingIntent.getBroadcast(mContext, requestCode, intent, PendingIntent.FLAG_CANCEL_CURRENT);
        if (!local) {
            pendingIntents.add(startPendingIntent);
        }
        mAlarmManager.setExact(AlarmManager.RTC_WAKEUP, timestamp, startPendingIntent);
        Log.e(TAG, "setDayLoopAlarm: " + "title: " + extra + " timeString: " + timestamp);
//        setLoopAlarm(action, extra, requestCode, AlarmManager.INTERVAL_DAY, timestamp);
    }

    /**
     * @param action
     * @param requestCode
     * @param timestamp   设置循环周期为一小时的闹钟
     */
    public void setHourLoopAlarm(String action, String extra, int requestCode, long timestamp, boolean local) {
        setLoopAlarm(action, extra, requestCode, AlarmManager.INTERVAL_HOUR, timestamp, local);
    }

    /**
     * @param action
     * @param requestCode
     * @param intervalMillis
     * @param timestamp      循环闹钟
     */
    public void setLoopAlarm(String action, String extra, int requestCode, long intervalMillis, long timestamp, boolean local) {
        Intent intent = new Intent(action);
        intent.putExtra("title", extra);
        intent.putExtra("id", requestCode);
        PendingIntent startPendingIntent = PendingIntent.getBroadcast(mContext, requestCode, intent, PendingIntent.FLAG_CANCEL_CURRENT);
        if (!local) {
            pendingIntents.add(startPendingIntent);
        }
        mAlarmManager.setWindow(AlarmManager.RTC_WAKEUP, timestamp, intervalMillis, startPendingIntent);
        Log.e(TAG, "setLoopAlarm: " + "title: " + extra + " timeString: " + timestamp);
    }

    public void setWorkDayAlarm(String action, String extra, int requestCode, String timeString, boolean local) {
        long timestamp = getTimestamp(timeString);
        Calendar calendar = Calendar.getInstance();
        int day_of_week = calendar.get(Calendar.DAY_OF_WEEK) - 1;
        switch (day_of_week) {
            case 6:
            case 7:
                timestamp += (8 - day_of_week) * AlarmManager.INTERVAL_DAY;
                break;
            default:
                if (System.currentTimeMillis() > timestamp) {
                    timestamp += AlarmManager.INTERVAL_DAY;
                }
                break;
        }
        Intent intent = new Intent(action);
        intent.putExtra("title", extra);
        intent.putExtra("id", requestCode);
        PendingIntent startPendingIntent = PendingIntent.getBroadcast(mContext, requestCode, intent, PendingIntent.FLAG_CANCEL_CURRENT);
        if (!local) {
            pendingIntents.add(startPendingIntent);
        }
        mAlarmManager.setExact(AlarmManager.RTC_WAKEUP, timestamp, startPendingIntent);
        Log.e(TAG, "setWorkDayAlarm: " + "title: " + extra + " timeString: " + timestamp);
    }

    public void setOffDayAlarm(String action, String extra, int requestCode, String timeString, boolean local) {
        long timestamp = getTimestamp(timeString);
        Calendar calendar = Calendar.getInstance();
        int day_of_week = calendar.get(Calendar.DAY_OF_WEEK) - 1;
        switch (day_of_week) {
            case 6:
                if (System.currentTimeMillis() > timestamp) {
                    timestamp += AlarmManager.INTERVAL_DAY;
                }
                break;
            case 7:
                break;
            default:
                timestamp += (6 - day_of_week) * AlarmManager.INTERVAL_DAY;
                break;
        }
        Intent intent = new Intent(action);
        intent.putExtra("title", extra);
        intent.putExtra("id", requestCode);
        PendingIntent startPendingIntent = PendingIntent.getBroadcast(mContext, requestCode, intent, PendingIntent.FLAG_CANCEL_CURRENT);
        if (!local) {
            pendingIntents.add(startPendingIntent);
        }
        mAlarmManager.setExact(AlarmManager.RTC_WAKEUP, timestamp, startPendingIntent);
        Log.e(TAG, "setOffDayAlarm: " + "title: " + extra + " timeString: " + timestamp);
    }


    public void ariaDownload(String url, String md5) {
        String fileName = Utils.getFileNamefromURL(url);
        File file = new File(Utils.getDownLoadPath(mContext) + fileName);
        if (file.exists() && !file.isDirectory()) {
            String fileMD5 = FileUtils.getFileMD5ToString(file);
            Log.e("ariaDownload", "fileOnlineMD5=" + md5);
            Log.e("ariaDownload", "fileMD5=" + fileMD5);
            if (!md5.equalsIgnoreCase(fileMD5)) {
                Aria.download(this)
                        .load(url)     //读取下载地址
                        .setFilePath(Utils.getDownLoadPath(mContext) + fileName)
//                        .ignoreFilePathOccupy()
                        .setExtendField(md5)
                        .create();   //启动下载}
            } else {
                Log.e("ariaDownload", "fileName = " + fileName + " exists");
            }
        } else {
            Aria.download(this)
                    .load(url)     //读取下载地址
                    .setFilePath(Utils.getDownLoadPath(mContext) + fileName)
//                    .ignoreFilePathOccupy()
                    .setExtendField(md5)
                    .create();   //启动下载}
        }
    }

    public void ariaDownload(String url) {
        if (FileUtil.isLocalPath(url)) {
            return;
        }
        String fileName = Utils.getFileNamefromURL(url);
        File file = new File(Utils.getDownLoadPath(mContext) + fileName);
        if (file.exists() && !file.isDirectory()) {
            String fileMD5 = FileUtils.getFileMD5ToString(file);
            Log.e("ariaDownload", "fileMD5=" + fileMD5);
            Log.e("ariaDownload", "fileName = " + fileName + " exists");
        } else {
            Aria.download(this)
                    .load(url)     //读取下载地址
                    .setFilePath(Utils.getDownLoadPath(mContext) + fileName)
                    .create();   //启动下载}
        }
    }


}