package com.ikea.shared.products.service;

import android.content.Context;
import android.text.TextUtils;
import com.ikea.shared.AppConfigData;
import com.ikea.shared.AppConfigManager;
import com.ikea.shared.BaseService;
import com.ikea.shared.BaseService.NetworkCaller;
import com.ikea.shared.config.model.KillSwitchConfig;
import com.ikea.shared.network.KompisRequest;
import com.ikea.shared.network.RequestUtil;
import com.ikea.shared.products.model.RetailItemCommunication;
import com.ikea.shared.stores.model.RetailItemAvailability;
import com.ikea.shared.stores.model.RetailItemCommChildAvailability;
import com.ikea.shared.stores.model.StockAvailability;
import com.ikea.shared.stores.model.StockAvailabilityResponse;
import com.ikea.shared.util.BasePriceUtil;
import com.ikea.shared.util.L;
import com.ikea.shared.util.ServiceCallback;
import java.util.List;
import java.util.concurrent.ExecutorService;

public final class ProductService extends BaseService
{
  private static final String NO = "NO";
  private static final String YES = "YES";
  private static ProductService mInstance;

  private ProductService(Context paramContext)
  {
    super(paramContext);
  }

  private RetailItemCommunication getProductInfo(String paramString1, String paramString2)
    throws Exception
  {
    KompisRequest localKompisRequest = RequestUtil.getPIPRequest(this.mContext, paramString1, paramString2);
    return (RetailItemCommunication)new BaseService.NetworkCaller(this, RetailItemCommunication.class, this.mContext).execute(localKompisRequest);
  }

  private STOCK_STATUS getStockStatus(String paramString1, String paramString2, String paramString3, int paramInt1, String paramString4, boolean paramBoolean, int paramInt2, String paramString5)
  {
    if (paramBoolean)
    {
      STOCK_STATUS localSTOCK_STATUS;
      if (paramInt1 > 0)
        if ((!TextUtils.isEmpty(paramString4)) && ("low".equalsIgnoreCase(paramString4)))
          localSTOCK_STATUS = STOCK_STATUS.LOW_STOCK;
      while (true)
      {
        if ((!TextUtils.isEmpty(paramString1)) && (paramString1.equals("3")) && (localSTOCK_STATUS.equals(STOCK_STATUS.NOT_SALE)))
          localSTOCK_STATUS = STOCK_STATUS.ORDER_IN_STORE;
        return localSTOCK_STATUS;
        if ((!TextUtils.isEmpty(paramString4)) && (("high".equalsIgnoreCase(paramString4)) || ("medium".equalsIgnoreCase(paramString4))))
        {
          localSTOCK_STATUS = STOCK_STATUS.IN_STOCK;
        }
        else
        {
          localSTOCK_STATUS = STOCK_STATUS.NOT_INFO;
          continue;
          if ((!TextUtils.isEmpty(paramString2)) && (paramString2.equals("YES")))
            localSTOCK_STATUS = STOCK_STATUS.NOT_STOCK;
          else if ((!TextUtils.isEmpty(paramString3)) && (paramString3.equals("YES")))
            localSTOCK_STATUS = STOCK_STATUS.ORDER_IN_STORE;
          else
            localSTOCK_STATUS = STOCK_STATUS.NOT_SALE;
        }
      }
    }
    if ((!TextUtils.isEmpty(paramString5)) && (paramString5.equals("Some parts of the SPR is available by order")))
      return STOCK_STATUS.ORDER_SOME_PARTS_IN_STORE;
    if (paramInt2 == 404)
      return STOCK_STATUS.NOT_INFO;
    return STOCK_STATUS.NO_SERVICE;
  }

  public static ProductService i(Context paramContext)
  {
    try
    {
      if (mInstance == null)
        mInstance = new ProductService(paramContext);
      ProductService localProductService = mInstance;
      return localProductService;
    }
    finally
    {
    }
  }

  public void getProductAvailabilityAsync(final ServiceCallback<StockAvailabilityResponse> paramServiceCallback, final String paramString, final RetailItemCommunication paramRetailItemCommunication)
  {
    this.mExecutorService.execute(new Runnable()
    {
      public void run()
      {
        try
        {
          StockAvailabilityResponse localStockAvailabilityResponse = ProductService.this.getProductStockInfo(paramString, paramRetailItemCommunication);
          paramServiceCallback.callbackDone(localStockAvailabilityResponse, null, null);
          return;
        }
        catch (Exception localException)
        {
          localException.printStackTrace();
          paramServiceCallback.callbackDone(null, null, localException);
        }
      }
    });
  }

  public void getProductInfo(final String paramString1, final String paramString2, final String paramString3, final ServiceCallback<RetailItemCommunication> paramServiceCallback)
  {
    this.mExecutorService.execute(new Runnable()
    {
      public void run()
      {
        RetailItemCommunication localRetailItemCommunication = null;
        try
        {
          L.I(this, "product service item Number " + paramString2);
          localRetailItemCommunication = ProductService.this.getProductInfo(paramString1, paramString2);
          if ((localRetailItemCommunication != null) && (localRetailItemCommunication.isSuccessful()) && (paramString3 != null) && (!paramString3.isEmpty()))
            localRetailItemCommunication.setStockAvailability(ProductService.this.getProductStockInfo(paramString3, localRetailItemCommunication));
          paramServiceCallback.callbackDone(localRetailItemCommunication, null, null);
          return;
        }
        catch (Exception localException)
        {
          localException.printStackTrace();
          if (localRetailItemCommunication != null)
            paramServiceCallback.callbackDone(localRetailItemCommunication, null, null);
          paramServiceCallback.callbackDone(null, null, localException);
        }
      }
    });
  }

  public StockAvailabilityResponse getProductStockInfo(String paramString, RetailItemCommunication paramRetailItemCommunication)
  {
    if ((AppConfigManager.i(this.mContext).getAppConfigData() != null) && (AppConfigManager.i(this.mContext).getAppConfigData().getKillSwitchConfig() != null) && (!AppConfigManager.i(this.mContext).getAppConfigData().getKillSwitchConfig().isPerformStockCheck()))
      return null;
    KompisRequest localKompisRequest = RequestUtil.getProductStockInfoRequest(this.mContext, paramString, paramRetailItemCommunication);
    try
    {
      StockAvailabilityResponse localStockAvailabilityResponse = (StockAvailabilityResponse)new BaseService.NetworkCaller(this, StockAvailabilityResponse.class, this.mContext).execute(localKompisRequest);
      return localStockAvailabilityResponse;
    }
    catch (Exception localException)
    {
      localException.printStackTrace();
    }
    return null;
  }

  public STOCK_STATUS getStockStatus(RetailItemCommunication paramRetailItemCommunication)
  {
    Object localObject = STOCK_STATUS.NONE;
    if (paramRetailItemCommunication != null);
    try
    {
      if ((paramRetailItemCommunication.getStockAvailability() != null) && (paramRetailItemCommunication.getStockAvailability().getStockAvailability() != null) && (!paramRetailItemCommunication.getStockAvailability().getStockAvailability().isEmpty()))
      {
        if (BasePriceUtil.isFoodType(paramRetailItemCommunication, this.mContext))
          return STOCK_STATUS.NOT_INFO;
        STOCK_STATUS localSTOCK_STATUS = getStockStatus(((StockAvailability)paramRetailItemCommunication.getStockAvailability().getStockAvailability().get(0)).getRetailItemAvailability());
        localObject = localSTOCK_STATUS;
      }
      return localObject;
    }
    catch (Exception localException)
    {
      while (true)
        L.E("Stock quantity format exception :" + localException.getMessage());
    }
  }

  public STOCK_STATUS getStockStatus(RetailItemAvailability paramRetailItemAvailability)
  {
    STOCK_STATUS localSTOCK_STATUS = STOCK_STATUS.NONE;
    if (paramRetailItemAvailability != null)
      try
      {
        if (TextUtils.isEmpty(paramRetailItemAvailability.getAvailableStock()));
        String str2;
        for (Object localObject = "0"; ; localObject = str2)
        {
          int i = Integer.parseInt((String)localObject);
          String str1 = paramRetailItemAvailability.getInStockProbabilityCode();
          return getStockStatus(paramRetailItemAvailability.getSalesMethodCode(), paramRetailItemAvailability.getInStockRangeCode(), paramRetailItemAvailability.getInCustomerOrderRangeCode(), i, str1, true, 200, "");
          str2 = paramRetailItemAvailability.getAvailableStock();
        }
      }
      catch (Exception localException)
      {
        L.E("Stock quantity format exception :" + localException.getMessage());
      }
    return localSTOCK_STATUS;
  }

  public STOCK_STATUS getStockStatus(RetailItemCommChildAvailability paramRetailItemCommChildAvailability)
  {
    return STOCK_STATUS.IN_STOCK;
  }

  public static enum STOCK_STATUS
  {
    static
    {
      LOW_STOCK = new STOCK_STATUS("LOW_STOCK", 2);
      NOT_INFO = new STOCK_STATUS("NOT_INFO", 3);
      NOT_SALE = new STOCK_STATUS("NOT_SALE", 4);
      NONE = new STOCK_STATUS("NONE", 5);
      ORDER_IN_STORE = new STOCK_STATUS("ORDER_IN_STORE", 6);
      ORDER_SOME_PARTS_IN_STORE = new STOCK_STATUS("ORDER_SOME_PARTS_IN_STORE", 7);
      NO_SERVICE = new STOCK_STATUS("NO_SERVICE", 8);
      STOCK_STATUS[] arrayOfSTOCK_STATUS = new STOCK_STATUS[9];
      arrayOfSTOCK_STATUS[0] = IN_STOCK;
      arrayOfSTOCK_STATUS[1] = NOT_STOCK;
      arrayOfSTOCK_STATUS[2] = LOW_STOCK;
      arrayOfSTOCK_STATUS[3] = NOT_INFO;
      arrayOfSTOCK_STATUS[4] = NOT_SALE;
      arrayOfSTOCK_STATUS[5] = NONE;
      arrayOfSTOCK_STATUS[6] = ORDER_IN_STORE;
      arrayOfSTOCK_STATUS[7] = ORDER_SOME_PARTS_IN_STORE;
      arrayOfSTOCK_STATUS[8] = NO_SERVICE;
    }
  }
}

/* Location:           C:\Documents and Settings\Cesar Cabello Cea\Mis documentos\Downloads\apk-downloader\com.ikea.kompis-6_dex2jar.jar
 * Qualified Name:     com.ikea.shared.products.service.ProductService
 * JD-Core Version:    0.6.2
 */