package org.telegram.group;

import android.annotation.SuppressLint;
import android.app.Activity;
import android.content.SharedPreferences;
import android.support.annotation.NonNull;
import android.util.Log;

import org.telegram.messenger.ApplicationLoader;
import org.telegram.messenger.MessagesController;
import org.telegram.messenger.UserConfig;
import org.telegram.network.GsonUtils;
import org.telegram.network.RetrofitClient;
import org.telegram.network.error.ErrorConsumer;
import org.telegram.tgnet.TLRPC;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.ObservableSource;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.functions.Consumer;
import io.reactivex.functions.Function;
import io.reactivex.schedulers.Schedulers;

/**
 * 群聊 ViewModel
 */

public class GroupViewModel {
    public static void create(final String groupId, final String title, final int a) {
        Observable.create(new ObservableOnSubscribe<Map<String, String>>() {
            @Override
            public void subscribe(ObservableEmitter<Map<String, String>> observableEmitter) throws Exception {
                TLRPC.User user = MessagesController.getInstance().getUser(UserConfig.getClientUserId());

                HashMap<String, String> map = new HashMap<>();
                map.put("t", "rC7UMgz3BUjxXWy4KQlBzaqO8Y5m7%2FujtA8gpHVELiw%3D");
                map.put("gid", groupId);
                map.put("gn", title);
                map.put("uid", user.id + "");
                map.put("up", user.phone);//手机号码
                @SuppressLint("SimpleDateFormat")
                SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
                map.put("ed", simpleDateFormat.format(new Date()));//时间
                map.put("dt", a == 1 ? "1" : "2");//1:自动解散,2:自由解散
                //第一种方法：
                Iterator iterator = map.entrySet().iterator();
                while (iterator.hasNext()) {
                    Map.Entry entry = (Map.Entry) iterator.next();
                    String value = (String) entry.getValue();
                    String key = (String) entry.getKey();
                    Log.e("siyehua-map", key + " :  " + value);
                }

                observableEmitter.onNext(map);
                observableEmitter.onComplete();
            }
        }).subscribeOn(Schedulers.io()).flatMap(new Function<Map<String, String>, ObservableSource<CreateResponse>>() {
            @Override
            public ObservableSource<CreateResponse> apply(Map<String, String> map) throws Exception {
                return RetrofitClient.getInstance().request(GroupService.class).createGroup(map);
            }
        }).subscribe(new Consumer<CreateResponse>() {
            @Override
            public void accept(CreateResponse o) throws Exception {

            }
        }, new ErrorConsumer() {
            @Override
            public void error(Throwable throwable, @NonNull String message) {
                throwable.printStackTrace();
            }
        });
    }

    /**
     * 查询所有组的状态<br>
     * 作用:<br>1.是否过了到期时间,过了需要判断需不需要删除并退出退(退出两个服务器)<br>
     * 2.查询是否能自主删除(选择非自主删除的不能退出)
     */
    public static void query() {
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> observableEmitter) throws Exception {
                TLRPC.User user = MessagesController.getInstance().getUser(UserConfig.getClientUserId());
                observableEmitter.onNext(user.phone);
            }
        }).subscribeOn(Schedulers.io()).flatMap(new Function<String, ObservableSource<QueryResponse>>() {
            @Override
            public ObservableSource<QueryResponse> apply(String s) throws Exception {
                return RetrofitClient.getInstance().request(GroupService.class).queryGroup(s, "rC7UMgz3BUjxXWy4KQlBzaqO8Y5m7%2FujtA8gpHVELiw%3D");
            }
        }).subscribe(new Consumer<QueryResponse>() {
            @Override
            public void accept(QueryResponse o) throws Exception {
                //保存所有的群组信息
                SharedPreferences.Editor editor = ApplicationLoader.applicationContext
                        .getSharedPreferences("group_from_cctv", Activity.MODE_PRIVATE).edit();
                editor.putString("info", GsonUtils.modeToJsonStr(o)).apply();
            }
        }, new ErrorConsumer() {
            @Override
            public void error(Throwable throwable, @NonNull String message) {
                throwable.printStackTrace();
            }
        });
    }

    /**
     * 检查一个群组是否能退出<br>
     * 1.自由解散则随时能退出 <br>
     * 2.非自由解散,则需要判断其是否过期 <br>
     *
     * @param groupId 组 id
     * @return
     */
    public static Observable<Boolean> checkGroup(final String groupId) {
        return Observable.just(ApplicationLoader.applicationContext
                .getSharedPreferences("group_from_cctv", Activity.MODE_PRIVATE).getString("info", "{}"))
                .subscribeOn(Schedulers.io()).map(new Function<String, List<QueryResponse.AttributesBean.ListBean>>() {
                    @Override
                    public List<QueryResponse.AttributesBean.ListBean> apply(String s) throws Exception {
                        return GsonUtils.jsonToMode(s, QueryResponse.class).getAttributes().getList();
                    }
                }).map(new Function<List<QueryResponse.AttributesBean.ListBean>, Boolean>() {
                    @Override
                    public Boolean apply(List<QueryResponse.AttributesBean.ListBean> listBeans) throws Exception {
                        boolean a = false;
                        for (int i = 0; i < listBeans.size(); i++) {
                            if (listBeans.get(i).getGroupId().equals(groupId)) {
                                if (System.currentTimeMillis() > listBeans.get(i).getExpiredDate()) {
                                    return true;
                                }
                            }
                        }
                        return false;
                    }
                }).observeOn(AndroidSchedulers.mainThread());
    }

    public static void deleteGroup(final String groupId) {
        Observable.create(new ObservableOnSubscribe<Map<String, String>>() {
            @Override
            public void subscribe(ObservableEmitter<Map<String, String>> observableEmitter) throws Exception {
                Map<String, String> map = new HashMap<>();
                map.put("t", "rC7UMgz3BUjxXWy4KQlBzaqO8Y5m7%2FujtA8gpHVELiw%3D");
                map.put("gid", groupId);
                TLRPC.User user = MessagesController.getInstance().getUser(UserConfig.getClientUserId());
                map.put("up", user.phone);
                observableEmitter.onNext(map);
                observableEmitter.onComplete();
            }
        }).subscribeOn(Schedulers.io()).flatMap(new Function<Map<String, String>, ObservableSource<DeleteResponse>>() {
            @Override
            public ObservableSource<DeleteResponse> apply(Map<String, String> map) throws Exception {
                return RetrofitClient.getInstance().request(GroupService.class).deleteGroup(map);
            }
        }).subscribe(new Consumer<DeleteResponse>() {
            @Override
            public void accept(DeleteResponse deleteResponse) throws Exception {

            }
        }, new ErrorConsumer() {
            @Override
            public void error(Throwable throwable, @NonNull String message) {
                throwable.printStackTrace();
            }
        });
    }
}