package com.agromercado;

import android.app.Activity;
import android.app.ActivityManager;
import android.app.Application;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.database.sqlite.SQLiteDatabase;
import android.graphics.Bitmap;
import android.graphics.Typeface;
import android.graphics.drawable.Drawable;
import android.location.Location;
import android.location.LocationManager;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.Environment;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentManager;
import android.support.v4.widget.DrawerLayout;
import android.support.v7.widget.Toolbar;
import android.text.TextUtils;
import android.util.DisplayMetrics;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.inputmethod.InputMethodManager;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.ProgressBar;
import android.widget.TextView;
import android.widget.Toast;

import com.agromercado.broadcast.MsnService;
import com.agromercado.db.DBHelper;
import com.agromercado.dialogs.LoadDialog;
import com.agromercado.dialogs.ReatingDialog;
import com.agromercado.dialogs.RegisterDialog;
import com.agromercado.dialogs.TokenDialog;
import com.agromercado.fragments.AvisoItemFragment;
import com.agromercado.fragments.AvisoOporFragment;
import com.agromercado.fragments.MiProductDetailFragment;
import com.agromercado.fragments.subastas.MainSubastasFragment;
import com.agromercado.objs.AvisoObj;
import com.agromercado.objs.CatElemObj;
import com.agromercado.objs.CultivoObj;
import com.agromercado.objs.EdoObj;
import com.agromercado.objs.JuridicPersonObj;
import com.agromercado.objs.MunObj;
import com.agromercado.objs.PerfilObj;
import com.agromercado.objs.ProdCatObj;
import com.agromercado.objs.SectObj;
import com.agromercado.objs.SectorObj;
import com.agromercado.objs.SexObj;
import com.agromercado.objs.TempObj;
import com.agromercado.objs.TypePersonObj;
import com.agromercado.objs.UnidadObj;
import com.agromercado.objs.UserObj;
import com.agromercado.utils.GpsConfiguration;

import com.nostra13.universalimageloader.cache.disc.naming.Md5FileNameGenerator;
import com.nostra13.universalimageloader.core.DisplayImageOptions;
import com.nostra13.universalimageloader.core.ImageLoader;
import com.nostra13.universalimageloader.core.ImageLoaderConfiguration;
import com.nostra13.universalimageloader.core.assist.FailReason;
import com.nostra13.universalimageloader.core.assist.QueueProcessingType;
import com.nostra13.universalimageloader.core.display.FadeInBitmapDisplayer;
import com.nostra13.universalimageloader.core.listener.SimpleImageLoadingListener;
import com.nostra13.universalimageloader.utils.DiskCacheUtils;
import com.nostra13.universalimageloader.utils.MemoryCacheUtils;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class SingleTon extends Application implements GpsConfiguration.OnGpsLocationListener {

    private static final Object TAG = SingleTon.class.getName();
    private static SingleTon m_Instance;

    private static Context context;
    private static DBHelper dbh;
    private static SQLiteDatabase db;
    //----------------------
    private static final int CORE_POOL_SIZE = 5;
    private static final int MAXIMUM_POOL_SIZE = 128;
    private static final int KEEP_ALIVE = 10;

    private static final BlockingQueue<Runnable> sWorkQueue =
            new LinkedBlockingQueue<Runnable>(KEEP_ALIVE);

    private static final ThreadFactory sThreadFactory = new ThreadFactory() {
        private final AtomicInteger mCount = new AtomicInteger(1);

        public Thread newThread(Runnable r) {
            return new Thread(r, "TrackingUserTask #" + mCount.getAndIncrement());
        }
    };

    private static final ThreadPoolExecutor sExecutor = new ThreadPoolExecutor(CORE_POOL_SIZE,
            MAXIMUM_POOL_SIZE, KEEP_ALIVE, TimeUnit.SECONDS, sWorkQueue, sThreadFactory);
    //----------------------
    private static SharedPreferences settings;
    private static SharedPreferences.Editor editor;
    private static String baseUrl;
    private static UserObj userObj;
    private static GpsConfiguration gps;
    private static double latitude, longitude;
    private static ArrayList<TypePersonObj> typePersonObjs = new ArrayList<>();
    private static ArrayList<JuridicPersonObj> juridicPersonObjs = new ArrayList<>();
    private static ArrayList<PerfilObj> perfilObjs = new ArrayList<>();
    private static ArrayList<SectorObj> sectorObjs = new ArrayList<>();
    private static ArrayList<SexObj> sexObjs = new ArrayList<>();
    private static ArrayList<EdoObj> edos = new ArrayList<>();
    private static Fragment fragment;
    private static TokenDialog tokenDialog;
    private static LoadDialog load;
    private static Toolbar toolbar;
    private static Menu menu;
    private static MiProductDetailFragment detailFragment;
    private static TextView actionText, username, email;
    private static ImageView actionButon;
    private static ArrayList<TempObj> months = new ArrayList<>();
    private static ArrayList<UnidadObj> unidades = new ArrayList<>();
    private static ArrayList<SectObj> sectores = new ArrayList<>();
    private static MenuItem login, market, nav_my_count, nav_my_products;
    private static boolean changeFlag;
    private static ArrayList<AvisoObj> ventas = new ArrayList<>(), compras = new ArrayList<>();
    private static String filterSectorid, filterMes, filterEstadoid;
    private static int filterCapacidadprod;

    private static ImageLoaderConfiguration config;
    private static DisplayImageOptions defaultOptions;

    private static AvisoOporFragment avisoOporFragment;
    //private static AvisoItemFragment avisoItemFragment;
    private static ArrayList<AvisoItemFragment> frags = new ArrayList<>();
    private static ArrayList<String> cuurentMonth = new ArrayList<>(), cuurentMonthId = new ArrayList<>();
    private static DrawerLayout drawerLayout;
    //public static final String DB_VERSION_TAG = "db_version";
    private static ReatingDialog reatingDialog;
    private static int refresh;
    private static ArrayList<CatElemObj> cats = new ArrayList<>();
    private static int getCurrentDrawable;

    private static ArrayList<CatElemObj> aduanas = new ArrayList<>();
    private static ArrayList<CatElemObj> asociaciones = new ArrayList<>();
    private static ArrayList<CatElemObj> agentes = new ArrayList<>();
    private static ArrayList<CatElemObj> productores = new ArrayList<>();
    private static ArrayList<CatElemObj> compradores = new ArrayList<>();
    private static ArrayList<CatElemObj> certificador = new ArrayList<>();

    private static ProgressBar actionProgress;
    private static TextView califText;

    private static MainSubastasFragment mainSubastasFragment;

    private static HashMap<Integer, String> db_actions = new HashMap<>();

    public SingleTon() {
        super();
        m_Instance = this;
    }

    public static SingleTon getInstance() {
        if(m_Instance == null) {
            synchronized(SingleTon.class) {
                if(m_Instance == null) new SingleTon();
            }
        }
        return m_Instance;
    }

    public void onCreate() {
        super.onCreate();
        context = this;
        baseUrl = getResources().getString(R.string.url_qa);
        genCacheDataCarpet();
        initPreferences();
        initGPSConfig(this);
        initImageLoader(this);
        frags.add(null);
        frags.add(null);
        Log.d("Error de sistema", "No funciona el wifi por los cambios de Lucero, vil programadorcillo");
    }

    public static void initDataBase(Context context){
        genCacheDataCarpet();
        Log.d("initDataBase", "initDataBase");
        dbh = new DBHelper(context, "mercados", null, 1);

        try {
            dbh.createDataBase();
        } catch (IOException e) {
            e.printStackTrace();
        }

        db = dbh.getWritableDatabase();
        try {
            dbh.createDataBase();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static DBHelper getDataBaseHelper(){
        return dbh;
    }

    public static SQLiteDatabase getSQLiteDatabase(){
        return db;
    }

    public static boolean isConnected(Context context){
        ConnectivityManager cm = (ConnectivityManager)context.getSystemService(Context.CONNECTIVITY_SERVICE);

        NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
        boolean isConnected = activeNetwork != null && activeNetwork.isConnectedOrConnecting();

        return isConnected;
    }

    private static File cache;
    private static void genCacheDataCarpet(){
        if(cache == null)
            cache = new File(Environment.getExternalStorageDirectory(), "MercadoSagarpa");
        if (!cache.exists()) {
            cache.mkdirs();
        }
    }

    public static File getCacheCarpet(){
        return cache;
    }

    private void initPreferences(){
        if(settings == null)
            settings = getSharedPreferences("prefs", Context.MODE_PRIVATE);
        if(editor == null)
            editor = settings.edit();
    }

    public static SharedPreferences getSettings(){
        return settings;
    }

    public static SharedPreferences.Editor getEditor(){
        return editor;
    }

    public static int dpTpPx(Context context, int dp){
        DisplayMetrics displayMetrics = context.getResources().getDisplayMetrics();
        int px = Math.round(dp * (displayMetrics.xdpi / DisplayMetrics.DENSITY_DEFAULT));
        return px;
    }

    public static int pxToDp(Context context, int px){
        DisplayMetrics displayMetrics = context.getResources().getDisplayMetrics();
        int dp = Math.round(px / (displayMetrics.xdpi / DisplayMetrics.DENSITY_DEFAULT));
        return dp;
    }

    public static ThreadPoolExecutor getsExecutor(){
        return sExecutor;
    }

    public static String getBaseUrl(){
        return baseUrl;
    }

    public static void setUserObj(UserObj arg){
        userObj = arg;
    }

    public static UserObj getUserObj(){
        return userObj;
    }

    public static void parseJsonLogin(){
        try {
            JSONObject jsonObject = new JSONObject(settings.getString("login_json",""));
            JSONObject userData = jsonObject.getJSONObject("usuariodatos");
            userObj = new UserObj();
            userObj.rfc = userData.getString("rfc");
            userObj.password = userData.getString("password");
            userObj.nombre = userData.getString("nombre");
            userObj.apellidop = userData.getString("apellidop");
            userObj.apellidom = userData.getString("apellidom");
            userObj.email = userData.getString("email");
            userObj.curp = userData.getString("curp");
            userObj.telefonofijo = userData.getString("telefonofijo");
            userObj.cp = userData.getString("cp");
            userObj.mobil = userData.getString("telefono");
            userObj.tipopersona = userData.getString("tipopersona");
        } catch (JSONException e) {
            e.printStackTrace();
        }
    }

    public static void parseRegJson(String json){
        typePersonObjs.clear();
        TypePersonObj typePersonObj0 = new TypePersonObj();
        typePersonObj0.nombre = "Seleccionar tipo de persona";
        typePersonObj0.id = "0";
        typePersonObjs.add(typePersonObj0);

        juridicPersonObjs.clear();
        JuridicPersonObj juridicPersonObj0 = new JuridicPersonObj();
        juridicPersonObj0.nombre = "Seleccionar tipo de persona juridica";
        juridicPersonObj0.id = "0";
        juridicPersonObjs.add(juridicPersonObj0);

        perfilObjs.clear();
        PerfilObj perfilObj0 = new PerfilObj();
        perfilObj0.nombre = "Seleccionar tipo de perfil";
        perfilObj0.id = "0";
        perfilObjs.add(perfilObj0);

        sectorObjs.clear();
        SectorObj sectorObj0 = new SectorObj();
        sectorObj0.id = "0";
        sectorObj0.nombre = "Seleccionar un sector";
        sectorObjs.add(sectorObj0);

        sexObjs.clear();
        SexObj sexObj = new SexObj();
        sexObj.id = "0";
        sexObj.name = "Selecciona tu sexo";
        sexObjs.add(sexObj);

        try {
            JSONObject jsonObject = new JSONObject(json);
            JSONArray jsonArray = jsonObject.getJSONArray("tipopersona");
            for(int i = 0; i < jsonArray.length(); i++){
                JSONObject per = jsonArray.getJSONObject(i);
                TypePersonObj typePersonObj = new TypePersonObj();
                typePersonObj.id = per.getString("id");
                typePersonObj.nombre = per.getString("nombre");
                typePersonObjs.add(typePersonObj);
            }

            jsonArray = jsonObject.getJSONArray("tipopersonajuridica");
            for(int i = 0; i < jsonArray.length(); i++){
                JSONObject per = jsonArray.getJSONObject(i);
                JuridicPersonObj juridicPersonObj = new JuridicPersonObj();
                juridicPersonObj.id = per.getString("id");
                juridicPersonObj.nombre = per.getString("nombre");
                juridicPersonObjs.add(juridicPersonObj);
            }

            jsonArray = jsonObject.getJSONArray("tipoperfil");
            for(int i = 0; i < jsonArray.length(); i++){
                JSONObject per = jsonArray.getJSONObject(i);
                PerfilObj perfilObj = new PerfilObj();
                perfilObj.id = per.getString("id");
                perfilObj.nombre = per.getString("nombre");
                perfilObjs.add(perfilObj);
            }

            jsonArray = jsonObject.getJSONArray("sector");
            for(int i = 0; i < jsonArray.length(); i++){
                JSONObject per = jsonArray.getJSONObject(i);
                SectorObj sectorObj = new SectorObj();
                sectorObj.id = per.getString("id");
                sectorObj.nombre = per.getString("nombre");
                JSONArray cul = per.getJSONArray("cultivosinteres");
                if(cul.length() > 0){
                    ArrayList<CultivoObj> cultivoObjs = new ArrayList<>();
                    for(int a = 0; a < cul.length(); a++){
                        JSONObject cultivo = cul.getJSONObject(a);
                        CultivoObj cultivoObj = new CultivoObj();
                        cultivoObj.id = cultivo.getString("id");
                        cultivoObj.nombre = cultivo.getString("nombre");
                        cultivoObjs.add(cultivoObj);
                    }
                    sectorObj.cultivoObjs = cultivoObjs;
                }
                sectorObjs.add(sectorObj);
            }
            jsonArray = jsonObject.getJSONArray("sexo");
            for(int i = 0; i < jsonArray.length(); i++){
                JSONObject sex = jsonArray.getJSONObject(i);
                SexObj sexObj1 = new SexObj();
                sexObj1.id = sex.getString("id");
                sexObj1.name = sex.getString("nombre");
                sexObjs.add(sexObj1);
            }
        } catch (JSONException e) {
            e.printStackTrace();
        }
    }

    public static ArrayList<TypePersonObj> getTypePersonObjs(){
        return typePersonObjs;
    }

    public static ArrayList<JuridicPersonObj> getJuridicPersonObjs(){
        return juridicPersonObjs;
    }

    public static ArrayList<PerfilObj> getPerfilObjs(){
        return perfilObjs;
    }

    public static ArrayList<SectorObj> getSectorObjs(){
        return sectorObjs;
    }

    public static ArrayList<SexObj> getSexObjs(){
        return sexObjs;
    }

    public static GpsConfiguration getGpsConfig(){
        return gps;
    }

    public static double getLatitud(){
        return latitude;
    }

    public static double getLongitude(){
        return longitude;
    }

    public static Drawable LoadImageFromURL(String url) {
        try {
            InputStream is = (InputStream) new URL(url).getContent();
            Drawable d = Drawable.createFromStream(is, "src name");
            return d;
        } catch (Exception e) {
            return null;
        }
    }

    private static void initGPSConfig(Context context){
        gps = new GpsConfiguration(context, false);
    }

    @Override
    public void onGpsLocationInteraction(Location location) {
        latitude = location.getLatitude();
        longitude = location.getLongitude();
    }

    public static void setCurrentFragment(Fragment arg){
        fragment = arg;
    }

    public static Fragment getCurrentFragment(){
        return fragment;
    }

    public static void initEdos(String json){
        if(edos.size() == 0){
            EdoObj edoObj0 = new EdoObj();
            edoObj0.id = "";
            edoObj0.nombre = context.getResources().getString(R.string.all_edos);
            edos.add(0, edoObj0);
            try {
                JSONObject jsonObject = new JSONObject(json);
                JSONArray estados = jsonObject.getJSONArray("estadomunicipio");
                for(int i = 0; i < estados.length(); i++){
                    JSONObject edo = estados.getJSONObject(i);
                    EdoObj edoObj = new EdoObj();
                    edoObj.id = edo.getString("estadoid");
                    edoObj.nombre = edo.getString("nombre");

                    JSONArray jsonArray = edo.getJSONArray("municipios");
                    ArrayList<MunObj> muns = new ArrayList<>();
                    for(int a = 0; a < jsonArray.length(); a++){
                        JSONObject mun = jsonArray.getJSONObject(a);
                        MunObj munObj = new MunObj();
                        munObj.municipioid = mun.getString("municipioid");
                        munObj.nombre = mun.getString("nombre");
                        muns.add(munObj);
                    }

                    Collections.sort(muns, new Comparator<MunObj>() {
                        public int compare(MunObj result1, MunObj result2) {
                            return result1.nombre.compareTo(result2.nombre);
                        }
                    });

                    edoObj.munObjs = muns;
                    edos.add(edoObj);
                }
            } catch (JSONException e) {
                e.printStackTrace();
            }
        }
    }

    public static ArrayList<EdoObj> getEdos(){
        return edos;
    }

    public static void runStopService(String sName){
        if(!isMyServiceRunning(sName)) {
            Intent intent = new Intent(context, MsnService.class);
            context.startService(intent);
        } else {
            Intent intent = new Intent(context, MsnService.class);
            context.stopService(intent);
        }
    }

    private static boolean isMyServiceRunning(String serv) {
        final ActivityManager manager = (ActivityManager)context.getSystemService(ACTIVITY_SERVICE);
        for (ActivityManager.RunningServiceInfo service : manager.getRunningServices(Integer.MAX_VALUE)) {
            if (serv.equals(service.service.getClassName())) {
                return true;
            }
        }
        return false;
    }

    public static boolean checkGPS(){
        LocationManager locationManager = (LocationManager)context.getSystemService(LOCATION_SERVICE);
        if (locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER)){
            return true;
        }else{
            return false;
        }
    }

    public static void setTokenDialog(TokenDialog arg){
        tokenDialog = arg;
    }

    public static TokenDialog getTokenDialog(){
        return tokenDialog;
    }

    public static LoadDialog showLoadDialog(FragmentManager manager){
        if(load == null){
            synchronized (SingleTon.class){
                if(load == null){
                    load = LoadDialog.newInstance();
                    load.setCancelable(false);
                    load.show(manager, "load dialog");
                }
            }
        }
        return load;
    }

    public static void dissmissLoad(){
        if(load != null) {
            load.dismiss();
            load = null;
        }
    }

    public static void setToolbar(Toolbar arg){
        toolbar = arg;
    }

    public static Toolbar getToolbar(){
        return toolbar;
    }

    public static void setMenu(Menu arg){
        menu = arg;
    }

    public static Menu getMenu(){
        return menu;
    }

    public static void setMiProductDetailFragment(MiProductDetailFragment arg){
        detailFragment = arg;
    }

    public static MiProductDetailFragment getMiProductDetailFragment(){
        return detailFragment;
    }

    public static void setActionText(TextView arg){
        actionText = arg;
    }

    public static TextView getActionText(){
        return actionText;
    }

    public static void changeActionText(String arg){
        actionText.setText(arg);
    }

    public static void setActionButon(ImageView arg){
        actionButon = arg;
    }

    public static ImageView getActionButon(){
        return actionButon;
    }

    public static void changeBgActionButton(int arg){
        getCurrentDrawable = arg;
        //actionButon.setBackgroundResource(arg);
        actionButon.setImageResource(arg);
    }


    public static void initMonths(String json){
        try {
            months.clear();
            JSONArray jsonArray = new JSONArray(json);
            for(int i = 0; i < jsonArray.length(); i++){
                JSONObject jsonObject = jsonArray.getJSONObject(i);
                TempObj tempObj = new TempObj();
                tempObj.id = jsonObject.getString("id");
                tempObj.ENG = jsonObject.getString("ENG");
                tempObj.ESP = jsonObject.getString("ESP");
                tempObj.FRE = jsonObject.getString("FRE");
                months.add(tempObj);
            }
        } catch (JSONException e) {
            e.printStackTrace();
        }
    }

    public static ArrayList<TempObj> getMonths(){
        return months;
    }

    public static void initProds(String json){
        if(sectores.isEmpty()){
            try {
                SectObj sectObj0 = new SectObj();
                sectObj0.id = "";
                sectObj0.ENG = "Sector";
                sectObj0.ESP = "Sector";
                sectObj0.FRE = "Sector";
                sectores.add(0, sectObj0);
                JSONArray jsonArray = new JSONArray(json);
                for(int i = 0; i < jsonArray.length(); i++){
                    JSONObject jsonObject1 = jsonArray.getJSONObject(i);
                    SectObj sectObj = new SectObj();
                    sectObj.id = jsonObject1.getString("sectorid");
                    sectObj.ESP = jsonObject1.getString("ESP");
                    sectObj.ENG = jsonObject1.getString("ENG");
                    sectObj.FRE = jsonObject1.getString("FRE");
                    ArrayList<ProdCatObj> prods = new ArrayList<>();
                    JSONArray jsonArray1 = jsonObject1.getJSONArray("producto");
                    for(int a = 0; a < jsonArray1.length(); a++){
                        JSONObject jsonObject2 = jsonArray1.getJSONObject(a);
                        ProdCatObj prodCatObj = new ProdCatObj();
                        prodCatObj.id = jsonObject2.getString("id");
                        prodCatObj.ENG = jsonObject2.getString("ENG");

                        String myString = jsonObject2.getString("ESP");
                        String upperString = myString.substring(0,1).toUpperCase() + myString.substring(1);
                        prodCatObj.ESP = upperString;

                        prodCatObj.FRE = jsonObject2.getString("FRE");
                        prods.add(prodCatObj);
                    }
                    Collections.sort(prods, new Comparator<ProdCatObj>() {
                        public int compare(ProdCatObj result1, ProdCatObj result2) {
                            return result1.ESP.compareTo(result2.ESP);
                        }
                    });
                    sectObj.prodCatObjs = prods;
                    sectores.add(sectObj);
                }
            } catch (JSONException e) {
                e.printStackTrace();
            }
        }
    }

    public static void initUnidades(String json){
        if(unidades.isEmpty()){
            try {
                JSONArray unidadess = new JSONArray(json);
                for(int i = 0; i < unidadess.length(); i++){
                    JSONObject unidad = unidadess.getJSONObject(i);
                    UnidadObj unidadObj = new UnidadObj();
                    unidadObj.id = unidad.getString("id");
                    unidadObj.ESP = unidad.getString("ESP");
                    unidadObj.ENG = unidad.getString("ENG");
                    unidadObj.FRE = unidad.getString("FRE");
                    unidades.add(unidadObj);
                }
            } catch (JSONException e) {
                e.printStackTrace();
            }
        }
    }

    public static ArrayList<UnidadObj> getUnidades(){
        return unidades;
    }

    public static void initSectores(String json){
        if(sectores.isEmpty()){
            try {
                JSONArray jsonArray = new JSONArray(json);
                for(int i = 0; i < jsonArray.length(); i++){
                    JSONObject jsonObject = jsonArray.getJSONObject(i);
                    SectObj sectObj = new SectObj();
                    sectObj.id = jsonObject.getString("id");
                    sectObj.ESP = jsonObject.getString("ESP");
                    sectObj.ENG = jsonObject.getString("ENG");
                    sectObj.FRE = jsonObject.getString("FRE");
                    sectores.add(sectObj);
                }
            } catch (JSONException e) {
                e.printStackTrace();
            }
        }
    }

    public static ArrayList<SectObj> getSectores(){
        return sectores;
    }

    public static void setUsername(TextView arg){
        username = arg;
    }

    public static void setEmail(TextView arg){
        email = arg;
    }

    public static TextView getUsername(){
        return username;
    }

    public static TextView getEmail(){
        return email;
    }

    public static void setLogin(MenuItem arg){
        login = arg;
    }

    public static MenuItem getLogin(){
        return login;
    }

    public static void setChangeFlag(boolean arg){
        changeFlag = arg;
    }

    public static boolean getChangeFlag(){
        return changeFlag;
    }

    private static void initImageLoader(Context context) {
        if(defaultOptions == null)
            defaultOptions = new DisplayImageOptions.Builder()
                    .showImageForEmptyUri(R.drawable.placeholder)
                    .showImageOnFail(R.drawable.placeholder)
                    .resetViewBeforeLoading(true)
                    .cacheOnDisk(true)
                    .bitmapConfig(Bitmap.Config.RGB_565)
                    .considerExifParams(true)
                    .displayer(new FadeInBitmapDisplayer(300))
                    .build();


        config = new ImageLoaderConfiguration.Builder(context)
                .threadPriority(Thread.NORM_PRIORITY)
                .denyCacheImageMultipleSizesInMemory()
                .diskCacheFileNameGenerator(new Md5FileNameGenerator())
                .diskCacheSize(150 * 1024 * 1024) // 150 Mb
                .memoryCacheExtraOptions(480, 800)
                .tasksProcessingOrder(QueueProcessingType.LIFO)
                .writeDebugLogs()
                .threadPoolSize(10)
                .build();

        ImageLoader.getInstance().init(config);
    }

    public static DisplayImageOptions getDefaultOptions(){
        return defaultOptions;
    }

    public static void loadImage(final String url, ImageView imageView, final ProgressBar load){
        ImageLoader.getInstance().displayImage(url, imageView, defaultOptions, new SimpleImageLoadingListener() {
            @Override
            public void onLoadingStarted(String imageUri, View view) {
                load.setVisibility(View.VISIBLE);
            }

            @Override
            public void onLoadingFailed(String imageUri, View view, FailReason failReason) {
                String message = null;
                switch (failReason.getType()) {
                    case IO_ERROR:
                        message = "Error de entrada o de salida";
                        break;
                    case DECODING_ERROR:
                        message = "La imagen no pudo ser decodificada";
                        break;
                    case NETWORK_DENIED:
                        message = "La descarga fue denegada";
                        break;
                    case OUT_OF_MEMORY:
                        message = "Out Of Memory error";
                        break;
                    case UNKNOWN:
                        message = "Error desconocido";
                        break;
                }
                Log.i(url, message);
                load.setVisibility(View.GONE);
            }

            @Override
            public void onLoadingComplete(String imageUri, View view, Bitmap loadedImage) {
                load.setVisibility(android.view.View.GONE);
            }
        });
    }

    public static void clearImageCache(String url){
        MemoryCacheUtils.removeFromCache(url, ImageLoader.getInstance().getMemoryCache());
        DiskCacheUtils.removeFromCache(url, ImageLoader.getInstance().getDiskCache());
    }

    public static void hideKeyboard(View view) {
        InputMethodManager manager = (InputMethodManager) view.getContext()
                .getSystemService(Context.INPUT_METHOD_SERVICE);
        if (manager != null)
            manager.hideSoftInputFromWindow(view.getWindowToken(), 0);
    }

    public static void setMarketMenu(MenuItem arg){
        market = arg;
    }

    public static MenuItem getMarketMenu(){
        return market;
    }

    public static void setVentas(ArrayList<AvisoObj> arg){
        ventas = arg;
    }

    public static ArrayList<AvisoObj> getVentas(){
        return ventas;
    }

    public static void setCompras(ArrayList<AvisoObj> arg){
        compras = arg;
    }

    public static ArrayList<AvisoObj> getCompras(){
        return compras;
    }

    public static void setAvisoOporFragment(AvisoOporFragment arg){
        avisoOporFragment = arg;
    }

    public static AvisoOporFragment getAvisoOporFragment(){
        return avisoOporFragment;
    }

    public static void setAvisoItemFragment(int id, AvisoItemFragment arg){
        frags.set(id, arg);
    }

    public static AvisoItemFragment getAvisoItemFragment(int id){
        return frags.get(id);
    }

    public static void setMyProducts(MenuItem arg){
        nav_my_products = arg;
    }

    public static MenuItem getMyProducts(){
        return nav_my_products;
    }

    public static void setMyCount(MenuItem arg){
        nav_my_count = arg;
    }

    public static MenuItem getMyCount(){
        return nav_my_count;
    }

    public static void setFilterSectorid(String arg){
        filterSectorid = arg;
    }

    public static String getFilterSectorid(){
        return filterSectorid;
    }

    public static void setFilterMes(String arg){
        filterMes = arg;
    }

    public static String getFilterMes(){
        return filterMes;
    }

    public static void setFilterEstadoid(String arg){
        filterEstadoid = arg;
    }

    public static String getFilterEstadoid(){
        return filterEstadoid;
    }

    public static void setFilterCapacidadprod(int arg){
        filterCapacidadprod = arg;
    }

    public static int getFilterCapacidadprod(){
        return filterCapacidadprod;
    }

    public static void setCurrentMonth(ArrayList<String> arg){
        cuurentMonth = arg;
    }

    public static ArrayList<String> getCurrentMonth(){
        return cuurentMonth;
    }

    public static void setCurrentMonthId(ArrayList<String> arg){
        cuurentMonthId = arg;
    }

    public static ArrayList<String> getCurrentMonthId(){
        return cuurentMonthId;
    }

    public static void setDrawerLayout(DrawerLayout arg){
        drawerLayout = arg;
    }

    public static void lockDrawer(){
        drawerLayout.setDrawerLockMode(DrawerLayout.LOCK_MODE_LOCKED_CLOSED, drawerLayout.findViewById(R.id.left_drawer));
    }

    public static void unlockDrawer(){
        drawerLayout.setDrawerLockMode(DrawerLayout.LOCK_MODE_UNLOCKED, drawerLayout.findViewById(R.id.left_drawer));
    }

    public static void setRefresh(int arg){
        refresh = arg;
    }

    public static int getRefresh(){
        return refresh;
    }

    public static void setCats(ArrayList<CatElemObj> arg){
        cats = arg;
    }

    public static ArrayList<CatElemObj> getCats(){
        return cats;
    }

    public static void genToast(final Activity activity){
        activity.runOnUiThread(new Runnable() {
            @Override
            public void run() {
                Toast.makeText(activity, activity.getResources().getString(R.string.must_login), Toast.LENGTH_LONG).show();
            }
        });
    }

    public static MainActivity mainActivity;

    public static void setMainActivity(MainActivity arg){
        mainActivity = arg;
    }

    public static MainActivity getMainActivity(){
        return mainActivity;
    }

    private static RegisterDialog registerDialog;

    public static RegisterDialog showRegisterDialog(FragmentManager manager){
        if(registerDialog == null){
            synchronized (SingleTon.class){
                if(registerDialog == null){
                    registerDialog = RegisterDialog.newInstance();
                    registerDialog.setCancelable(true);
                    registerDialog.show(manager, "register dialog");
                }
            }
        }
        return registerDialog;
    }

    public static void dissmissRegisterDialog(){
        if(registerDialog != null) {
            registerDialog.dismiss();
            registerDialog = null;
        }
    }

    public static int getGetCurrentDrawable(){
        return getCurrentDrawable;
    }

    public static void setAduanas(ArrayList<CatElemObj> arg){
        aduanas = arg;
    }

    public static ArrayList<CatElemObj> getAduanas(){
        return aduanas;
    }

    public static void setAsociaciones(ArrayList<CatElemObj> arg){
        asociaciones = arg;
    }

    public static ArrayList<CatElemObj> getAsociaciones(){
        return asociaciones;
    }

    public static void setAgentes(ArrayList<CatElemObj> arg){
        agentes = arg;
    }

    public static ArrayList<CatElemObj> getAgentes(){
        return agentes;
    }

    public static void setProductores(ArrayList<CatElemObj> arg){
        productores = arg;
    }

    public static ArrayList<CatElemObj> getProductores(){
        return productores;
    }

    public static void setCompradores(ArrayList<CatElemObj> arg){
        compradores = arg;
    }

    public static ArrayList<CatElemObj> getCompradores(){
        return compradores;
    }

    public static void setCertificador(ArrayList<CatElemObj> arg){
        certificador = arg;
    }

    public static ArrayList<CatElemObj> getCertificador(){
        return certificador;
    }

    public static void setActionProgress(ProgressBar arg){
        actionProgress = arg;
    }

    public static ProgressBar getActionProgress(){
        return actionProgress;
    }

    public static void setCalifText(TextView arg){
        califText = arg;
    }

    public static TextView getCalifText(){
        return califText;
    }

    public static void setMainSubastasFragment(MainSubastasFragment arg){
        mainSubastasFragment = arg;
    }

    public static MainSubastasFragment getMainSubastasFragment(){
        return mainSubastasFragment;
    }

}