package com.dengun.libandroid;

import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.v7.util.DiffUtil;
import android.support.v7.widget.RecyclerView;
import android.view.View;
import android.view.ViewGroup;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;

/**
 * Created by andre on 1/26/18.
 */

public class BaseAdapter extends RecyclerView.Adapter<BaseAdapter.ViewHolderWrapper<?>> {

    private ViewBinder viewBinder;

    private boolean mWaitForUpdate;

    private ArrayList<ViewProvider<Object>> providers = new ArrayList<>();

    public BaseAdapter(ViewBinder... viewBinders) {
        if (viewBinders.length > 1) {
            this.viewBinder = new ViewBinder(viewBinders){};
        }else {
            this.viewBinder = viewBinders[0];
        }
        viewBinder.attachAdapter(this);
    }

    @Override
    public int getItemViewType(int position) {
        ViewProvider provider = viewBinder.getViewProvider(position);
        if (provider.id == -1) {
            provider.id = providers.size();
            //noinspection unchecked
            providers.add(provider);
        }
        return provider.id;
    }

    @NonNull
    @Override
    public ViewHolderWrapper onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
        ViewProvider<?> provider = providers.get(viewType);
        return getViewHolderWrapper(parent, provider);
    }

    @NonNull
    private <VW> ViewHolderWrapper getViewHolderWrapper(ViewGroup parent, ViewProvider<VW> provider) {
        VW viewWrapper = provider.newViewWrapper(parent);
        return new ViewHolderWrapper<>(viewWrapper, provider.getView(viewWrapper, parent));
    }

    @Override
    public void onBindViewHolder(@NonNull ViewHolderWrapper holder, int position) {
        getViewBinder().bind1(holder.getViewWrapper(), position);
    }

    @Override
    public void onViewRecycled(@NonNull ViewHolderWrapper<?> holder) {
        getViewBinder().unbind1(holder.getViewWrapper(), holder.getAdapterPosition());
    }

    @Override
    public int getItemCount() {
        return mWaitForUpdate ? 0 : viewBinder.getCount();
    }

    public final ViewBinder getViewBinder() {
        return viewBinder;
    }

    public final void update() {
        getViewBinder().update();
    }

    public void waitForUpdate() {
        mWaitForUpdate = true;
    }

    public static class ViewHolderWrapper<VW> extends RecyclerView.ViewHolder {

        private VW viewWrapper;

        public ViewHolderWrapper(VW viewWrapper, View view) {
            super(view);

            this.viewWrapper = viewWrapper;
        }

        public VW getViewWrapper() {
            return viewWrapper;
        }
    }

    public static abstract class ViewBinder<VW> {

        private static List<ViewBinder> EMPTY = new ArrayList<>();

        private int offset;

        private List<ViewBinder> binders = EMPTY;
        private RecyclerView.Adapter adapter;

        public ViewBinder(List<ViewBinder> binders) {
            setBinders(binders);
        }

        public ViewBinder(ViewBinder... binders) {
            setBinders(binders);
        }

        public final void setBinders(ViewBinder... providers) {
            this.binders = Arrays.asList(providers);
        }

        public final void setBinders(Collection<ViewBinder> providers) {
            this.binders = new ArrayList<>(providers);
        }

        public ViewBinder<?> getBinder(int position) {
            for (int i = binders.size() - 1; i >= 0; i--) {
                ViewBinder p = binders.get(i);
                if (p.offset <= position) {
                    return p.getBinder(position - p.offset);
                }
            }
            return this;
        }

        public int getCount() {
            int count = 0;
            for (ViewBinder provider : binders) {
                provider.offset = count;
                count += provider.getCount();
            }
            return count;
        }

        @Nullable
        public final void update() {
            DiffUtil.Callback update = onUpdate();
            if (update == null) {
                adapter.notifyDataSetChanged();
                return;
            }
            DiffUtil
                    .calculateDiff(update)
                    .dispatchUpdatesTo(adapter);
        }

        @Nullable
        protected DiffUtil.Callback onUpdate() {
            return null;
        }

        private void bind1(Object viewWrapper, int position) {
            if (binders.isEmpty()) {
                //noinspection unchecked
                bind((VW) viewWrapper, position);
                return;
            }
            ViewBinder binder = getBinder(position);
            binder.bind1(viewWrapper, position - binder.offset);
        }

        private void unbind1(Object viewWrapper, int position) {
            if (binders.isEmpty()) {
                //noinspection unchecked
                unbind((VW) viewWrapper);
                return;
            }
            ViewBinder binder = getBinder(position);
            binder.unbind1(viewWrapper, position - binder.offset);
        }

        private ViewProvider<?> getViewProvider(int position) {
            if (binders.isEmpty()) {
                return getViewProvider();
            }
            //noinspection unchecked
            return getBinder(position).getViewProvider(position);
        }

        protected ViewProvider<VW> getViewProvider() {
            return null;
        }

        protected void bind(VW viewWrapper, int position) {

        }
        protected void unbind(VW viewWrapper) {

        }

        public void attachAdapter(RecyclerView.Adapter adapter) {
            this.adapter = adapter;
        }
    }

    public static abstract class ViewProvider<VW> {

        private int id = -1;

        protected abstract VW newViewWrapper(ViewGroup parent);
        protected abstract View getView(VW vw, ViewGroup parent);
    }
}