// 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.util;

import android.os.Environment;
import android.util.Log;
import com.olio.comunication.BuildConfig;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.Writer;
import java.net.UnknownHostException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class ALog
{
    public static final class Level extends Enum
    {

        private static final Level $VALUES[];
        public static final Level D;
        public static final Level E;
        public static final Level I;
        public static final Level MUTE;
        public static final Level V;
        public static final Level W;
        public final int value;

        public static Level valueOf(String s)
        {
            return (Level)Enum.valueOf(com/olio/util/ALog$Level, s);
        }

        public static Level[] values()
        {
            return (Level[])$VALUES.clone();
        }

        static 
        {
            V = new Level("V", 0, 1);
            D = new Level("D", 1, 2);
            I = new Level("I", 2, 3);
            W = new Level("W", 3, 4);
            E = new Level("E", 4, 5);
            MUTE = new Level("MUTE", 5, 0x7fffffff);
            $VALUES = (new Level[] {
                V, D, I, W, E, MUTE
            });
        }

        private Level(String s, int j, int k)
        {
            super(s, j);
            value = k;
        }
    }

    private static class LogContext
    {

        int lineNumber;
        String methodName;
        String simpleClassName;

        LogContext(StackTraceElement stacktraceelement)
        {
            simpleClassName = ALog.getSimpleClassName(stacktraceelement.getClassName());
            methodName = stacktraceelement.getMethodName();
            lineNumber = stacktraceelement.getLineNumber();
        }
    }


    private static final DateFormat FLOG_FORMAT;
    private static final File LOG_DIR;
    private static boolean fileLogging = false;
    private static Level level;
    private static final BlockingQueue logQueue = new LinkedBlockingQueue();
    private static Runnable queueRunner;
    private static String tag = "";

    public ALog()
    {
    }

    public static transient void d(String s, Object aobj[])
    {
        if (level.value <= Level.D.value)
        {
            s = getMessage(s, aobj);
            Log.d(tag, s);
            if (fileLogging)
            {
                flog(Level.D, s);
                return;
            }
        }
    }

    public static transient void e(String s, Throwable throwable, Object aobj[])
    {
        if (level.value <= Level.E.value)
        {
            s = getMessage(s, aobj);
            Log.e(tag, s, throwable);
            if (fileLogging)
            {
                flog(Level.E, s, throwable);
                return;
            }
        }
    }

    public static transient void e(String s, Object aobj[])
    {
        if (level.value <= Level.E.value)
        {
            s = getMessage(s, aobj);
            Log.e(tag, s);
            if (fileLogging)
            {
                flog(Level.E, s);
                return;
            }
        }
    }

    private static void flog(Level level1, String s)
    {
        flog(level1, s, null);
    }

    private static void flog(Level level1, String s, Throwable throwable)
    {
        String s1 = FLOG_FORMAT.format(new Date());
        if (throwable != null)
        {
            level1 = String.format("%s %s/%s: %s\n%s\n", new Object[] {
                s1, level1.toString(), tag, s, getStackTraceString(throwable)
            });
        } else
        {
            level1 = String.format("%s %s/%s: %s\n", new Object[] {
                s1, level1.toString(), tag, s
            });
        }
        logQueue.offer(level1);
    }

    private static LogContext getContext()
    {
        return new LogContext(Thread.currentThread().getStackTrace()[5]);
    }

    private static transient String getMessage(String s, Object aobj[])
    {
        s = String.format(s, aobj);
        aobj = getContext();
        return String.format("%s.%s@%d: %s", new Object[] {
            ((LogContext) (aobj)).simpleClassName, ((LogContext) (aobj)).methodName, Integer.valueOf(((LogContext) (aobj)).lineNumber), s
        });
    }

    private static String getSimpleClassName(String s)
    {
        int j = s.lastIndexOf(".");
        if (j == -1)
        {
            return s;
        } else
        {
            return s.substring(j + 1);
        }
    }

    public static String getStackTraceString(Throwable throwable)
    {
        if (throwable == null)
        {
            return "";
        }
        for (Throwable throwable1 = throwable; throwable1 != null; throwable1 = throwable1.getCause())
        {
            if (throwable1 instanceof UnknownHostException)
            {
                return "";
            }
        }

        StringWriter stringwriter = new StringWriter();
        throwable.printStackTrace(new PrintWriter(stringwriter));
        return stringwriter.toString();
    }

    public static transient void i(String s, Object aobj[])
    {
        if (level.value <= Level.I.value)
        {
            s = getMessage(s, aobj);
            Log.i(tag, s);
            if (fileLogging)
            {
                flog(Level.I, s);
                return;
            }
        }
    }

    public static void setFileLogging(boolean flag)
    {
        fileLogging = flag;
    }

    public static void setLevel(Level level1)
    {
        level = level1;
    }

    public static void setTag(String s)
    {
        tag = s;
    }

    public static void trace()
    {
        try
        {
            throw new Throwable("dumping stack trace ...");
        }
        catch (Throwable throwable)
        {
            e("trace:", throwable, new Object[0]);
        }
    }

    public static transient void v(String s, Object aobj[])
    {
        if (level.value <= Level.V.value)
        {
            s = getMessage(s, aobj);
            Log.v(tag, s);
            if (fileLogging)
            {
                flog(Level.V, s);
                return;
            }
        }
    }

    public static transient void vTag(String s, String s1, Object aobj[])
    {
        if (level.value <= Level.V.value)
        {
            s1 = getMessage(s1, aobj);
            Log.v(s, s1);
            if (fileLogging)
            {
                flog(Level.V, s1);
                return;
            }
        }
    }

    public static transient void w(String s, Throwable throwable, Object aobj[])
    {
        if (level.value <= Level.W.value)
        {
            s = getMessage(s, aobj);
            Log.w(s, throwable);
            if (fileLogging)
            {
                flog(Level.W, s, throwable);
                return;
            }
        }
    }

    public static transient void w(String s, Object aobj[])
    {
        if (level.value <= Level.W.value)
        {
            s = getMessage(s, aobj);
            Log.w(tag, s);
            if (fileLogging)
            {
                flog(Level.W, s);
                return;
            }
        }
    }

    static 
    {
        FLOG_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS", Locale.US);
        LOG_DIR = new File((new StringBuilder()).append(Environment.getExternalStorageDirectory()).append(File.separator).append("alog").toString());
        level = BuildConfig.LOG_LEVEL;
        queueRunner = new Runnable() {

            public void run()
            {
_L4:
                String s = (String)ALog.logQueue.take();
                if (s == null) goto _L2; else goto _L1
_L1:
                if (!Environment.getExternalStorageState().equals("mounted") || !ALog.LOG_DIR.exists() && !ALog.LOG_DIR.mkdirs()) goto _L4; else goto _L3
_L3:
                Object obj = new File(ALog.LOG_DIR, (new StringBuilder()).append(ALog.tag).append(".log").toString());
                Object obj1;
                Object obj2;
                obj1 = null;
                obj2 = null;
                obj = new FileWriter(((File) (obj)), true);
                ((Writer) (obj)).write(s);
                ((Writer) (obj)).close();
                if (obj == null) goto _L4; else goto _L5
_L5:
                ((Writer) (obj)).close();
                  goto _L4
                obj;
                  goto _L4
                obj;
                obj = obj2;
_L9:
                if (obj == null) goto _L4; else goto _L6
_L6:
                ((Writer) (obj)).close();
                  goto _L4
                obj;
                  goto _L4
                obj;
_L8:
                if (obj1 == null)
                {
                    break MISSING_BLOCK_LABEL_145;
                }
                try
                {
                    ((Writer) (obj1)).close();
                }
                // Misplaced declaration of an exception variable
                catch (Object obj1) { }
                throw obj;
                obj;
_L2:
                return;
                Exception exception;
                exception;
                obj1 = obj;
                obj = exception;
                if (true) goto _L8; else goto _L7
_L7:
                IOException ioexception;
                ioexception;
                  goto _L9
            }

        };
        (new Thread(queueRunner)).start();
    }




}