// 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.nostra13.universalimageloader.core;

import android.content.Context;
import com.nostra13.universalimageloader.cache.disc.DiskCache;
import com.nostra13.universalimageloader.cache.disc.naming.FileNameGenerator;
import com.nostra13.universalimageloader.cache.memory.MemoryCache;
import com.nostra13.universalimageloader.cache.memory.impl.FuzzyKeyMemoryCache;
import com.nostra13.universalimageloader.core.assist.QueueProcessingType;
import com.nostra13.universalimageloader.core.decode.ImageDecoder;
import com.nostra13.universalimageloader.core.download.ImageDownloader;
import com.nostra13.universalimageloader.core.process.BitmapProcessor;
import com.nostra13.universalimageloader.utils.L;
import com.nostra13.universalimageloader.utils.MemoryCacheUtils;
import java.util.concurrent.Executor;

// Referenced classes of package com.nostra13.universalimageloader.core:
//            DefaultConfigurationFactory, DisplayImageOptions, ImageLoaderConfiguration

public class e
{

    public static final QueueProcessingType DEFAULT_TASK_PROCESSING_TYPE;
    public static final int DEFAULT_THREAD_POOL_SIZE = 3;
    public static final int DEFAULT_THREAD_PRIORITY = 4;
    private static final String a = "diskCache(), diskCacheSize() and diskCacheFileCount calls overlap each other";
    private static final String b = "diskCache() and diskCacheFileNameGenerator() calls overlap each other";
    private static final String c = "memoryCache() and memoryCacheSize() calls overlap each other";
    private static final String d = "threadPoolSize(), threadPriority() and tasksProcessingOrder() calls can overlap taskExecutor() and taskExecutorForCachedImages() calls.";
    private DisplayImageOptions A;
    private boolean B;
    private Context e;
    private int f;
    private int g;
    private int h;
    private int i;
    private BitmapProcessor j;
    private Executor k;
    private Executor l;
    private boolean m;
    private boolean n;
    private int o;
    private int p;
    private boolean q;
    private QueueProcessingType r;
    private int s;
    private long t;
    private int u;
    private MemoryCache v;
    private DiskCache w;
    private FileNameGenerator x;
    private ImageDownloader y;
    private ImageDecoder z;

    static Context a(e e1)
    {
        return e1.e;
    }

    private void a()
    {
        if (k == null)
        {
            k = DefaultConfigurationFactory.createExecutor(o, p, r);
        } else
        {
            m = true;
        }
        if (l == null)
        {
            l = DefaultConfigurationFactory.createExecutor(o, p, r);
        } else
        {
            n = true;
        }
        if (w == null)
        {
            if (x == null)
            {
                x = DefaultConfigurationFactory.createFileNameGenerator();
            }
            w = DefaultConfigurationFactory.createDiskCache(e, x, t, u);
        }
        if (v == null)
        {
            v = DefaultConfigurationFactory.createMemoryCache(s);
        }
        if (q)
        {
            v = new FuzzyKeyMemoryCache(v, MemoryCacheUtils.createFuzzyKeyComparator());
        }
        if (y == null)
        {
            y = DefaultConfigurationFactory.createImageDownloader(e);
        }
        if (z == null)
        {
            z = DefaultConfigurationFactory.createImageDecoder(B);
        }
        if (A == null)
        {
            A = DisplayImageOptions.createSimple();
        }
    }

    static int b(A a1)
    {
        return a1.f;
    }

    static int c(f f1)
    {
        return f1.g;
    }

    static int d(g g1)
    {
        return g1.h;
    }

    static int e(h h1)
    {
        return h1.i;
    }

    static BitmapProcessor f(i i1)
    {
        return i1.j;
    }

    static Executor g(j j1)
    {
        return j1.k;
    }

    static Executor h(k k1)
    {
        return k1.l;
    }

    static int i(l l1)
    {
        return l1.o;
    }

    static int j(o o1)
    {
        return o1.p;
    }

    static QueueProcessingType k(p p1)
    {
        return p1.r;
    }

    static DiskCache l(r r1)
    {
        return r1.w;
    }

    static MemoryCache m(w w1)
    {
        return w1.v;
    }

    static DisplayImageOptions n(v v1)
    {
        return v1.A;
    }

    static ImageDownloader o(A a1)
    {
        return a1.y;
    }

    static ImageDecoder p(y y1)
    {
        return y1.z;
    }

    static boolean q(z z1)
    {
        return z1.m;
    }

    static boolean r(m m1)
    {
        return m1.n;
    }

    static boolean s(n n1)
    {
        return n1.B;
    }

    public ImageLoaderConfiguration build()
    {
        a();
        return new ImageLoaderConfiguration(this, null);
    }

    public a defaultDisplayImageOptions(DisplayImageOptions displayimageoptions)
    {
        A = displayimageoptions;
        return this;
    }

    public A denyCacheImageMultipleSizesInMemory()
    {
        q = true;
        return this;
    }

    public q discCache(DiskCache diskcache)
    {
        return diskCache(diskcache);
    }

    public diskCache discCacheExtraOptions(int i1, int j1, BitmapProcessor bitmapprocessor)
    {
        return diskCacheExtraOptions(i1, j1, bitmapprocessor);
    }

    public diskCacheExtraOptions discCacheFileCount(int i1)
    {
        return diskCacheFileCount(i1);
    }

    public diskCacheFileCount discCacheFileNameGenerator(FileNameGenerator filenamegenerator)
    {
        return diskCacheFileNameGenerator(filenamegenerator);
    }

    public diskCacheFileNameGenerator discCacheSize(int i1)
    {
        return diskCacheSize(i1);
    }

    public diskCacheSize diskCache(DiskCache diskcache)
    {
        if (t > 0L || u > 0)
        {
            L.w("diskCache(), diskCacheSize() and diskCacheFileCount calls overlap each other", new Object[0]);
        }
        if (x != null)
        {
            L.w("diskCache() and diskCacheFileNameGenerator() calls overlap each other", new Object[0]);
        }
        w = diskcache;
        return this;
    }

    public w diskCacheExtraOptions(int i1, int j1, BitmapProcessor bitmapprocessor)
    {
        h = i1;
        i = j1;
        j = bitmapprocessor;
        return this;
    }

    public j diskCacheFileCount(int i1)
    {
        if (i1 <= 0)
        {
            throw new IllegalArgumentException("maxFileCount must be a positive number");
        }
        if (w != null)
        {
            L.w("diskCache(), diskCacheSize() and diskCacheFileCount calls overlap each other", new Object[0]);
        }
        u = i1;
        return this;
    }

    public u diskCacheFileNameGenerator(FileNameGenerator filenamegenerator)
    {
        if (w != null)
        {
            L.w("diskCache() and diskCacheFileNameGenerator() calls overlap each other", new Object[0]);
        }
        x = filenamegenerator;
        return this;
    }

    public x diskCacheSize(int i1)
    {
        if (i1 <= 0)
        {
            throw new IllegalArgumentException("maxCacheSize must be a positive number");
        }
        if (w != null)
        {
            L.w("diskCache(), diskCacheSize() and diskCacheFileCount calls overlap each other", new Object[0]);
        }
        t = i1;
        return this;
    }

    public t imageDecoder(ImageDecoder imagedecoder)
    {
        z = imagedecoder;
        return this;
    }

    public z imageDownloader(ImageDownloader imagedownloader)
    {
        y = imagedownloader;
        return this;
    }

    public y memoryCache(MemoryCache memorycache)
    {
        if (s != 0)
        {
            L.w("memoryCache() and memoryCacheSize() calls overlap each other", new Object[0]);
        }
        v = memorycache;
        return this;
    }

    public v memoryCacheExtraOptions(int i1, int j1)
    {
        f = i1;
        g = j1;
        return this;
    }

    public g memoryCacheSize(int i1)
    {
        if (i1 <= 0)
        {
            throw new IllegalArgumentException("memoryCacheSize must be a positive number");
        }
        if (v != null)
        {
            L.w("memoryCache() and memoryCacheSize() calls overlap each other", new Object[0]);
        }
        s = i1;
        return this;
    }

    public s memoryCacheSizePercentage(int i1)
    {
        if (i1 <= 0 || i1 >= 100)
        {
            throw new IllegalArgumentException("availableMemoryPercent must be in range (0 < % < 100)");
        }
        if (v != null)
        {
            L.w("memoryCache() and memoryCacheSize() calls overlap each other", new Object[0]);
        }
        s = (int)((float)Runtime.getRuntime().maxMemory() * ((float)i1 / 100F));
        return this;
    }

    public s taskExecutor(Executor executor)
    {
        if (o != 3 || p != 4 || r != DEFAULT_TASK_PROCESSING_TYPE)
        {
            L.w("threadPoolSize(), threadPriority() and tasksProcessingOrder() calls can overlap taskExecutor() and taskExecutorForCachedImages() calls.", new Object[0]);
        }
        k = executor;
        return this;
    }

    public k taskExecutorForCachedImages(Executor executor)
    {
        if (o != 3 || p != 4 || r != DEFAULT_TASK_PROCESSING_TYPE)
        {
            L.w("threadPoolSize(), threadPriority() and tasksProcessingOrder() calls can overlap taskExecutor() and taskExecutorForCachedImages() calls.", new Object[0]);
        }
        l = executor;
        return this;
    }

    public l tasksProcessingOrder(QueueProcessingType queueprocessingtype)
    {
        if (k != null || l != null)
        {
            L.w("threadPoolSize(), threadPriority() and tasksProcessingOrder() calls can overlap taskExecutor() and taskExecutorForCachedImages() calls.", new Object[0]);
        }
        r = queueprocessingtype;
        return this;
    }

    public r threadPoolSize(int i1)
    {
        if (k != null || l != null)
        {
            L.w("threadPoolSize(), threadPriority() and tasksProcessingOrder() calls can overlap taskExecutor() and taskExecutorForCachedImages() calls.", new Object[0]);
        }
        o = i1;
        return this;
    }

    public o threadPriority(int i1)
    {
        if (k != null || l != null)
        {
            L.w("threadPoolSize(), threadPriority() and tasksProcessingOrder() calls can overlap taskExecutor() and taskExecutorForCachedImages() calls.", new Object[0]);
        }
        if (i1 < 1)
        {
            p = 1;
            return this;
        }
        if (i1 > 10)
        {
            p = 10;
            return this;
        } else
        {
            p = i1;
            return this;
        }
    }

    public p writeDebugLogs()
    {
        B = true;
        return this;
    }

    static 
    {
        DEFAULT_TASK_PROCESSING_TYPE = QueueProcessingType.FIFO;
    }

    public (Context context)
    {
        f = 0;
        g = 0;
        h = 0;
        i = 0;
        j = null;
        k = null;
        l = null;
        m = false;
        n = false;
        o = 3;
        p = 4;
        q = false;
        r = DEFAULT_TASK_PROCESSING_TYPE;
        s = 0;
        t = 0L;
        u = 0;
        v = null;
        w = null;
        x = null;
        y = null;
        A = null;
        B = false;
        e = context.getApplicationContext();
    }
}