// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/kpdus/jad.html
// Decompiler options: braces fieldsfirst space lnc 

package com.olio.communication.notifications.mappers.rule;

import android.content.ContentResolver;
import android.content.Context;
import android.content.Loader;
import com.olio.communication.notifications.mappers.AssistantMapper;
import com.olio.data.object.assistant.rule.Rule;
import com.olio.data.object.assistant.rule.RuleLoader;
import com.olio.data.object.assistant.rule.SilenceNotificationsRule;
import com.olio.data.object.bluetooth_status.PairingProgress;
import com.olio.data.object.context.PersonalAssistantContext;
import com.olio.data.object.context.PersonalAssistantContextLoader;
import com.olio.util.ALog;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;

// Referenced classes of package com.olio.communication.notifications.mappers.rule:
//            RuleMapperFactory

public abstract class ActiveRuleMonitor
{

    private ContentResolver contentResolver;
    private Context context;
    private android.content.Loader.OnLoadCompleteListener contextChangeMonitor;
    PersonalAssistantContextLoader personalAssistantContextLoader;
    private android.content.Loader.OnLoadCompleteListener ruleChangeMonitor;
    RuleLoader ruleLoader;
    List rules;

    public ActiveRuleMonitor(ContentResolver contentresolver, Context context1)
    {
        rules = null;
        contextChangeMonitor = new android.content.Loader.OnLoadCompleteListener() {

            final ActiveRuleMonitor this$0;

            public volatile void onLoadComplete(Loader loader, Object obj)
            {
                onLoadComplete(loader, (List)obj);
            }

            public void onLoadComplete(Loader loader, List list)
            {
                ALog.d("ActiveRuleMonitor: contextChange load complete", new Object[0]);
                if (PairingProgress.pairingProgress(contentResolver).getPairingStatus() == 5)
                {
                    updateActiveRuleMappersWithContexts(list);
                }
            }

            
            {
                this$0 = ActiveRuleMonitor.this;
                super();
            }
        };
        ruleChangeMonitor = new android.content.Loader.OnLoadCompleteListener() {

            final ActiveRuleMonitor this$0;

            public volatile void onLoadComplete(Loader loader, Object obj)
            {
                onLoadComplete(loader, (List)obj);
            }

            public void onLoadComplete(Loader loader, List list)
            {
                ALog.d("ActiveRuleMonitor: rulesChange load complete", new Object[0]);
                if (PairingProgress.pairingProgress(contentResolver).getPairingStatus() == 7)
                {
                    ALog.d("ActiveRuleMonitor: rule load completed and paired to iOS", new Object[0]);
                    updateActiveRuleMappersWithRules(list);
                }
            }

            
            {
                this$0 = ActiveRuleMonitor.this;
                super();
            }
        };
        contentResolver = contentresolver;
        context = context1;
        personalAssistantContextLoader = new PersonalAssistantContextLoader(context1);
        ruleLoader = new RuleLoader(context1);
        rules = Rule.getAllRules(contentresolver);
    }

    private AssistantMapper getMapperForRule(Rule rule)
    {
        if (Objects.equals(rule.typeName(), SilenceNotificationsRule.TYPE_NAME))
        {
            return RuleMapperFactory.mapperForRule(rule, context);
        } else
        {
            return null;
        }
    }

    public abstract void activeMappersUpdate(ArrayList arraylist);

    public void register()
    {
        personalAssistantContextLoader.registerListener(1, contextChangeMonitor);
        personalAssistantContextLoader.startLoading();
        ruleLoader.registerListener(1, ruleChangeMonitor);
        ruleLoader.startLoading();
    }

    public void unregister()
    {
        personalAssistantContextLoader.stopLoading();
        personalAssistantContextLoader.unregisterListener(contextChangeMonitor);
        ruleLoader.stopLoading();
        ruleLoader.unregisterListener(ruleChangeMonitor);
    }

    protected void updateActiveRuleMappers(List list, List list1)
    {
        ALog.d("ActiveRuleMonitor updateActiveRuleMappers called. Number of rules is: %d", new Object[] {
            Integer.valueOf(list.size())
        });
        ArrayList arraylist = new ArrayList(list.size());
        Iterator iterator = list.iterator();
        do
        {
            if (!iterator.hasNext())
            {
                break;
            }
            Rule rule = (Rule)iterator.next();
            if (rule.isEnabled() && !rule.isActive())
            {
                for (list = Rule.activeRulesMatchingContexts(list, list1).iterator(); list.hasNext();)
                {
                    list1 = (Rule)list.next();
                    AssistantMapper assistantmapper = getMapperForRule(list1);
                    if (assistantmapper != null)
                    {
                        ALog.d("ActiveRuleMonitor Adding mapper for rule: %s", new Object[] {
                            list1.toString()
                        });
                        arraylist.add(assistantmapper);
                    } else
                    {
                        ALog.e("ActiveRuleMonitor Mapper is null. This should never happen", new Object[0]);
                    }
                }

                break;
            }
            if (!rule.isEnabled() || rule.isDeletedKey())
            {
                if (rule.isActive())
                {
                    rule.setActive(false);
                    rule.save(contentResolver);
                }
            } else
            if (rule.isActive())
            {
                AssistantMapper assistantmapper1 = getMapperForRule(rule);
                if (assistantmapper1 != null)
                {
                    ALog.d("ActiveRuleMonitor Adding mapper for rule: %s", new Object[] {
                        rule.toString()
                    });
                    arraylist.add(assistantmapper1);
                } else
                {
                    ALog.e("ActiveRuleMonitor Mapper is null. This should never happen", new Object[0]);
                }
            }
        } while (true);
        activeMappersUpdate(arraylist);
    }

    public void updateActiveRuleMappersWithContexts(List list)
    {
        updateActiveRuleMappers(Rule.getAllRules(contentResolver), list);
    }

    public void updateActiveRuleMappersWithRules(List list)
    {
        updateActiveRuleMappers(list, PersonalAssistantContext.allRecords(contentResolver));
    }

}