package com.seewo.vcommons.system.onoffsetting;

import a.b.c.a.a;
import android.content.ContentResolver;
import android.content.ContentUris;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.net.Uri;
import android.util.Log;
import com.seewo.vcommons.cutomer.CustomerUtils;
import com.seewo.vcommons.system.onoffsetting.Task;
import com.seewo.vcommons.utils.RLog;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;

/* JADX INFO: loaded from: classes.dex */
public class TimeSwitchSQLBusiness {
    private static final String DEFAULT_SIGNS_FOR_WEEKDAYS = "0000000";
    private static final int PRIVATE_TIMER_INDEX = 0;
    public static final String REGULAR_ALL_SHUTDOWN = "0+";
    public static final String REGULAR_ALL_STARTUP = "1+";
    public static final String REGULAR_ALTERNATE = "(01)+|(10)+";
    public static final String REGULAR_CORRECTION = "(0+|1+)|(01)+|(10)+";
    private static String TAG = null;
    public static final int TIMER_COUNT;
    private static final int TIMER_INDEX = 1;
    private static final String TYPE_SHUTDOWN = "0";
    private static final String TYPE_STARTUP = "1";
    public static final Uri mUri;

    static {
        TIMER_COUNT = (CustomerUtils.isBenqCustomized() || CustomerUtils.isViewSonicBiaopaiCustomized()) ? 8 : 4;
        TAG = "raymond";
        mUri = Constants.TASK_URI;
    }

    public static void addTask(Context context, Task task) {
        if (getTaskByGroupID(context, task.groupId) != null) {
            Log.d(TAG, "addTask: update by group id");
            updateTaskByGroupID(context, task);
        } else {
            Log.d(TAG, "addTask: insert");
            context.getContentResolver().insert(mUri, createContentValues(task));
        }
    }

    public static void addTaskById(Context context, Task task) {
        Task taskByGroupID = getTaskByGroupID(context, task.groupId);
        if (taskByGroupID == null) {
            Log.d(TAG, "addTask: insert");
            context.getContentResolver().insert(mUri, createContentValues(task));
        } else {
            Log.d(TAG, "addTask: update by group id");
            task.id = taskByGroupID.id;
            updateTask(context, task);
        }
    }

    private String changTimeFromIntToStr(int i2, int i3) {
        return Integer.toString((i2 * 60) + i3);
    }

    private boolean checkOrder(String str) {
        Log.d(TAG, "Order sourceStr:" + str);
        return Pattern.compile(REGULAR_CORRECTION).matcher(str).matches();
    }

    public static boolean checkTheIntervalBetweenShutdown(Context context, Task task) {
        List<Task> tasksListExceptGID = getTasksListExceptGID(context.getContentResolver(), task.groupId);
        int i2 = (task.shutdownHour * 60) + task.shutdownMinute;
        String str = task.shutdownDays;
        for (int i3 = 0; i3 < tasksListExceptGID.size(); i3++) {
            Task task2 = tasksListExceptGID.get(i3);
            String str2 = task2.shutdownDays;
            int i4 = (task2.shutdownHour * 60) + task2.shutdownMinute;
            for (int i5 = 0; i5 < 7; i5++) {
                StringBuilder sb = new StringBuilder();
                int i6 = i2 - i4;
                sb.append(i6);
                sb.append(" min");
                RLog.d("ShutdownInterval", sb.toString());
                if (str2.charAt(i5) == '1' && str.charAt(i5) == '1' && Math.abs(i6) < 5) {
                    return false;
                }
                if (str2.charAt(i5) == '1' && str.charAt(i5) == '1' && Math.abs(i6) > 1435) {
                    return false;
                }
            }
        }
        return true;
    }

    public static boolean checkTheIntervalBetweenStartupAndShutdown(Context context, Task task) {
        List<Task> tasksListExceptGID = getTasksListExceptGID(context.getContentResolver(), task.groupId);
        int i2 = (task.startupHour * 60) + task.startupMinute;
        int i3 = (task.shutdownHour * 60) + task.shutdownMinute;
        String str = task.startupDays;
        String str2 = task.shutdownDays;
        int i4 = 0;
        while (true) {
            int i5 = 7;
            if (i4 >= 7) {
                int i6 = 0;
                while (i6 < tasksListExceptGID.size()) {
                    Task task2 = tasksListExceptGID.get(i6);
                    String str3 = task2.startupDays;
                    String str4 = task2.shutdownDays;
                    int i7 = (task2.startupHour * 60) + task2.startupMinute;
                    int i8 = (task2.shutdownHour * 60) + task2.shutdownMinute;
                    int i9 = 0;
                    while (i9 < i5) {
                        if (str.charAt(i9) == '1' && str4.charAt(i9) == '1' && i2 != -61 && i8 != -61 && Math.abs(i2 - i8) < 5) {
                            return false;
                        }
                        if (str2.charAt(i9) == '1' && str3.charAt(i9) == '1' && i3 != -61 && i7 != -61 && Math.abs(i3 - i7) < 5) {
                            return false;
                        }
                        i9++;
                        i5 = 7;
                    }
                    i6++;
                    i5 = 7;
                }
                return true;
            }
            if (str.charAt(i4) == '1' && str2.charAt(i4) == '1' && i2 != -61 && i3 != -61 && Math.abs(i2 - i3) < 5) {
                return false;
            }
            i4++;
        }
    }

    private static ContentValues createContentValues(Task task) {
        ContentValues contentValues = new ContentValues(11);
        contentValues.put(Task.TaskColumns.GROUP_ID, Integer.valueOf(task.groupId));
        contentValues.put(Task.TaskColumns.STARTUP_HOUR, Integer.valueOf(task.startupHour));
        contentValues.put(Task.TaskColumns.STARTUP_MINUTES, Integer.valueOf(task.startupMinute));
        contentValues.put(Task.TaskColumns.SHUTDOWN_HOUR, Integer.valueOf(task.shutdownHour));
        contentValues.put(Task.TaskColumns.SHUTDOWN_MINUTES, Integer.valueOf(task.shutdownMinute));
        contentValues.put(Task.TaskColumns.DAYS_OF_WEEK, task.daysOfWeek);
        contentValues.put(Task.TaskColumns.STARTUP_DAYS, task.startupDays);
        contentValues.put(Task.TaskColumns.SHUTDOWN_DAYS, task.shutdownDays);
        contentValues.put(Task.TaskColumns.MESSAGE, task.message);
        contentValues.put("command", task.command);
        contentValues.put(Task.TaskColumns.CUSTOM_CLOUMN_FORCE_CHANNEL, task.forceChannel);
        contentValues.put(Task.TaskColumns.ENABLED, Integer.valueOf(task.enabled ? 1 : 0));
        return contentValues;
    }

    public static void deleteAll(Context context) {
        context.getContentResolver().delete(mUri, "_id>-1", null);
    }

    public static void deleteTaskByGroupID(Context context, int i2) {
        if (i2 == -1) {
            return;
        }
        context.getContentResolver().delete(mUri, "group_id = " + i2, null);
    }

    public static void deleteTaskByID(Context context, int i2) {
        if (i2 == -1) {
            return;
        }
        context.getContentResolver().delete(ContentUris.withAppendedId(mUri, i2), "", null);
    }

    public static void enableTask(Context context, int i2, boolean z) {
        enableTaskInternal(context, i2, z);
    }

    private static void enableTaskInternal(Context context, int i2, boolean z) {
        enableTaskInternal(context, getTaskByID(context.getContentResolver(), i2), z);
    }

    private static void enableTaskInternal(Context context, Task task, boolean z) {
        if (task == null) {
            return;
        }
        ContentResolver contentResolver = context.getContentResolver();
        ContentValues contentValues = new ContentValues(2);
        contentValues.put(Task.TaskColumns.ENABLED, Integer.valueOf(z ? 1 : 0));
        contentResolver.update(ContentUris.withAppendedId(mUri, task.id), contentValues, null, null);
    }

    private void forDaysOfWeek(Task task, HashMap<String, String> map, String[] strArr, String[] strArr2, String[] strArr3, int i2) {
        for (int i3 = 0; i3 < strArr.length; i3++) {
            if (strArr[i3].charAt(i2) == task.daysOfWeek.charAt(i2)) {
                if (Integer.valueOf(strArr2[i3]).intValue() > 0) {
                    map.put(strArr2[i3], "1");
                }
                if (Integer.valueOf(strArr3[i3]).intValue() > 0) {
                    map.put(strArr3[i3], "0");
                }
            }
        }
    }

    public static int getAvailableGroupID(Context context) {
        int i2;
        String str = TAG;
        StringBuilder sbC = a.C("getAvailableGroupID: count ");
        sbC.append(TIMER_COUNT);
        Log.d(str, sbC.toString());
        int maxSupportedPowerControlTaskNumber = getMaxSupportedPowerControlTaskNumber();
        Cursor tasksCursor = getTasksCursor(context.getContentResolver());
        int i3 = -1;
        if (tasksCursor == null) {
            return -1;
        }
        if (tasksCursor.getCount() == 0) {
            return 1;
        }
        if (tasksCursor.getCount() >= maxSupportedPowerControlTaskNumber) {
            return -1;
        }
        int i4 = 1;
        while (true) {
            if (i4 >= maxSupportedPowerControlTaskNumber + 1) {
                break;
            }
            tasksCursor.moveToFirst();
            do {
                i2 = tasksCursor.getInt(1);
                if (i2 == i4) {
                    break;
                }
            } while (tasksCursor.moveToNext());
            if (tasksCursor.isAfterLast() && i2 != i4) {
                i3 = i4;
                break;
            }
            i4++;
        }
        tasksCursor.close();
        return i3;
    }

    public static List<Task> getEnableShutdownTasksList(Context context) {
        ArrayList arrayList = new ArrayList();
        Cursor cursorQuery = context.getContentResolver().query(mUri, Task.TaskColumns.TASK_QUERY_COLUMNS, "shutdown_hour!=? and enabled=?", new String[]{Integer.toString(-1), "1"}, Task.TaskColumns.DEFAULT_SORT_ORDER);
        if (cursorQuery != null) {
            cursorQuery.moveToFirst();
            while (!cursorQuery.isAfterLast()) {
                Task task = new Task();
                task.id = cursorQuery.getInt(0);
                task.groupId = cursorQuery.getInt(1);
                task.daysOfWeek = cursorQuery.getString(2);
                task.startupDays = cursorQuery.getString(3);
                task.shutdownDays = cursorQuery.getString(4);
                task.startupHour = cursorQuery.getInt(5);
                task.startupMinute = cursorQuery.getInt(6);
                task.shutdownHour = cursorQuery.getInt(7);
                task.shutdownMinute = cursorQuery.getInt(8);
                task.enabled = cursorQuery.getInt(11) == 1;
                task.message = cursorQuery.getString(9);
                task.command = cursorQuery.getString(10);
                task.forceChannel = cursorQuery.getString(12);
                arrayList.add(task);
                cursorQuery.moveToNext();
            }
            cursorQuery.close();
        }
        return arrayList;
    }

    public static List<Task> getEnableStartupTasksList(Context context) {
        ArrayList arrayList = new ArrayList();
        Cursor cursorQuery = context.getContentResolver().query(mUri, Task.TaskColumns.TASK_QUERY_COLUMNS, "startup_hour!=? and enabled=?", new String[]{Integer.toString(-1), "1"}, Task.TaskColumns.DEFAULT_SORT_ORDER);
        if (cursorQuery != null) {
            cursorQuery.moveToFirst();
            while (!cursorQuery.isAfterLast()) {
                Task task = new Task();
                task.id = cursorQuery.getInt(0);
                task.groupId = cursorQuery.getInt(1);
                task.daysOfWeek = cursorQuery.getString(2);
                task.startupDays = cursorQuery.getString(3);
                task.shutdownDays = cursorQuery.getString(4);
                task.startupHour = cursorQuery.getInt(5);
                task.startupMinute = cursorQuery.getInt(6);
                task.shutdownHour = cursorQuery.getInt(7);
                task.shutdownMinute = cursorQuery.getInt(8);
                task.enabled = cursorQuery.getInt(11) == 1;
                task.message = cursorQuery.getString(9);
                task.command = cursorQuery.getString(10);
                task.forceChannel = cursorQuery.getString(12);
                arrayList.add(task);
                cursorQuery.moveToNext();
            }
            cursorQuery.close();
        }
        return arrayList;
    }

    public static Cursor getEnableTasksCursor(ContentResolver contentResolver) {
        return contentResolver.query(mUri, Task.TaskColumns.TASK_QUERY_COLUMNS, "enabled=?", new String[]{Integer.toString(1)}, Task.TaskColumns.DEFAULT_SORT_ORDER);
    }

    public static int getMaxSupportedPowerControlTaskNumber() {
        return TIMER_COUNT - 1;
    }

    public static List<Task> getShutdownTasksList(Context context) {
        ArrayList arrayList = new ArrayList();
        Cursor cursorQuery = context.getContentResolver().query(mUri, Task.TaskColumns.TASK_QUERY_COLUMNS, "shutdown_hour!=? ", new String[]{Integer.toString(-1)}, Task.TaskColumns.DEFAULT_SORT_ORDER);
        if (cursorQuery != null) {
            cursorQuery.moveToFirst();
            while (!cursorQuery.isAfterLast()) {
                Task task = new Task();
                task.id = cursorQuery.getInt(0);
                task.groupId = cursorQuery.getInt(1);
                task.daysOfWeek = cursorQuery.getString(2);
                task.startupDays = cursorQuery.getString(3);
                task.shutdownDays = cursorQuery.getString(4);
                task.startupHour = cursorQuery.getInt(5);
                task.startupMinute = cursorQuery.getInt(6);
                task.shutdownHour = cursorQuery.getInt(7);
                task.shutdownMinute = cursorQuery.getInt(8);
                task.enabled = cursorQuery.getInt(11) == 1;
                task.message = cursorQuery.getString(9);
                task.command = cursorQuery.getString(10);
                task.forceChannel = cursorQuery.getString(12);
                arrayList.add(task);
                cursorQuery.moveToNext();
            }
            cursorQuery.close();
        }
        return arrayList;
    }

    public static List<Task> getStartupTasksList(Context context) {
        ArrayList arrayList = new ArrayList();
        Cursor cursorQuery = context.getContentResolver().query(mUri, Task.TaskColumns.TASK_QUERY_COLUMNS, "startup_hour!=?", new String[]{Integer.toString(-1)}, Task.TaskColumns.DEFAULT_SORT_ORDER);
        if (cursorQuery != null) {
            cursorQuery.moveToFirst();
            while (!cursorQuery.isAfterLast()) {
                Task task = new Task();
                task.id = cursorQuery.getInt(0);
                task.groupId = cursorQuery.getInt(1);
                task.daysOfWeek = cursorQuery.getString(2);
                task.startupDays = cursorQuery.getString(3);
                task.shutdownDays = cursorQuery.getString(4);
                task.startupHour = cursorQuery.getInt(5);
                task.startupMinute = cursorQuery.getInt(6);
                task.shutdownHour = cursorQuery.getInt(7);
                task.shutdownMinute = cursorQuery.getInt(8);
                task.enabled = cursorQuery.getInt(11) == 1;
                task.message = cursorQuery.getString(9);
                task.command = cursorQuery.getString(10);
                task.forceChannel = cursorQuery.getString(12);
                arrayList.add(task);
                cursorQuery.moveToNext();
            }
            cursorQuery.close();
        }
        return arrayList;
    }

    public static Task getTaskByGroupID(Context context, int i2) {
        if (i2 == -1) {
            return null;
        }
        Cursor cursorQuery = context.getContentResolver().query(mUri, Task.TaskColumns.TASK_QUERY_COLUMNS, "group_id=?", new String[]{Integer.toString(i2)}, Task.TaskColumns.DEFAULT_SORT_ORDER);
        if (cursorQuery != null) {
            task = cursorQuery.moveToFirst() ? new Task(cursorQuery) : null;
            cursorQuery.close();
        }
        return task;
    }

    public static Task getTaskByID(ContentResolver contentResolver, int i2) {
        Cursor cursorQuery = contentResolver.query(ContentUris.withAppendedId(mUri, i2), Task.TaskColumns.TASK_QUERY_COLUMNS, null, null, null);
        if (cursorQuery != null) {
            task = cursorQuery.moveToFirst() ? new Task(cursorQuery) : null;
            cursorQuery.close();
        }
        return task;
    }

    public static Cursor getTasksCursor(ContentResolver contentResolver) {
        String str = TAG;
        StringBuilder sbC = a.C("getTasksCursor: ");
        sbC.append(TIMER_COUNT);
        Log.d(str, sbC.toString());
        Cursor cursorQuery = contentResolver.query(mUri, Task.TaskColumns.TASK_QUERY_COLUMNS, null, null, Task.TaskColumns.DEFAULT_SORT_ORDER);
        if (cursorQuery != null) {
            return cursorQuery;
        }
        return null;
    }

    public static List<Task> getTasksList(ContentResolver contentResolver) {
        ArrayList arrayList = new ArrayList();
        Cursor cursorQuery = contentResolver.query(mUri, Task.TaskColumns.TASK_QUERY_COLUMNS, null, null, Task.TaskColumns.DEFAULT_SORT_ORDER);
        if (cursorQuery != null) {
            cursorQuery.moveToFirst();
            while (!cursorQuery.isAfterLast()) {
                Task task = new Task();
                task.id = cursorQuery.getInt(0);
                task.groupId = cursorQuery.getInt(1);
                task.daysOfWeek = cursorQuery.getString(2);
                task.startupDays = cursorQuery.getString(3);
                task.shutdownDays = cursorQuery.getString(4);
                task.startupHour = cursorQuery.getInt(5);
                task.startupMinute = cursorQuery.getInt(6);
                task.shutdownHour = cursorQuery.getInt(7);
                task.shutdownMinute = cursorQuery.getInt(8);
                task.enabled = cursorQuery.getInt(11) == 1;
                task.message = cursorQuery.getString(9);
                task.command = cursorQuery.getString(10);
                task.forceChannel = cursorQuery.getString(12);
                if (task.groupId != 0) {
                    arrayList.add(task);
                }
                cursorQuery.moveToNext();
            }
            cursorQuery.close();
        }
        return arrayList;
    }

    public static List<Task> getTasksListExceptGID(ContentResolver contentResolver, int i2) {
        ArrayList arrayList = new ArrayList();
        Cursor cursorQuery = contentResolver.query(mUri, Task.TaskColumns.TASK_QUERY_COLUMNS, "group_id!=?", new String[]{Integer.toString(i2)}, Task.TaskColumns.DEFAULT_SORT_ORDER);
        if (cursorQuery != null) {
            cursorQuery.moveToFirst();
            while (!cursorQuery.isAfterLast()) {
                Task task = new Task();
                task.id = cursorQuery.getInt(0);
                task.groupId = cursorQuery.getInt(1);
                task.daysOfWeek = cursorQuery.getString(2);
                task.startupDays = cursorQuery.getString(3);
                task.shutdownDays = cursorQuery.getString(4);
                task.startupHour = cursorQuery.getInt(5);
                task.startupMinute = cursorQuery.getInt(6);
                task.shutdownHour = cursorQuery.getInt(7);
                task.shutdownMinute = cursorQuery.getInt(8);
                task.enabled = cursorQuery.getInt(11) == 1;
                task.message = cursorQuery.getString(9);
                task.command = cursorQuery.getString(10);
                task.forceChannel = cursorQuery.getString(12);
                arrayList.add(task);
                cursorQuery.moveToNext();
            }
            cursorQuery.close();
        }
        return arrayList;
    }

    public static String getTimerTaskChannelNameByGID(Context context, int i2) {
        String string;
        Cursor cursorQuery = context.getContentResolver().query(mUri, Task.TaskColumns.TASK_QUERY_COLUMNS, "group_id=? and enabled=?", new String[]{Integer.toString(i2), "1"}, Task.TaskColumns.DEFAULT_SORT_ORDER);
        string = "";
        if (cursorQuery != null) {
            string = cursorQuery.moveToFirst() ? cursorQuery.getString(12) : "";
            cursorQuery.close();
        }
        return string;
    }

    private String orderTheMapSet(HashMap<String, String> map) {
        ArrayList arrayList = new ArrayList(map.entrySet());
        StringBuilder sb = new StringBuilder();
        Collections.sort(arrayList, new Comparator<Map.Entry<String, String>>() { // from class: com.seewo.vcommons.system.onoffsetting.TimeSwitchSQLBusiness.1
            @Override // java.util.Comparator
            public int compare(Map.Entry<String, String> entry, Map.Entry<String, String> entry2) {
                return Integer.valueOf(entry.getKey()).compareTo(Integer.valueOf(entry2.getKey()));
            }
        });
        arrayList.size();
        Iterator it = arrayList.iterator();
        while (it.hasNext()) {
            sb.append((String) ((Map.Entry) it.next()).getValue());
        }
        return sb.toString();
    }

    public static void updateTask(Context context, Task task) {
        context.getContentResolver().update(ContentUris.withAppendedId(mUri, task.id), createContentValues(task), null, null);
    }

    public static void updateTaskByGroupID(Context context, Task task) {
        ContentValues contentValuesCreateContentValues = createContentValues(task);
        ContentResolver contentResolver = context.getContentResolver();
        Uri uriWithAppendedId = ContentUris.withAppendedId(mUri, task.groupId);
        StringBuilder sbC = a.C("group_id = ");
        sbC.append(task.groupId);
        contentResolver.update(uriWithAppendedId, contentValuesCreateContentValues, sbC.toString(), null);
    }

    private int whenTaskMapNotEmpty(HashMap<String, String> map, String str, String str2, int[] iArr, int i2, int i3) {
        if (map.size() == 0) {
            return i2;
        }
        if (Integer.valueOf(str).intValue() > 0) {
            map.put(str, "1");
        }
        if (Integer.valueOf(str2).intValue() > 0) {
            map.put(str2, "0");
        }
        if (checkOrder(orderTheMapSet(map))) {
            return i2;
        }
        iArr[i2] = i3;
        String str3 = TAG;
        StringBuilder sbD = a.D("errorDays[", i2, "]: ");
        sbD.append(iArr[i2]);
        Log.d(str3, sbD.toString());
        return i2 + 1;
    }

    public int[] isOKBeforUpdateDB(Context context, Task task) {
        int i2;
        int[] iArr;
        Cursor enableTasksCursor = getEnableTasksCursor(context.getContentResolver());
        HashMap<String, String> map = new HashMap<>();
        String[] strArr = (CustomerUtils.isBenqCustomized() || CustomerUtils.isViewSonicBiaopaiCustomized()) ? new String[]{DEFAULT_SIGNS_FOR_WEEKDAYS, DEFAULT_SIGNS_FOR_WEEKDAYS, DEFAULT_SIGNS_FOR_WEEKDAYS, DEFAULT_SIGNS_FOR_WEEKDAYS, DEFAULT_SIGNS_FOR_WEEKDAYS, DEFAULT_SIGNS_FOR_WEEKDAYS, DEFAULT_SIGNS_FOR_WEEKDAYS} : new String[]{DEFAULT_SIGNS_FOR_WEEKDAYS, DEFAULT_SIGNS_FOR_WEEKDAYS, DEFAULT_SIGNS_FOR_WEEKDAYS};
        int i3 = TIMER_COUNT;
        String[] strArr2 = new String[i3];
        String[] strArr3 = new String[i3];
        String strChangTimeFromIntToStr = changTimeFromIntToStr(task.startupHour, task.startupMinute);
        String strChangTimeFromIntToStr2 = changTimeFromIntToStr(task.shutdownHour, task.shutdownMinute);
        int i4 = 7;
        int[] iArr2 = {-1, -1, -1, -1, -1, -1, -1};
        enableTasksCursor.moveToFirst();
        int i5 = 0;
        while (!enableTasksCursor.isAfterLast()) {
            String string = enableTasksCursor.getString(2);
            int i6 = enableTasksCursor.getInt(5);
            int i7 = enableTasksCursor.getInt(6);
            int i8 = enableTasksCursor.getInt(i4);
            int i9 = enableTasksCursor.getInt(8);
            strArr[i5] = string;
            strArr2[i5] = changTimeFromIntToStr(i6, i7);
            strArr3[i5] = changTimeFromIntToStr(i8, i9);
            i5++;
            enableTasksCursor.moveToNext();
            i4 = 7;
        }
        int i10 = 0;
        int iWhenTaskMapNotEmpty = 0;
        while (i10 < task.daysOfWeek.length()) {
            if (task.daysOfWeek.charAt(i10) == '1') {
                i2 = i10;
                iArr = iArr2;
                forDaysOfWeek(task, map, strArr, strArr2, strArr3, i2);
                iWhenTaskMapNotEmpty = whenTaskMapNotEmpty(map, strChangTimeFromIntToStr, strChangTimeFromIntToStr2, iArr, iWhenTaskMapNotEmpty, i2);
                map.clear();
            } else {
                i2 = i10;
                iArr = iArr2;
            }
            i10 = i2 + 1;
            iArr2 = iArr;
        }
        int[] iArr3 = iArr2;
        enableTasksCursor.close();
        return iArr3;
    }
}