package com.srv4pos.server.api.sync.sample;
   
   import com.srv4pos.server.api.category.CategoryInfo;
   import com.srv4pos.server.api.commodity.CommodityInfo;
   import com.srv4pos.server.api.day.DayInfo;
   import com.srv4pos.server.api.keyboard.KeyboardInfo;
   import com.srv4pos.server.api.keyboardentry.KeyboardEntryInfo;
   import com.srv4pos.server.api.order.OrderInfo;
   import com.srv4pos.server.api.product.ProductInfo;
  import com.srv4pos.server.api.sale.SaleInfo;
  import com.srv4pos.server.api.sale.SaleSlotInfo;
  import com.srv4pos.server.api.seller.SellerInfo;
  import com.srv4pos.server.api.sync.SyncVersionInfo;
  import com.srv4pos.server.api.tax.TaxInfo;
  import com.srv4pos.server.api.transportation.TripInfo;
  import com.srv4pos.server.api.treasurer.TreasurerInfo;
  
  import java.util.ArrayList;
  import java.util.List;
  
  public class MemoryLocalStorage {
  
      private SellerInfo seller;
      private boolean sellerIsSynced;
  
      private List<SyncProduct> products = new ArrayList<SyncProduct>();
      private List<SyncTax> taxes = new ArrayList<SyncTax>();
      private List<SyncCategory> categories = new ArrayList<SyncCategory>();
      private List<SyncCommodity> commodities = new ArrayList<SyncCommodity>();
      private List<SyncTreasurer> treasurers = new ArrayList<SyncTreasurer>();
      private List<SyncOrder> orders = new ArrayList<SyncOrder>();
      private List<SyncKeyboard> keyboards = new ArrayList<SyncKeyboard>();
      private List<SyncKeyboardEntry> keyboardEntries = new ArrayList<SyncKeyboardEntry>();
      private List<SyncSaleSlot> saleSlots = new ArrayList<SyncSaleSlot>();
      private List<SyncDay> days = new ArrayList<SyncDay>();
      private List<SyncTrip> trips = new ArrayList<SyncTrip>();
      private List<SyncSale> sales = new ArrayList<SyncSale>();
  
      private int localVersion;
  
      public MemoryLocalStorage() {
          localVersion = 0;
      }
  
      public String toString() {
          StringBuilder sb = new StringBuilder();
  
          sb.append("version: ")
                  .append(localVersion).append("\n")
                  .append((sellerIsSynced ? "synced " : "not synced "))
                  .append(seller).append("\n");
  
          for (final SyncTax tax : taxes) {
              sb.append(tax).append("\n");
          }
  
          for (final SyncProduct product : products) {
              sb.append(product).append("\n");
          }
  
          for (final SyncCategory category : categories) {
              sb.append(category).append("\n");
          }
  
          for (final SyncCommodity commodity : commodities) {
              sb.append(commodity).append("\n");
          }
  
          for (final SyncTreasurer treasurer : treasurers) {
              sb.append(treasurer).append("\n");
          }
  
          for (final SyncOrder order : orders) {
              sb.append(order).append("\n");
          }
  
          return sb.toString();
      }
  
      // alternative to this: make MemoryLocalStorage to implement SyncVersionInfo
      // or even use some independent class which implements SyncVersionInfo
      private SyncVersionInfo syncInfo = new SyncVersionInfo() {
          public int getVersion() {
              return localVersion;
          }
  
          public void setVersion(int version) {
              localVersion = version;
          }
  
          public String toString() {
              return String.format("SyncInfo version: %d", getVersion());
          }
      };
  
      public SyncVersionInfo getSyncInfo() {
          return syncInfo;
      }
  
     public int getLocalVersion() {
         return localVersion;
     }
 
 
     public SellerInfo getSeller() {
         return seller;
     }
 
     public void setSeller(final SellerInfo seller) {
         this.seller = seller;
         setSellerSynced(false);
     }
 
     public boolean isSellerSynced() {
         return sellerIsSynced;
     }
 
     public void setSellerSynced(final boolean sellerSynced) {
         this.sellerIsSynced = sellerSynced;
     }
 
 
     public List<SyncProduct> getProducts() {
         return products;
     }
 
     public void setProducts(final List<SyncProduct> products) {
         this.products = products;
     }
 
     public SyncProduct getProduct(final int index) {
         if (index >= getProducts().size()) {
             return null;
         }
         return getProducts().get(index);
     }
 
     public SyncProduct getProductByIdentifier(final String identifier) {
         if (identifier == null) {
             return null;
         }
 
         for (final SyncProduct p : products) {
             final ProductInfo info = p.getInfo();
             if (info != null //&& !info.isDeleted()
                     && info.getIdentifier() != null
                     && info.getIdentifier().equals(identifier)) {
                 return p;
             }
         }
         return null;
     }
 
     public List<SyncProduct> getProductsByTax(final SyncTax tax) {
 
         List<SyncProduct> productList = new ArrayList<SyncProduct>();
 
         for (final SyncProduct syncProduct : getProducts()) {
             if (!syncProduct.getInfo().isDeleted()
                     && syncProduct.getTax() == tax) {
                 productList.add(syncProduct);
             }
         }
 
         return productList;
     }
 
     public List<SyncProduct> getProductsByTaxIndex(final int index) {
         return getProductsByTax(getTax(index));
     }
 
     public List<SyncProduct> getProductsByCategory(final SyncCategory category) {
 
         List<SyncProduct> productList = new ArrayList<SyncProduct>();
 
         for (final SyncCommodity commodity : getCommodities()) {
             if (commodity.getCategory() == category
                     && !commodity.getInfo().isDeleted()) {
 
                 final SyncProduct product = commodity.getProduct();
 
                 if (product != null && !product.getInfo().isDeleted()) {
                     productList.add(product);
                 }
             }
         }
 
         return productList;
     }
 
     public List<SyncProduct> getProductsByCategoryIndex(final int index) {
         return getProductsByCategory(getCategory(index));
     }
 
     public void add(final SyncProduct p) {
         products.add(p);
     }
 
     public int delete(final SyncProduct product, final boolean forceDeleteRelated) {
 
         int countDeleted = 0;
 
         for (SyncCommodity commodity : getCommodities()) {
             if (commodity.getProduct() == product) {
                 if (forceDeleteRelated) {
                     commodity.getInfo().setDeleted(true);
                     countDeleted++;
                     break;
                 } else {
                     return 0;
                 }
             }
         }
         product.getInfo().setDeleted(true);
         countDeleted++;
 
         return countDeleted;
     }
 
 
     public List<SyncTax> getTaxes() {
         return taxes;
     }
 
     public void setTaxes(final List<SyncTax> taxes) {
         this.taxes = taxes;
     }
 
     public SyncTax getTax(final int index) {
         if (index >= getTaxes().size()) {
             return null;
         }
         return getTaxes().get(index);
     }
 
     public SyncTax getTaxByIdentifier(final String identifier) {
         if (identifier == null) {
             return null;
         }
 
         for (final SyncTax tax : taxes) {
             final TaxInfo info = tax.getInfo();
             if (info != null //&& !info.isDeleted()
                     && info.getIdentifier() != null
                     && info.getIdentifier().equals(identifier)) {
                 return tax;
             }
         }
         return null;
     }
 
     public SyncTax getTaxByVat(final int vat) {
 
         for (final SyncTax tax : taxes) {
             final TaxInfo info = tax.getInfo();
             if (info != null && !info.isDeleted() && info.getVat() == vat) {
                 return tax;
             }
         }
         return null;
     }
 
     public void add(final SyncTax tax) {
         taxes.add(tax);
     }
 
     public int delete(final SyncTax tax, final boolean forceDeleteRelated) {
 
         int countDeleted = 0;
 
         for (SyncProduct product : getProducts()) {
             if (product.getTax() == tax) {
                 if (forceDeleteRelated) {
                     countDeleted += delete(product, forceDeleteRelated);
                 } else {
                     return 0;
                 }
             }
         }
         tax.getInfo().setDeleted(true);
         countDeleted++;
 
         return countDeleted;
     }
 
 
     public List<SyncCategory> getCategories() {
         return categories;
     }
 
     public void setCategories(final List<SyncCategory> categories) {
         this.categories = categories;
     }
 
     public SyncCategory getCategory(final int index) {
         if (index >= getCategories().size()) {
             return null;
         }
         return getCategories().get(index);
     }
 
     public SyncCategory getCategoryByIdentifier(final String identifier) {
         if (identifier == null) {
             return null;
         }
 
         for (final SyncCategory cat : categories) {
             final CategoryInfo info = cat.getInfo();
             if (info != null //&& !info.isDeleted()
                     && info.getIdentifier() != null
                     && info.getIdentifier().equals(identifier)) {
                 return cat;
             }
         }
         return null;
     }
 
     public void add(final SyncCategory cat) {
         categories.add(cat);
     }
 
     public int delete(final SyncCategory cat, final boolean forceDeleteRelated) {
 
         int countDeleted = 0;
 
         for (SyncCommodity commodity : getCommodities()) {
             if (commodity.getCategory() == cat) {
                 if (forceDeleteRelated) {
                     countDeleted += delete(commodity, forceDeleteRelated);
                 } else {
                     return 0;
                 }
             }
         }
         cat.getInfo().setDeleted(true);
         countDeleted++;
 
         return countDeleted;
     }
 
 
     public List<SyncCommodity> getCommodities() {
         return commodities;
     }
 
     public void setCommodities(final List<SyncCommodity> commodities) {
         this.commodities = commodities;
     }
 
     public SyncCommodity getCommodity(final int index) {
         if (index >= getCommodities().size()) {
             return null;
         }
         return getCommodities().get(index);
     }
 
     public SyncCommodity getCommodityByIdentifier(final String identifier) {
         return getCommodityByIdentifier(identifier, true); // default behaviour for all getByIdentifier - including deleted too
     }
 
     public SyncCommodity getCommodityByIdentifier(final String identifier, boolean checkDeletedToo) {
         if (identifier == null) {
             return null;
         }
 
         for (final SyncCommodity c : commodities) {
             final CommodityInfo info = c.getInfo();
             if (info != null && (!info.isDeleted() || checkDeletedToo)
                     && info.getIdentifier() != null
                     && info.getIdentifier().equals(identifier)) {
                 return c;
             }
         }
         return null;
     }
 
     public void add(final SyncCommodity c) {
         commodities.add(c);
     }
 
     public int delete(final SyncCommodity c, final boolean forceDeleteRelated) {
 
         int countDeleted = 0;
 
         if (c.getProduct() != null) {
             if (forceDeleteRelated) {
                 c.getProduct().getInfo().setDeleted(true);
                 countDeleted++;
             } else {
                 return 0;
             }
         }
 
         c.getInfo().setDeleted(true);
         countDeleted++;
 
         return countDeleted;
     }
 
     public List<SyncTreasurer> getTreasurers() {
         return treasurers;
     }
 
     public void setTreasurers(List<SyncTreasurer> treasurers) {
         this.treasurers = treasurers;
     }
 
     public SyncTreasurer getTreasurer(final int index) {
         if (index >= getTreasurers().size()) {
             return null;
         }
         return getTreasurers().get(index);
     }
 
     public SyncTreasurer getTreasurerByIdentifier(final String identifier) {
         if (identifier == null) {
             return null;
         }
 
         for (final SyncTreasurer t : treasurers) {
             final TreasurerInfo info = t.getInfo();
             if (info != null //&& !info.isDeleted()
                     && info.getIdentifier() != null
                     && info.getIdentifier().equals(identifier)) {
                 return t;
             }
         }
         return null;
     }
 
     public void add(final SyncTreasurer t) {
         treasurers.add(t);
     }
 
     public int delete(final SyncTreasurer t, final boolean forceDeleteRelated) {
 
         int countDeleted = 0;
 
         t.getInfo().setDeleted(true);
         countDeleted++;
 
         return countDeleted;
     }
 
     public SyncTreasurer getTreasurerBySsn(final String ssn) {
 
         if (ssn == null) {
             return null;
         }
 
         for (final SyncTreasurer t : treasurers) {
             final TreasurerInfo info = t.getInfo();
             if (info != null && !info.isDeleted() && ssn.equals(info.getSsn())) {
                 return t;
             }
         }
         return null;
     }
 
     public SyncTreasurer getTreasurerByName(final String name) {
 
         if (name == null) {
             return null;
         }
 
         for (final SyncTreasurer t : treasurers) {
             final TreasurerInfo info = t.getInfo();
             if (info != null && !info.isDeleted() && name.equals(info.getName())) {
                 return t;
             }
         }
         return null;
     }
 
 
     public List<SyncOrder> getOrders() {
         return orders;
     }
 
     public void setOrders(List<SyncOrder> orders) {
         this.orders = orders;
     }
 
     public SyncOrder getOrder(final int index) {
         if (index >= getOrders().size()) {
             return null;
         }
         return getOrders().get(index);
     }
 
     public SyncOrder getOrderByIdentifier(final String identifier) {
         if (identifier == null) {
             return null;
         }
 
         for (final SyncOrder order : orders) {
             final OrderInfo info = order.getInfo();
             if (info != null //&& !info.isDeleted()
                     && info.getIdentifier() != null
                     && info.getIdentifier().equals(identifier)) {
                 return order;
             }
         }
         return null;
     }
 
     public void add(final SyncOrder order) {
         orders.add(order);
     }
 
     public int delete(final SyncOrder order, final boolean forceDeleteRelated) {
 
         int countDeleted = 0;
 
         order.getInfo().setDeleted(true);
         countDeleted++;
 
         return countDeleted;
     }
 
     public List<SyncKeyboard> getKeyboards() {
         return keyboards;
     }
 
     public void setKeyboards(List<SyncKeyboard> keyboards) {
         this.keyboards = keyboards;
     }
 
     public SyncKeyboard getKeyboard(final int index) {
         if (index >= getKeyboards().size()) {
             return null;
         }
         return getKeyboards().get(index);
     }
 
     public SyncKeyboard getKeyboardByIdentifier(final String idenifier) {
         if (idenifier == null) {
             return null;
         }
 
         for (final SyncKeyboard keyboard : keyboards) {
             final KeyboardInfo info = keyboard.getInfo();
             if (info != null && info.getIdentifier() != null && info.getIdentifier().equals(idenifier)) {
                 return keyboard;
             }
         }
         return null;
     }
 
     public void add(final SyncKeyboard keyboard) {
         keyboards.add(keyboard);
     }
 
     public int delete(final SyncKeyboard keyboard) {
 
         int countDeleted = 0;
 
         keyboard.getInfo().setDeleted(true);
         countDeleted++;
 
         return countDeleted;
     }
 
     public List<SyncKeyboardEntry> getKeyboardEntries() {
         return keyboardEntries;
     }
 
     public List<SyncSaleSlot> getSaleSlots() {
         return saleSlots;
     }
 
     public void setKeyboardEntries(List<SyncKeyboardEntry> keyboardEntries) {
         this.keyboardEntries = keyboardEntries;
     }
 
     public void setSaleSlots(List<SyncSaleSlot> saleSlots) {
         this.saleSlots = saleSlots;
     }
 
     public SyncKeyboardEntry getKeyboardEntry(final int index) {
         if (index >= getKeyboardEntries().size()) {
             return null;
         }
         return getKeyboardEntries().get(index);
     }
 
     public SyncSaleSlot getSaleSlot(final int index) {
         if (index >= getSaleSlots().size()) {
             return null;
         }
         return getSaleSlots().get(index);
     }
 
     public SyncKeyboardEntry getKeyboardEntryByIdentifier(final String idenifier) {
         if (idenifier == null) {
             return null;
         }
 
         for (final SyncKeyboardEntry keyboardEntry : keyboardEntries) {
             final KeyboardEntryInfo info = keyboardEntry.getInfo();
             if (info != null && info.getIdentifier() != null && info.getIdentifier().equals(idenifier)) {
                 return keyboardEntry;
             }
         }
         return null;
     }
 
     public SyncSaleSlot getSaleSlotByIdentifier(final String identifier) {
         if (identifier == null) {
             return null;
         }
 
         for (final SyncSaleSlot saleSlot : saleSlots) {
             final SaleSlotInfo info = saleSlot.getInfo();
             if (info != null && info.getIdentifier() != null && info.getIdentifier().equals(identifier)) {
                 return saleSlot;
             }
         }
         return null;
     }
 
     public void add(final SyncSaleSlot saleSlot) {
         saleSlots.add(saleSlot);
     }
 
     public void add(final SyncKeyboardEntry keyboardEntry) {
         keyboardEntries.add(keyboardEntry);
     }
 
     public List<SyncDay> getDays() {
         return days;
     }
 
     public SyncDay getDayByIdentifier(String identifier) {
         if (identifier == null) {
             return null;
         }
 
         for (final SyncDay day : days) {
             final DayInfo info = day.getInfo();
             if (info != null && info.getIdentifier() != null && info.getIdentifier().equals(identifier)) {
                 return day;
             }
         }
 
         return null;
     }
 
     public void add(SyncDay day) {
         days.add(day);
     }
 
     public void add(SyncTrip trip) {
         trips.add(trip);
     }
 
     public SyncTrip getTripByIdentifier(String identifier) {
         if (identifier == null) {
             return null;
         }
 
         for (SyncTrip trip : trips) {
             TripInfo info = trip.getInfo();
             if (info != null && info.getIdentifier() != null && info.getIdentifier().equals(identifier)) {
                 return trip;
             }
         }
 
         return null;
     }
 
     public List<SyncTrip> getTrips() {
         return trips;
     }
 
     public List<SyncSale> getSales() {
         return sales;
     }
 
     public SyncSale getSaleByIdentifier(String identifier) {
         if (identifier == null) {
             return null;
         }
 
         for (SyncSale sale : sales) {
             SaleInfo info = sale.getInfo();
             if (info != null && info.getIdentifier() != null && info.getIdentifier().equals(identifier)) {
                 return sale;
             }
         }
 
         return null;
     }
 
     public List<SyncSale> getSalesByTripIdentifier(String tripIdentifier) {
         if (tripIdentifier == null) {
             return null;
         }
 
         List<SyncSale> sales = new ArrayList<SyncSale>();
         for (SyncSale sale : sales) {
             if (sale.getInfo() == null) {
                 continue;
             }
 
             TripInfo info = getTripByIdentifier(sale.getInfo().getTripIdentifier()).getInfo();
 
             if (info != null && info.getIdentifier() != null && info.getIdentifier().equals(tripIdentifier)) {
                 sales.add(sale);
             }
         }
 
         if (sales.isEmpty()) {
             return null;
         } else {
             return sales;
         }
     }
 
     public void add(SyncSale sale) {
         sales.add(sale);
     }
 
     public int delete(final SyncKeyboardEntry keyboardEntry) {
 
         int countDeleted = 0;
 
         keyboardEntry.getInfo().setDeleted(true);
         countDeleted++;
 
         return countDeleted;
     }
     /**
      * <p>Simple check if current storage object is a superset of other memory storage (contains everything from other storage).<br/>
      * Does not compare full contents of entities, compares just entity identifiers. Ignores deleted entities.</p>
      *
      * @param storage MemoryLocalStorage to compare with
      * @return true if self contains everything from storage
      */
     public boolean isSupersetOf(final MemoryLocalStorage storage) {
 
         if (this == storage) {
             throw new UnsupportedOperationException("It is useless to compare some storage with itself");
         }
 
         for (final SyncCommodity commodity : storage.getCommodities()) {
             final CommodityInfo info = commodity.getInfo();
             if (!info.isDeleted()) {
 
                 // for Commodity (a link between Product and Category) we are testing:
                 // 1) commodity identifiers are equal
                 // 2) category identifiers for both commodities are equal (or both are null)
                 // 3) product identifiers for both producs are equal (or both are null)
 
                 final SyncCommodity commodityByIdentifier = getCommodityByIdentifier(info.getIdentifier());
                 if (commodityByIdentifier == null) {
                     return false;
                 }
 
                 final CommodityInfo localInfo = commodityByIdentifier.getInfo();
 
                 if (info.getCategory() != null && localInfo.getCategory() != null) {
                     if (!info.getCategory().equals(localInfo.getCategory())) {
                         return false;
                     }
                 } else if (info.getCategory() != null || localInfo.getCategory() != null) {
                     // e.g. one of them is non-null => they are not equal
                     return false;
                 }
 
                 if (info.getProduct() != null && localInfo.getProduct() != null) {
                     if (!info.getProduct().equals(localInfo.getProduct())) {
                         return false;
                     }
                 } else if (info.getProduct() != null || localInfo.getProduct() != null) {
                     return false;
                 } else if (info.isDeleted() && localInfo.isDeleted() || !info.isDeleted() && localInfo.isDeleted()) {
                     return false;
                 }
             }
         }
 
         for (final SyncCategory cat : storage.getCategories()) {
             final CategoryInfo info = cat.getInfo();
             if (!info.isDeleted() && getCategoryByIdentifier(info.getIdentifier()) == null) {
                 return false;
             }
         }
 
         for (final SyncTax tax : storage.getTaxes()) {
             final TaxInfo info = tax.getInfo();
             if (!info.isDeleted() && getTaxByIdentifier(info.getIdentifier()) == null) {
                 return false;
             }
         }
 
         for (final SyncProduct product : storage.getProducts()) {
             final ProductInfo info = product.getInfo();
             if (!info.isDeleted()) {
 
                 // for Product (which has a link with Tax) we are testing:
                 // 1) product identifiers are equal
                 // 2) tax identifiers for both products are equal
                 //    (in the future we can even test that tax vat value for both product are equal)
 
                 final SyncProduct productByIdentifier = getProductByIdentifier(info.getIdentifier());
 
                 if (productByIdentifier == null) {
                     return false;
                 }
 
                 final ProductInfo localInfo = productByIdentifier.getInfo();
 
                 if (info.getTax() != null && localInfo.getTax() != null) {
                     if (!info.getTax().equals(localInfo.getTax())) {
                         return false;
                     } else {
                         final SyncTax syncTax = storage.getTaxByIdentifier(info.getTax());
                         final SyncTax localSyncTax = getTaxByIdentifier(localInfo.getTax());
 
                         if (syncTax == null || localSyncTax == null) {
                             return false;
                         }
                         if (syncTax.getInfo().getVat() != localSyncTax.getInfo().getVat()) {
                             return false;
                         }
                         if (syncTax.getInfo().isDeleted() && !localSyncTax.getInfo().isDeleted() ||
                                 !syncTax.getInfo().isDeleted() && localSyncTax.getInfo().isDeleted()) {
                             return false;
                         }
                     }
                 } else if (info.getTax() != null || localInfo.getTax() != null) {
                     // e.g. one of them is non-null => they are not equal
                     return false;
                 }
             }
         }
 
         for (final SyncTreasurer treasurer : storage.getTreasurers()) {
             final TreasurerInfo info = treasurer.getInfo();
             if (!info.isDeleted() && getTreasurerByIdentifier(info.getIdentifier()) == null) {
                 return false;
             }
         }
 
         for (final SyncOrder order : storage.getOrders()) {
             final OrderInfo info = order.getInfo();
             if (!info.isDeleted() && getOrderByIdentifier(info.getIdentifier()) == null) {
                 return false;
             }
         }
 
         if (storage.getSeller() != null && getSeller() != null) {
             if (storage.isSellerSynced() != isSellerSynced() || !storage.getSeller().getCorporateId().equals(getSeller().getCorporateId())) {
                 return false;
             }
         }
 
         if (storage.getLocalVersion() != getLocalVersion()) {
             return false;
         }
 
         return true;
     }
 
     /**
      * <p>Simple compare of two memory storages.<br/>
      * Compares just entity identifiers. Ignores deleted entities.</p>
      *
      * @param storage MemoryLocalStorage to compare with
      * @return true if both storages are equal
      */
     public boolean isEqualTo(final MemoryLocalStorage storage) {
         return isSupersetOf(storage) && storage.isSupersetOf(this);
     }
 }