package com.gh.gamecenter.message;

import android.content.Context;
import android.content.Intent;
import android.support.v7.widget.RecyclerView;
import android.support.v7.widget.RecyclerView.ViewHolder;
import android.text.Html;
import android.text.TextUtils;
import android.view.View;
import android.view.ViewGroup;

import com.gh.base.OnRequestCallBackListener;
import com.gh.common.util.CommentUtils;
import com.gh.common.util.EntranceUtils;
import com.gh.common.util.ImageUtils;
import com.gh.common.util.QQUtils;
import com.gh.gamecenter.GameDetailActivity;
import com.gh.gamecenter.NewsDetailActivity;
import com.gh.gamecenter.R;
import com.gh.gamecenter.SubjectActivity;
import com.gh.gamecenter.WebActivity;
import com.gh.gamecenter.adapter.viewholder.FooterViewHolder;
import com.gh.gamecenter.entity.MessageKeFuEntity;
import com.gh.gamecenter.eventbus.EBUISwitch;
import com.gh.gamecenter.retrofit.Response;
import com.gh.gamecenter.retrofit.RetrofitManager;
import com.google.gson.Gson;
import com.lightgame.adapter.BaseRecyclerAdapter;
import com.lightgame.utils.Utils;

import org.greenrobot.eventbus.EventBus;
import org.json.JSONArray;

import java.util.ArrayList;
import java.util.List;

import okhttp3.MediaType;
import okhttp3.RequestBody;
import okhttp3.ResponseBody;
import retrofit2.HttpException;
import rx.android.schedulers.AndroidSchedulers;
import rx.schedulers.Schedulers;

import static com.gh.gamecenter.message.MessageFragment.EB_KEFUMARKREADCOUNT;

/**
 * Created by khy on 2017/4/10.
 * 消息-客服适配器
 */
public class KeFuFragmentAdapter extends BaseRecyclerAdapter<ViewHolder> {


    private OnRequestCallBackListener mCallBackListener;

    private List<MessageKeFuEntity> mKeFuList;

    private List<String> mReceiveIds;

    private int mCurMarkCount;

    private boolean isRemove;
    private boolean isNetworkError;
    private boolean isLoaded;

    public KeFuFragmentAdapter(Context context, OnRequestCallBackListener listener) {
        super(context);
        this.mCallBackListener = listener;

        mReceiveIds = new ArrayList<>();
        mKeFuList = new ArrayList<>();

        mCurMarkCount = 0;
    }

    public void loadData(final int offset) {
        isLoaded = false;
        RetrofitManager.getInstance(mContext).getApi()
                .getMessageKeFuData(offset, 20)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Response<List<MessageKeFuEntity>>() {
                    @Override
                    public void onResponse(List<MessageKeFuEntity> response) {
                        super.onResponse(response);
                        if (response.size() > 0) {
                            for (MessageKeFuEntity keFuEntity : response) {
                                if (!keFuEntity.isReceive()) {
                                    mReceiveIds.add(keFuEntity.getId());
                                }
                            }

                            if (response.size() < 20) {
                                isRemove = true;
                            }

                            if (offset == 0) {
                                mCallBackListener.loadDone();
                            }

                            mKeFuList.addAll(response);
//                            if (!fragment.isHidden() && !fragment.isEverPause()) {
//                                notifyItemRangeInserted(mKeFuList.size() - response.size(), response.size());
//                            } else {
                            notifyDataSetChanged();
//                            }

                            if (mReceiveIds.size() > 0) {
                                postDataReceive();
                            }

                        } else {
                            isRemove = true;
                            if (mKeFuList.size() == 0) {
                                mCallBackListener.loadEmpty();
                            }
                        }

                        isLoaded = true;
                    }

                    @Override
                    public void onFailure(HttpException e) {
                        isLoaded = true;
                        if (offset == 0) {
                            mCallBackListener.loadError();
                        } else {
                            isNetworkError = true;
                            notifyItemChanged(getItemCount() - 1);
                        }
                    }
                });
    }


    private void postDataReceive() {

        String ids = new Gson().toJson(mReceiveIds);
        final RequestBody body = RequestBody.create(MediaType.parse("application/json"), ids);

        RetrofitManager.getInstance(mContext).getApi()
                .postKeFuDataReceive(body)
                .subscribeOn(Schedulers.io())
                .observeOn(Schedulers.io())
                .subscribe(new Response<ResponseBody>() {
                    @Override
                    public void onResponse(ResponseBody response) {
                        super.onResponse(response);
                        mReceiveIds.clear();
                    }

                    @Override
                    public void onFailure(HttpException e) {
                        super.onFailure(e);
                    }
                });
    }

    @Override
    public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        if (viewType == 0) {
            View view = mLayoutInflater.inflate(R.layout.refresh_footerview, parent, false);
            return new FooterViewHolder(view);
        } else {
            View view = mLayoutInflater.inflate(R.layout.message_kefu_item, parent, false);
            return new KeFuViewHolder(view);
        }
    }

    @Override
    public void onBindViewHolder(RecyclerView.ViewHolder holder, int position) {
        if (holder instanceof KeFuViewHolder) {
            MessageKeFuEntity keFuEntity = mKeFuList.get(position);
            KeFuViewHolder viewHolder = (KeFuViewHolder) holder;
            initKeFuViewHolder(viewHolder, keFuEntity, position);
        } else if (holder instanceof FooterViewHolder) {
            FooterViewHolder viewHolder = (FooterViewHolder) holder;
            initFooterViewHolder(viewHolder);
        }

    }

    @Override
    public int getItemViewType(int position) {
        if (position == getItemCount() - 1) {
            return 0;
        } else {
            return 1;
        }
    }

    @Override
    public int getItemCount() {
        if (mKeFuList.size() == 0) {
            return 0;
        }

        return mKeFuList.size() + 1;
    }

    private void initFooterViewHolder(FooterViewHolder viewHolder) {
        viewHolder.initItemPadding();
        if (isNetworkError) {
            viewHolder.loading.setVisibility(View.GONE);
            viewHolder.hint.setText(R.string.loading_failed_retry);
            viewHolder.itemView.setClickable(true);
            viewHolder.itemView.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    isNetworkError = false;
                    notifyItemChanged(getItemCount() - 1);
                    loadData(mKeFuList.size());
                }
            });
        } else if (isRemove) {
            viewHolder.loading.setVisibility(View.GONE);
            viewHolder.hint.setText(R.string.loading_complete);
            viewHolder.itemView.setClickable(false);
            viewHolder.lineLeft.setVisibility(View.VISIBLE);
            viewHolder.lineRight.setVisibility(View.VISIBLE);
        } else {
            viewHolder.loading.setVisibility(View.VISIBLE);
            viewHolder.hint.setText(R.string.loading);
            viewHolder.itemView.setClickable(false);
        }
    }

    private void initKeFuViewHolder(KeFuViewHolder viewHolder, final MessageKeFuEntity keFuEntity, final int position) {
        viewHolder.content.setText(Html.fromHtml(keFuEntity.getMessage()));
        if (!TextUtils.isEmpty(keFuEntity.getSuggestion())) {
            viewHolder.suggestion.setVisibility(View.VISIBLE);
            viewHolder.suggestion.setText(keFuEntity.getSuggestion());
        } else {
            viewHolder.suggestion.setVisibility(View.GONE);
        }

        if (keFuEntity.isRead()) {
            viewHolder.readHint.setVisibility(View.GONE);
        } else {
            viewHolder.readHint.setVisibility(View.VISIBLE);
        }

        if (keFuEntity.getLink() != null && !TextUtils.isEmpty(keFuEntity.getLink().getDocument())) {
            viewHolder.skip.setText(keFuEntity.getLink().getDocument());
            viewHolder.skip.setVisibility(View.VISIBLE);
        } else {
            viewHolder.skip.setVisibility(View.GONE);
        }

        MessageKeFuEntity.ServiceEntity serviceEntity = keFuEntity.getServiceEntity();
        viewHolder.kefuName.setText(R.string.kefu_default_name);
        if (serviceEntity != null) {
            String name = serviceEntity.getName();
            if (!TextUtils.isEmpty(name)) {
                viewHolder.kefuName.setText(name);
            }
            ImageUtils.Companion.display(viewHolder.kefuIcon, serviceEntity.getIcon());
        }

        CommentUtils.setCommentTime(viewHolder.time, keFuEntity.getTime());

        if (!TextUtils.isEmpty(keFuEntity.getSuggestion())) {
            StringBuffer suggest = new StringBuffer();
            suggest.append("反馈原文：");
            suggest.append(keFuEntity.getSuggestion());
            viewHolder.suggestion.setVisibility(View.VISIBLE);
            viewHolder.suggestion.setText(suggest);
        } else {
            viewHolder.suggestion.setVisibility(View.GONE);
        }

        viewHolder.itemView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (keFuEntity.getLink() != null) {
                    onReadControl(keFuEntity, position);
                }
            }
        });

        viewHolder.skip.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (keFuEntity.getLink() == null || keFuEntity.getLink().getType() == null) {
                    Utils.toast(mContext, "数据请求失败");
                    return;
                }
                switch (keFuEntity.getLink().getType()) {
                    case "游戏":
                        if (!TextUtils.isEmpty(keFuEntity.getLink().getId())) {
                            GameDetailActivity.startGameDetailActivity(mContext, keFuEntity.getLink().getId(), "");
                        }
                        break;
                    case "QQ号":
                        if (!TextUtils.isEmpty(keFuEntity.getLink().getQq())) {
                            QQUtils.startQQSession(mContext, keFuEntity.getLink().getQq());
                        }
                        break;
                    case "web":
                        if (!TextUtils.isEmpty(keFuEntity.getLink().getUrl())) {
                            mContext.startActivity(WebActivity.getIntentByUrl(mContext, keFuEntity.getLink().getUrl()));
                        }
                        break;
                    case "QQ群":
                        if (!TextUtils.isEmpty(keFuEntity.getLink().getKey())) {
                            QQUtils.joinQQGroup(mContext, keFuEntity.getLink().getKey());
                        }
                        break;
                    case "新闻":
                        if (!TextUtils.isEmpty(keFuEntity.getLink().getId())) {
                            Intent intent2 = new Intent(mContext, NewsDetailActivity.class);
                            intent2.putExtra(EntranceUtils.KEY_ENTRANCE, "(消息-公告)");
                            intent2.putExtra(EntranceUtils.KEY_NEWSID, keFuEntity.getLink().getId());
                            mContext.startActivity(intent2);
                        }
                        break;
                    case "专题":
                        if (!TextUtils.isEmpty(keFuEntity.getLink().getId())) {
                            SubjectActivity.startSubjectActivity(mContext, keFuEntity.getLink().getId()
                                    , null, false, "(消息-客服)");
                        }
                        break;
                }
                onReadControl(keFuEntity, position);
            }
        });
    }

    private void onReadControl(MessageKeFuEntity keFuEntity, int position) {
        if (!keFuEntity.isRead()) {
            mCurMarkCount++;

            keFuEntity.setRead(true);
            notifyItemChanged(position);
            JSONArray array = new JSONArray();
            array.put(keFuEntity.getId());
            RequestBody body = RequestBody.create(MediaType.parse("application/json"), array.toString());
            postMarkRead(body);
        }

        EventBus.getDefault().post(new EBUISwitch(EB_KEFUMARKREADCOUNT, mCurMarkCount));
    }

    private void postMarkRead(final RequestBody body) {
        RetrofitManager.getInstance(mContext)
                .getApi()
                .postMarkKeFuRead(body)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Response<ResponseBody>() {
                    @Override
                    public void onResponse(ResponseBody response) {
                        super.onResponse(response);

                    }

                    @Override
                    public void onFailure(HttpException e) {
                        super.onFailure(e);
                    }
                });

    }

    public boolean isLoaded() {
        return isLoaded;
    }

    public boolean isRemove() {
        return isRemove;
    }
}