package com.basic.security.manager.impl.cblite;

import android.text.TextUtils;
import android.util.Base64;

import com.basic.security.manager.impl.es.ReadConfig;
import com.basic.security.manager.impl.sqlite.SlBaseManager;
import com.basic.security.manager.impl.sqlite.SlPersonManager;
import com.basic.security.utils.CompareFeatureResult;
import com.basic.security.utils.Constants;
import com.basic.security.utils.FaceId;
import com.basic.security.utils.FastDFSUtil;
import com.basic.security.utils.MutableDocumentUtil;
import com.couchbase.lite.Expression;
import com.basic.security.model.ModelAdapter;
import com.couchbase.lite.Ordering;

import org.androidannotations.api.BackgroundExecutor;
import org.json.JSONArray;
import org.json.JSONObject;
import org.xutils.common.Callback;
import org.xutils.http.RequestParams;
import org.xutils.x;

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

public class PersonManager extends BaseManager {

    public static void savePerson(ModelAdapter personDocument) {
        if (Constants.useCouchbase) {
            save(personDocument);
        } else {
            SlPersonManager.save(personDocument);
        }
        String autoInit = personDocument.getString("auto_init");
        if (TextUtils.isEmpty(autoInit) || "0".equals(autoInit)) {
            uploadToTemporary(personDocument.getId());
        }
    }

    public static void uploadToTemporary(String personId) {
        BackgroundExecutor.execute(new BackgroundExecutor.Task("", 0, "") {
            public void execute() {
                try {
                    ModelAdapter savedPersonDocument = SlPersonManager.findById("person", personId);
                    RequestParams params = new RequestParams("http://"+ReadConfig.getInstance().getTempHost()+":"+ReadConfig.getInstance().getTempPort()+""+ReadConfig.getInstance().getTempUrl()+"");
//                    params.addHeader("Content-Type", "application/json");
                    params.addHeader("Content-Type", "application/json-rpc");
                    JSONArray jsonArray = new JSONArray();
                    JSONObject jsonObject = new JSONObject();
                    if (savedPersonDocument == null) {
                        return;
                    }
                    jsonObject.put("id", savedPersonDocument.getId());
                    jsonObject.put("name", MutableDocumentUtil.getString(savedPersonDocument, "name")); //姓名（可空）
                    jsonObject.put("cardId", MutableDocumentUtil.getString(savedPersonDocument, "id_card_number")); //身份证号（可以不准）
                    jsonObject.put("gender", MutableDocumentUtil.getString(savedPersonDocument, "")); //性别（可空）
                    jsonObject.put("phone", MutableDocumentUtil.getString(savedPersonDocument, "phone")); //手机号（可空）
                    jsonObject.put("distributionIds", MutableDocumentUtil.getString(savedPersonDocument, "")); //集群id（必需）
                    jsonObject.put("distributionNames", MutableDocumentUtil.getString(savedPersonDocument, "")); //集群名称（必需）
                    jsonObject.put("deviceId", DeviceManager.getDeviceId()); //设备id：例如： DSPAD010120181101（类似这种之前统一规定的设备id）
                    String camera_image_fastdfs_path = MutableDocumentUtil.getString(savedPersonDocument, "camera_image_fastdfs_path");
                    if (camera_image_fastdfs_path == null || camera_image_fastdfs_path.length() == 0) {
                        byte[] camera_image_path = savedPersonDocument.getBlob("camera_image_path");
                        if (camera_image_path != null && camera_image_path != null) {
                            String picPath = FastDFSUtil.upLoadVisitorPic(camera_image_path, System.currentTimeMillis());
                            savedPersonDocument.setString("camera_image_fastdfs_path", picPath);
                        }
                    }
                    jsonObject.put("photos", MutableDocumentUtil.getString(savedPersonDocument, "camera_image_fastdfs_path")); //图片的fstdfs路径（必需）
                    byte[] camera_image_feature = savedPersonDocument.getBlob("camera_image_feature");
                    if (camera_image_feature != null && camera_image_feature != null) {
                        jsonObject.put("featureBase64", Base64.encodeToString(camera_image_feature, Base64.NO_WRAP)); //图片的特征值（必需）
                    }
                    jsonArray.put(jsonObject);
                    String bodyJsonContent = jsonArray.toString();
//                    System.out.println("bodyJsonContent=" + bodyJsonContent);
                    params.setBodyContent(bodyJsonContent);
                    params.setAsJsonContent(true);
                    x.http().post(params, new Callback.CommonCallback<String>() {
                        public void onSuccess(String result) {
                            System.out.println("http上传人员成功");
                        }

                        public void onError(Throwable ex, boolean isOnCallback) {
                            ex.printStackTrace();
                            System.out.println("httponError");
                        }

                        public void onCancelled(CancelledException cex) {
                            System.out.println("httponCancelled");
                        }

                        public void onFinished() {
//                            System.out.println("httponFinished");
                        }
                    });
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    /*删除人员*/
    public static void deletePerson(ModelAdapter modelAdapter) {
        if (Constants.useCouchbase) {
            try {
                delete(modelAdapter);
            } catch (Exception e) {
                e.printStackTrace();
            }
        } else {
            SlPersonManager.deletePerson(modelAdapter);
        }
    }

    /**
     * 获取所有人员信息的列表
     */
    public static List<ModelAdapter> getPersonList(String sign_up_status) {
        if (Constants.useCouchbase) {
            List<ModelAdapter> allPersonList = new ArrayList<>();
            Expression expression = Expression.property("table").equalTo(Expression.string("person"));
            expression = expression.and(Expression.property("sign_up_status").equalTo(Expression.string(sign_up_status)));
            //findPage(Expression.booleanValue(true),10,1);
            Ordering[] a = new Ordering[1];
            a[0] = Ordering.property("sign_up_time").descending();
            List<ModelAdapter> documentList = findList(expression, a);
            // 过滤掉不是本设备的系统管理员
            for (ModelAdapter person : documentList) {
                if (!"1".equals(person.getString("auto_init"))
                        || ("1".equals(person.getString("auto_init"))
                        && DeviceManager.getDeviceId().equals(person.getString("device_id")))) {
                    allPersonList.add(person);
                }
            }
            return allPersonList;
        } else {
            return SlPersonManager.getPersonList(sign_up_status);
        }
//        return findList(expression, a);
    }

    public static ModelAdapter findPersonById(String personId) {
        if (Constants.useCouchbase) {
            return findById(personId);// 已经在父类处理空指针的情况
        } else {
            return SlPersonManager.findPersonById(personId);
        }
    }

    // 获取含有特定身份的所有人员
    public static List<ModelAdapter> getIdentityPersonList(List<ModelAdapter> allPersonList, Map<String, ModelAdapter> checkedIdentityMap) {
        if (Constants.useCouchbase) {
            List<ModelAdapter> allPersonIdList = new ArrayList<>();// 获取符合身份的所有人员信息
            List<ModelAdapter> personList = new ArrayList<>();
            Map<String, ModelAdapter> checkedPerson = new HashMap<>();
            personList.clear();
            allPersonIdList.clear();
            checkedPerson.clear();
            // 获取符合身份的所有人员信息
            for (String ruleId : checkedIdentityMap.keySet()) {
                Expression expression = Expression.property("table").equalTo(Expression.string("person_identity"))
                        .and(Expression.property("identity_id").equalTo(Expression.string(ruleId)));
                allPersonIdList.addAll(findList(expression));
            }

            for (int j = 0; j < allPersonList.size(); j++) {
                for (int i = 0; i < allPersonIdList.size(); i++) {
                    if (allPersonList.get(j).getId().equals(allPersonIdList.get(i).getString("person_id"))
                            && !checkedPerson.containsKey(allPersonIdList.get(i).getString("person_id"))) {
                        checkedPerson.put(allPersonIdList.get(i).getString("person_id"), allPersonList.get(j));
                        ModelAdapter personDocument = allPersonList.get(j);
                        if (personDocument != null) {
                            personList.add(personDocument);
                        }
                    }
                }
            }
            return personList;
        } else {
            return SlPersonManager.getIdentityPersonList(allPersonList, checkedIdentityMap);
        }
    }

    public static boolean isDuplicate(ModelAdapter selectedPersonDocument) {
        if (Constants.useCouchbase) {
            try {
                byte[] camera_image_feature = selectedPersonDocument.getBlob("camera_image_feature");
                if (camera_image_feature != null && camera_image_feature != null) {
                    String compareResultStr = FaceId.instance.compareFeatureInDb(camera_image_feature, Constants.minRecognizeScoe);
                    ModelAdapter person = PersonManager.findPersonById(compareResultStr.split(",", -1)[0]);
                    if (person != null) {
                        return true;
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            return false;
        } else {
            return SlPersonManager.isDuplicate(selectedPersonDocument);
        }
    }

    public static void reFindPerson(CompareFeatureResult compareFeatureResult) {
        if (Constants.useCouchbase) {
            try {
                if (compareFeatureResult.person != null) {
                    compareFeatureResult.person = PersonManager.findPersonById(compareFeatureResult.personId);
                }
                if (compareFeatureResult.person == null) {
                    compareFeatureResult.personId = "";
                }
            } catch (Exception e) {
                compareFeatureResult.person = null;
                compareFeatureResult.personId = "";
                e.printStackTrace();
            }
        } else {
            SlPersonManager.reFindPerson(compareFeatureResult);
        }
    }

    // 人员注册时选中的为有效时间内通行,返回的为可以通行的时间规则
    public static List<ModelAdapter> getValidSignUpRuleList(ModelAdapter person) {
        if (Constants.useCouchbase) {
            List<ModelAdapter> checkedTimeRuleList = new ArrayList<>();
            String checked_time_rule_id = person.getString("checked_time_rule_id");
            if (!TextUtils.isEmpty(checked_time_rule_id)) {
                if (TimeRuleManager.timeRuleIsValid(checked_time_rule_id)) {
                    ModelAdapter checked_time_rule = findById(checked_time_rule_id);
                    checkedTimeRuleList.add(checked_time_rule);
                }
            }

            return checkedTimeRuleList;
        } else {
            return SlPersonManager.getValidSignUpRuleList(person);
        }
    }

    // 人员注册时选中的为有效时间内通行,提前多久提示,返回的为可以通行的时间规则
    public static List<ModelAdapter> getValidSignUpRuleListButTimeNotReach(ModelAdapter person) {
        if (Constants.useCouchbase) {
            List<ModelAdapter> checkedTimeRuleList = new ArrayList<>();
            long noReachTime = HintDoorAccessManager.getNoReachTime();
            String checked_time_rule_id = person.getString("checked_time_rule_id");
            if (!TextUtils.isEmpty(checked_time_rule_id)) {
                if (TimeRuleManager.timeRuleIsValid(checked_time_rule_id, noReachTime * 60 * 1000)) {
                    ModelAdapter checked_time_rule = findById(checked_time_rule_id);
                    checkedTimeRuleList.add(checked_time_rule);
                }
            }

            return checkedTimeRuleList;
        } else {
            return SlPersonManager.getValidSignUpRuleListButTimeNotReach(person);
        }
    }

    public static List<ModelAdapter> findPersonList(Expression expression, String sql) {
        if (Constants.useCouchbase) {
            return BaseManager.findList(expression);
        } else {
            return SlBaseManager.findList(sql);
        }
    }
}