import android.support.v7.util.DiffUtil;

import java.util.List;

import rx.Observable;
import rx.functions.Func2;

public class RxDiffUtil {

    public static <T> Observable.Transformer<T, Result<T>> diff(final Callback<T> callback) {
        return diff(callback, true);
    }

    public static <T> Observable.Transformer<T, Result<T>> diff(final Callback<T> callback, final boolean detectMoves) {
        return new Observable.Transformer<T, Result<T>>() {
            @Override
            public Observable<Result<T>> call(Observable<T> observable) {
                return observable.reduce(null, new Func2<Result<T>, T, Result<T>>() {
                    @Override
                    public Result<T> call(Result<T> oldResult, T newItems) {
                        if (oldResult == null) {
                            return new Result<>(newItems, DiffUtil.calculateDiff(new FirstDiffCallback<>(callback, newItems), detectMoves));
                        } else {
                            return new Result<>(newItems, DiffUtil.calculateDiff(new DiffCallback<>(callback, oldResult.items, newItems), detectMoves));
                        }
                    }
                });
            }
        };
    }

    public static <T extends Diffable<T>> Observable.Transformer<List<T>, Result<List<T>>> diff(boolean detectMoves) {
        return diff(new DiffableListCallback<T>(), detectMoves);
    }

    public static <T extends Diffable<T>> Observable.Transformer<List<T>, Result<List<T>>> diff() {
        return diff(true);
    }

    public interface Diffable<T> {
        boolean isSame(T other);
    }

    public static class Result<T> {
        public final T items;
        public final DiffUtil.DiffResult diff;

        public Result(T items, DiffUtil.DiffResult diff) {
            this.items = items;
            this.diff = diff;
        }
    }

    public static abstract class Callback<T> {
        public abstract int getSize(T list);

        public abstract boolean areItemsTheSame(int oldItemPosition, T oldItems, int newItemPosition, T newItems);

        public abstract boolean areContentsTheSame(int oldItemPosition, T oldItems, int newItemPosition, T newItems);
    }

    public static abstract class ListCallback<T> extends Callback<List<T>> {
        @Override
        public int getSize(List<T> list) {
            return list.size();
        }

        @Override
        public final boolean areItemsTheSame(int oldItemPosition, List<T> oldItems, int newItemPosition, List<T> newItems) {
            return areItemsTheSame(oldItems.get(oldItemPosition), newItems.get(newItemPosition));
        }

        @Override
        public final boolean areContentsTheSame(int oldItemPosition, List<T> oldItems, int newItemPosition, List<T> newItems) {
            return areContentsTheSame(oldItems.get(oldItemPosition), newItems.get(newItemPosition));
        }

        public abstract boolean areItemsTheSame(T oldItem, T newItem);

        public abstract boolean areContentsTheSame(T oldItem, T newItem);
    }

    public static class DiffableListCallback<T extends Diffable<T>> extends ListCallback<T> {
        @Override
        public boolean areItemsTheSame(T oldItem, T newItem) {
            return oldItem.isSame(newItem);
        }

        @Override
        public boolean areContentsTheSame(T oldItem, T newItem) {
            return oldItem.equals(newItem);
        }
    }

    private static class FirstDiffCallback<T> extends DiffUtil.Callback {
        private final Callback<T> callback;
        private final T newItems;

        FirstDiffCallback(Callback<T> callback, T newItems) {
            this.callback = callback;
            this.newItems = newItems;
        }

        @Override
        public int getOldListSize() {
            return 0;
        }

        @Override
        public int getNewListSize() {
            return callback.getSize(newItems);
        }

        @Override
        public boolean areItemsTheSame(int oldItemPosition, int newItemPosition) {
            return false;
        }

        @Override
        public boolean areContentsTheSame(int oldItemPosition, int newItemPosition) {
            return false;
        }
    }

    private static class DiffCallback<T> extends DiffUtil.Callback {
        private final Callback<T> callback;
        private final T oldItems;
        private final T newItems;

        DiffCallback(Callback<T> callback, T oldItems, T newItems) {
            this.callback = callback;
            this.oldItems = oldItems;
            this.newItems = newItems;
        }

        @Override
        public int getOldListSize() {
            return callback.getSize(oldItems);
        }

        @Override
        public int getNewListSize() {
            return callback.getSize(newItems);
        }

        @Override
        public boolean areItemsTheSame(int oldItemPosition, int newItemPosition) {
            return callback.areContentsTheSame(oldItemPosition, oldItems, newItemPosition, newItems);
        }

        @Override
        public boolean areContentsTheSame(int oldItemPosition, int newItemPosition) {
            return callback.areContentsTheSame(oldItemPosition, oldItems, newItemPosition, newItems);
        }
    }
}