ProductUseCase

package ru.cash.terminal.domain.usecases;

import java.util.List;
import java.util.UUID;

import javax.inject.Inject;

import ru.cash.terminal.domain.entities.Product;
import ru.cash.terminal.domain.executors.PostExecutionThread;
import ru.cash.terminal.domain.executors.ThreadExecutor;
import ru.cash.terminal.domain.services.ProductService;
import ru.cash.terminal.domain.usecases.base.ServiceUseCase;
import rx.Observable;
import rx.functions.Func1;

import static ru.cash.terminal.utils.Utility.NOT_FATAL;
import static ru.cash.terminal.utils.Utility.REQUIRED_FIELD;


public class ProductUseCase extends ServiceUseCase<Product, ProductService> {

    @Inject
    protected ProductUseCase(ThreadExecutor threadExecutor,
                             PostExecutionThread postExecutionThread,
                             ProductService service) {
        super(threadExecutor, postExecutionThread, service);
    }

    public Observable<Product> getBySearch(final String searchText, Product.Sorting sorting) {
        return tService.getBySearch(searchText, sorting).filter(new Func1<Product, Boolean>() {
            @Override
            public Boolean call(Product product) {
                return (product.getName().toLowerCase().contains(searchText)
                        || product.getArticle().toLowerCase().contains(searchText));

            }
        });
    }

    public Observable<Product> getProductByCatalog(String catalogId, Product.Sorting sorting) {
        return tService.getProductByCatalogId(catalogId, sorting);
    }

    public Observable<Product> getSortedByArticle(final String article, final boolean isAdd, final boolean isError) {
        return super.getAll()
                .toList()
                .map(new Func1<List<Product>, Product>() {
                    @Override
                    public Product call(List<Product> products) {
                        for (int i = 0; i < products.size(); i++) {
                            Product product = products.get(i);
                            if (!product.isRemoved() && product.getArticle().equals(article)) {
                                return product;
                            }
                        }
                        return null;
                    }
                })
                .flatMap(new Func1<Product, Observable<Product>>() {
                    @Override
                    public Observable<Product> call(Product product) {
                        if (product == null) {
                            if (!isAdd) {
                                addErrorMessage(NOT_FATAL + "Товар не найден");
                            } else {
                                if (isError) {
                                    addErrorMessage(NOT_FATAL + "Товар не найден");
                                    return getObservableError();
                                } else {
                                    return Observable.just(new Product());
                                }
                            }

                        }
                        return Observable.just(product);
                    }
                });
    }

    public Observable<Boolean> saveOrUpdateNewAndOldProductList(List<Product> newProducts, final List<Product> oldProducts) {

        return Observable.just(oldProducts)
                .flatMap(new Func1<List<Product>, Observable<Product>>() {
                    @Override
                    public Observable<Product> call(List<Product> products) {

                        return Observable.from(products);
                    }
                })
                .flatMap(new Func1<Product, Observable<Boolean>>() {
                    @Override
                    public Observable<Boolean> call(Product oldProduct) {
                        oldProduct.setRemoved(true);
                        oldProduct.getCatalog().setRemoved(true);
                        return tService.saveOrUpdate(oldProduct);
                    }
                })
                .concatWith(
                        Observable.from(newProducts)
                                .flatMap(new Func1<Product, Observable<Boolean>>() {
                                    @Override
                                    public Observable<Boolean> call(Product newProduct) {
                                        newProduct.setId(UUID.randomUUID().toString().toUpperCase());
                                        return tService.saveOrUpdate(newProduct);
                                    }
                                }));

    }

    public Observable<Boolean> saveOrUpdateProduct(final Product product, final String firstArticle, final boolean isNew) {
        if (!product.isRemoved()) {
            validateProduct(product);
            if (parametersIncorrect())
                return getObservableError();
        }
        return getAll()
                .toList()
                .map(new Func1<List<Product>, Boolean>() {
                    @Override
                    public Boolean call(List<Product> products) {
                        for (Product p : products) {
                            if (((!p.isRemoved()) && p.getArticle().equals(product.getArticle())) // true, если такой баркод есть в базе
                                    && !product.getArticle().equals(firstArticle)) {//true, если баркод изменился
                                return true;
                            }
                        }
                        return false;
                    }
                })
                .flatMap(new Func1<Boolean, Observable<Boolean>>() {
                    @Override
                    public Observable<Boolean> call(Boolean isExist) {
                        if (isExist) {
                            addErrorMessage(NOT_FATAL + "Товар с таким штрихкодом уже есть в базе номенклатур");
                            return getObservableError();
                        }
                        return saveOrUpdate(product.setRemoved(!isNew));
                    }
                });
    }

    private void validateProduct(Product product) {
        if (product.getPrice() == null) {
            addErrorMessage(NOT_FATAL + "Цена" + REQUIRED_FIELD);
        }
        if (product.getPrice() != null && product.getPrice() == 0.0d) {
            addErrorMessage(NOT_FATAL + "Цена товара должна быть больше нуля");
        }
        if (product.getArticle() == null || product.getArticle().equals("")) {
            addErrorMessage(NOT_FATAL + "Штрихкод" + REQUIRED_FIELD);
        }
        if (product.getRemainder() == -1) {
            addErrorMessage(NOT_FATAL + "Остаток" + REQUIRED_FIELD);
        }
        if (product.getName() == null || product.getName().equals("")) {
            addErrorMessage(NOT_FATAL + "Наименование" + REQUIRED_FIELD);
        }
        if (product.getProductUnit() == null) {
            addErrorMessage(NOT_FATAL + "Необходимо выбрать единицу измерения");
        }

        if (product.getCatalog() == null) {
            addErrorMessage(NOT_FATAL + "Необходимо выбрать родительскую категорию");
        }

        if (product.getTaxComplexParam() == null) {
            addErrorMessage(NOT_FATAL + "Необходимо выбрать НДС продукта");
        }

        if (product.getProductUnit() != null && !product.getProductUnit().isFractional()
//                && (String.valueOf(product.getRemainder()).isContainsInParameters(".") || String.valueOf(product.getRemainder()).isContainsInParameters(","))
                && !isZeroFraction(product.getRemainder())) {
            addErrorMessage(NOT_FATAL + "Введено неверное количество товара");
        }
    }

    private boolean isZeroFraction(Double value) {
        return value % 1 == 0.0;
    }

    public Observable<Boolean> saveOrUpdateProductList(List<Product> productList) {

        return Observable.from(productList)
                .flatMap(new Func1<Product, Observable<Boolean>>() {
                    @Override
                    public Observable<Boolean> call(Product product) {
                        return tService.saveOrUpdate(product);
                    }
                }).toList().flatMap(new Func1<List<Boolean>, Observable<Boolean>>() {
                    @Override
                    public Observable<Boolean> call(List<Boolean> booleen) {
                        return Observable.just(true);
                    }
                });

    }
}