package com.gh.gamecenter.personal;

import android.content.Context;
import android.support.v4.util.ArrayMap;
import android.support.v7.widget.RecyclerView;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

import com.gh.common.constant.ItemViewType;
import com.gh.common.util.DataCollectionUtils;
import com.gh.common.util.DataUtils;
import com.gh.common.util.DownloadItemUtils;
import com.gh.common.util.GameUtils;
import com.gh.common.util.GameViewUtils;
import com.gh.common.util.PackageUtils;
import com.gh.common.util.PlatformUtils;
import com.gh.common.util.TrafficUtils;
import com.gh.common.view.CardLinearLayout;
import com.gh.download.DownloadManager;
import com.gh.gamecenter.R;
import com.gh.gamecenter.adapter.viewholder.FooterViewHolder;
import com.gh.gamecenter.adapter.viewholder.GameNormalViewHolder;
import com.gh.gamecenter.db.LibaoDao;
import com.gh.gamecenter.db.info.ConcernInfo;
import com.gh.gamecenter.entity.ApkEntity;
import com.gh.gamecenter.entity.GameEntity;
import com.gh.gamecenter.entity.GameInfoEntity;
import com.gh.gamecenter.manager.ConcernManager;
import com.gh.gamecenter.manager.GameManager;
import com.gh.gamecenter.retrofit.Response;
import com.gh.gamecenter.retrofit.RetrofitManager;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import rx.Observable;
import rx.android.schedulers.AndroidSchedulers;
import rx.schedulers.Schedulers;

/**
 * Created by LGT on 2016/8/12.
 * 已安装界面-数据适配器
 */
public class InstallFragmentAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {

    private Context context;

    private ArrayList<GameEntity> gameList;
    private ArrayList<GameInfoEntity> sortedList;

    private int cardMargin;

    //下载用到的map
    private ArrayMap<String, ArrayList<Integer>> locationMap;

    private boolean isRemove;

    private LibaoDao libaoDao;

    public InstallFragmentAdapter(InstallFragment fragment) {
        this.context = fragment.getActivity();

        gameList = new ArrayList<>();
        sortedList = new ArrayList<>();

        locationMap = new ArrayMap<>();

        isRemove = false;

        cardMargin = (int) context.getResources().getDimension(R.dimen.cardview_margin);

        libaoDao = new LibaoDao(context);

        ConcernManager cManager = new ConcernManager(context);
        List<ConcernInfo> runnableGame = cManager.getInstalledGame();
        if (runnableGame.isEmpty()) {
            fragment.loadEmpty();
        } else {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    init();
                    List<String> ids = new ArrayList<>();
                    for (GameInfoEntity info : sortedList) {
                        if (!ids.contains(info.getId())) {
                            ids.add(info.getId());
                        }
                    }
                    initGameList(ids);
                }
            }).start();
        }
    }

    public ArrayList<GameEntity> getGameList() {
        return gameList;
    }

    public ArrayMap<String, ArrayList<Integer>> getLocationMap() {
        return locationMap;
    }

    //初始化
    private void init() {

        ArrayList<GameInfoEntity> list = new ArrayList<>();
        ArrayList<GameInfoEntity> signatureList = new ArrayList<>();   // 是我们签名的游戏
        ArrayList<GameInfoEntity> unsignatureList = new ArrayList<>(); // 不是我们签名的游戏
        ArrayList<GameInfoEntity> noopenList = new ArrayList<>();      // 未打开过的游戏
        ArrayList<GameInfoEntity> oftenuseList = new ArrayList<>();    // 已经打开过的游戏

        TrafficUtils trafficUtils = TrafficUtils.getInstance(context);

        ConcernManager cManager = new ConcernManager(context);
        List<ConcernInfo> runnableGame = cManager.getInstalledGame();
        for (ConcernInfo concernEntity : runnableGame) {
            for (Map.Entry<String, Boolean> entry : concernEntity.getPackageNames().entrySet()) {
                if (entry.getValue()) {
                    GameInfoEntity info = new GameInfoEntity();
                    info.setId(concernEntity.getId());
                    info.setPackageName(entry.getKey());
                    info.setTraffic(trafficUtils.getTraffice(entry.getKey()));
                    info.setSignature(PackageUtils.isSignature(context, entry.getKey()));
                    info.setInstallTime(PackageUtils.getInstalledTime(context, entry.getKey()));
                    list.add(info);
                }
            }
        }

        ArrayMap<String, ArrayList<GameInfoEntity>> map = new ArrayMap<>();
        ArrayList<GameInfoEntity> mList;
        for (int i = 0, size = list.size(); i < size; i++) {
            mList = map.get(list.get(i).getPackageName());
            if (mList == null) {
                mList = new ArrayList<>();
                map.put(list.get(i).getPackageName(), mList);
            }
            mList.add(list.get(i));
        }
        Comparator<GameInfoEntity> comparator = new Comparator<GameInfoEntity>() {
            @Override
            public int compare(GameInfoEntity lhs, GameInfoEntity rhs) {
                return rhs.getId().compareTo(lhs.getId());
            }
        };
        Object gh_id;
        for (String key : map.keySet()) {
            mList = map.get(key);
            if (mList.size() > 1) {
                Collections.sort(mList, comparator);
            }
            if (mList.get(0).isSignature()) {
                gh_id = PackageUtils.getMetaData(context, key, "gh_id");
                for (GameInfoEntity info : mList) {
                    if (gh_id == null || info.getId().equals(gh_id)) {
                        signatureList.add(info);
                        break;
                    }
                }
            } else {
                unsignatureList.add(mList.get(0));
            }
        }

        for (GameInfoEntity info : signatureList) {
            if (info.getTraffic() == 0) {
                noopenList.add(info);
            } else {
                oftenuseList.add(info);
            }
        }

        comparator = new Comparator<GameInfoEntity>() {
            @Override
            public int compare(GameInfoEntity lhs, GameInfoEntity rhs) {
                if (rhs.getInstallTime() > lhs.getInstallTime()) {
                    return 1;
                } else if (rhs.getInstallTime() < lhs.getInstallTime()) {
                    return -1;
                } else {
                    return 0;
                }
            }
        };
        Collections.sort(noopenList, comparator);

        comparator = new Comparator<GameInfoEntity>() {
            @Override
            public int compare(GameInfoEntity lhs, GameInfoEntity rhs) {
                if (rhs.getTraffic() > lhs.getTraffic()) {
                    return 1;
                } else if (rhs.getTraffic() < lhs.getTraffic()) {
                    return -1;
                } else {
                    return 0;
                }
            }
        };
        Collections.sort(oftenuseList, comparator);

        Collections.sort(unsignatureList, comparator);

        sortedList.addAll(noopenList);
        sortedList.addAll(oftenuseList);
        sortedList.addAll(unsignatureList);
    }

    //获取游戏简介
    private void initGameList(List<String> ids) {
        final List<GameEntity> result = new ArrayList<>();

        List<Observable<GameEntity>> sequences = new ArrayList<>();
        for (String id : ids) {
            sequences.add(RetrofitManager.getApi().getGameDigest(id));
        }
        Observable.merge(sequences)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Response<GameEntity>() {
                    @Override
                    public void onNext(GameEntity response) {
                        result.add(response);
                    }

                    @Override
                    public void onCompleted() {
                        processingData(result);
                    }
                });
    }

    private void processingData(List<GameEntity> gameList) {
        if (gameList.size() != 0) {
            for (int i = 0, size = sortedList.size(); i < size; i++) {
                String id = sortedList.get(i).getId();
                for (GameEntity entity : gameList) {
                    if (entity.getId().equals(id)) {
                        GameEntity newEntity = entity.clone();
                        newEntity.setLibaoExists(entity.isLibaoExists());
                        if (newEntity != null && newEntity.getApk().size() > 1) {
                            for (ApkEntity apkEntity : newEntity.getApk()) {
                                if (sortedList.get(i).getPackageName().equals(apkEntity.getPackageName())) {
                                    ArrayList<ApkEntity> list = new ArrayList<>();
                                    list.add(apkEntity);
                                    newEntity.setApk(list);
                                    break;
                                }
                            }
                        }
                        this.gameList.add(newEntity);
                        break;
                    }
                }
            }
            GameManager manager = new GameManager(context);
            for (GameEntity entity : this.gameList) {
                entity.setEntryMap(DownloadManager.getInstance(context).getEntryMap(entity.getName()));
                manager.addOrUpdate(entity.getApk(), entity.getId(), entity.getName());
            }
        }

        if (this.gameList.size() != 0) {
            ArrayMap<String, ArrayList<GameEntity>> map = new ArrayMap<>();
            ArrayList<GameEntity> list;
            for (GameEntity gameEntity : this.gameList) {
                list = map.get(gameEntity.getId());
                if (list == null) {
                    list = new ArrayList<>();
                    map.put(gameEntity.getId(), list);
                }
                list.add(gameEntity);
            }
            list = new ArrayList<>();
            for (String key : map.keySet()) {
                list.addAll(map.get(key));
            }
            this.gameList = list;
            isRemove = true;
            notifyDataSetChanged();

            initLocationMap();
        }
    }

    private void initLocationMap() {
        locationMap.clear();
        GameEntity gameEntity;
        ArrayList<Integer> list;
        for (int i = 0; i < gameList.size(); i++) {
            gameEntity = gameList.get(i);
            if (gameEntity.getApk() != null && gameEntity.getApk().size() != 0) {
                for (ApkEntity apkEntity : gameEntity.getApk()) {
                    list = locationMap.get(apkEntity.getPackageName());
                    if (list == null) {
                        list = new ArrayList<>();
                        locationMap.put(apkEntity.getPackageName(), list);
                    }
                    list.add(i);
                }
            }
        }
    }

    @Override
    public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        if (viewType == ItemViewType.GAME_NORMAL) {
            View view = LayoutInflater.from(parent.getContext()).inflate(
                    R.layout.game_normal_item, parent, false);
            return new GameNormalViewHolder(view);
        } else if (viewType == ItemViewType.LOADING) {
            View view = LayoutInflater.from(parent.getContext()).inflate(
                    R.layout.refresh_footerview, parent, false);
            return new FooterViewHolder(view);
        }
        return null;
    }

    @Override
    public void onBindViewHolder(RecyclerView.ViewHolder holder, int position) {
        if (holder instanceof GameNormalViewHolder) {
            initGameNormal((GameNormalViewHolder) holder, gameList.get(position), position);
        }
    }

    @Override
    public int getItemCount() {
        if (gameList.isEmpty() && !isRemove) {
            return 1;
        }
        if (isRemove) {
            return gameList.size();
        }
        return gameList.size() + 1;
    }

    @Override
    public int getItemViewType(int position) {
        if (gameList.size() != 0 && position >= 0 && position < gameList.size()) {
            return ItemViewType.GAME_NORMAL;
        }
        return ItemViewType.LOADING;
    }

    private void initGameNormal(final GameNormalViewHolder holder, final GameEntity gameEntity, int i) {

        // 第一个
        if (i == 0) {
            ((CardLinearLayout) holder.itemView).setmTop(cardMargin);
        } else {
            ((CardLinearLayout) holder.itemView).setmTop(0);
        }

        // 最后一个
        if (i == gameList.size() - 1) {
            ((CardLinearLayout) holder.itemView).setBottom(true);
        } else {
            ((CardLinearLayout) holder.itemView).setBottom(false);
        }

        holder.gameThumb.setImageURI(gameEntity.getIcon());

        if (libaoDao.isExist(gameEntity.getId())) {
            holder.libaoIcon.setVisibility(View.VISIBLE);
        } else {
            if (gameEntity.isLibaoExists()) {
                holder.libaoIcon.setVisibility(View.VISIBLE);
            } else {
                holder.libaoIcon.setVisibility(View.GONE);
            }
        }

        if (gameEntity.getApk() == null || gameEntity.getApk().isEmpty()
                || gameEntity.getTag() == null || gameEntity.getTag().isEmpty()) {
            holder.gameDes.setText(gameEntity.getBrief());
            holder.gameNameAndSize.setText(gameEntity.getName());
        } else {
            holder.gameNameAndSize.setText(String.format("%s - %s", gameEntity.getName(),
                    PlatformUtils.getInstance(context).getPlatformName(gameEntity.getApk().get(0).getPlatform())));
            holder.gameDes.setText(String.format("V%s", gameEntity.getApk().get(0).getVersion()));
        }
        GameViewUtils.setLabelList(context, holder.labelList, gameEntity.getTag());

        holder.itemView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Map<String, Object> kv = new HashMap<>();
                kv.put("名字", gameEntity.getName());
                kv.put("位置", String.valueOf(holder.getPosition() + 1));
                DataUtils.onEvent(context, "点击", "我的光环-已安装", kv);

                DataCollectionUtils.uploadClick(context, "列表", "我的光环-已安装", gameEntity.getName());

                GameUtils.startGameDetailActivity(context, gameEntity.getId(), "(我的光环-已安装)");
            }
        });

        DownloadItemUtils.setOnClickListener(context, holder.downloadBtn, gameEntity, i,
                this, "(我的光环-已安装)", "我的光环-已安装" + ":" + gameEntity.getName());

        DownloadItemUtils.updateItem(context, holder.gameDes,
                holder.game_progressbar, holder.game_ll_info, holder.download_speed,
                holder.download_percentage, holder.downloadBtn, gameEntity, false);
    }

}