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

import android.text.TextUtils;

import com.basic.security.manager.impl.sqlite.SlPersonIdentityManager;
import com.basic.security.utils.Constants;
import com.couchbase.lite.Expression;
import com.basic.security.model.ModelAdapter;

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

/*人员身份表*/
public class PersonIdentityManager extends BaseManager {

    public static List<ModelAdapter> findPersonIdentityListByPersonId(String personId) {
        if (Constants.useCouchbase) {
            if (TextUtils.isEmpty(personId)) {
                return new ArrayList<>();
            }
            Expression expression = Expression.property("table").equalTo(Expression.string("person_identity")).and(Expression.property("person_id").equalTo(Expression.string(personId)));
            return findList(expression);
        } else {
            return SlPersonIdentityManager.findPersonIdentityListByPersonId(personId);
        }
    }

    public static void deletePersonIdentityByPersonId(String personId) {
        if (Constants.useCouchbase) {
            deleteList(findPersonIdentityListByPersonId(personId));
            Expression expression = Expression.property("table").equalTo(Expression.string("user")).and(Expression.property("person_id").equalTo(Expression.string(personId)));
            List<ModelAdapter> list = BaseManager.findList(expression);
            for (ModelAdapter k : list) {
                try {
                    delete(k);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        } else {
            SlPersonIdentityManager.deletePersonIdentityByPersonId(personId);
        }
    }

    public static void delete(String personId, String ruleId) {
        if (Constants.useCouchbase) {
            try {
                Expression expression = Expression.property("table").equalTo(Expression.string("person_identity"))
                        .and(Expression.property("person_id").equalTo(Expression.string(personId)))
                        .and(Expression.property("identity_id").equalTo(Expression.string(ruleId)));
                delete(findOne(expression));
            } catch (Exception e) {
                e.printStackTrace();
            }
        } else {
            SlPersonIdentityManager.delete(personId,ruleId);
        }
    }

    public static void save(String personId, String ruleId) {
        if (Constants.useCouchbase) {
            ModelAdapter person = new ModelAdapter();
            person.setString("person_id", personId);
            person.setString("identity_id", ruleId);
            person.setString("table", "person_identity");

            person.setString("device_id", DeviceManager.getDeviceId());
            person.setString("company_id", DeviceManager.getCompareId());
            save(person);
        } else {
            SlPersonIdentityManager.save(personId,ruleId);
        }

    }


    public static void saveAdminIdentity(String personId) {
        if (Constants.useCouchbase) {
            Expression expression = Expression.property("table").equalTo(Expression.string("user"))
                    .and(Expression.property("person_id").equalTo(Expression.string(personId)));

            List<ModelAdapter> list = findList(expression);

            if (list.size() > 0) {
                return;
            }

            ModelAdapter admin_user_table = new ModelAdapter()
                    .setString("table", "user")
                    .setString("name", PersonManager.findById(personId).getString("name"))
                    .setString("person_id", personId)
                    .setString("username", "admin")
                    .setString("password", "admin123")
                    .setString("device_id", DeviceManager.getDeviceId())
                    .setString("company_id", DeviceManager.getCompareId());

            save(admin_user_table);
        } else {
            SlPersonIdentityManager.saveAdminIdentity(personId);
        }
    }

    public static void delAdminIdentity(String personId) {
        if (Constants.useCouchbase) {
            Expression expression = Expression.property("table").equalTo(Expression.string("user"))
                    .and(Expression.property("person_id").equalTo(Expression.string(personId)));

            List<ModelAdapter> list = findList(expression);

            for (ModelAdapter d : list) {
                delete(d);
            }
        } else {
            SlPersonIdentityManager.delAdminIdentity(personId);
        }
    }

    public static Map<String, ModelAdapter> findIdentityMapByPersonId(String personId) {
        if (Constants.useCouchbase) {
            Map<String, ModelAdapter> ruleMap = new HashMap();
            List<ModelAdapter> personPersonIdentity = PersonIdentityManager.findPersonIdentityListByPersonId(personId);
            for (ModelAdapter personIdentity : personPersonIdentity) {
                String ruleId = personIdentity.getString("identity_id");
                ruleMap.put(ruleId, findById(ruleId));
            }
            return ruleMap;
        } else {
            return SlPersonIdentityManager.findIdentityMapByPersonId(personId);
        }
    }

    public static List<String> findIdentityNameByPersonId(String personId) {
        if (Constants.useCouchbase) {
            Map<String, ModelAdapter> checkedIdentityMapByPerson = PersonIdentityManager.findIdentityMapByPersonId(personId);
            List<String> ruleNameList = new ArrayList<>();
            for (ModelAdapter identityModelAdapter : checkedIdentityMapByPerson.values()) {
                if (identityModelAdapter != null && !TextUtils.isEmpty(identityModelAdapter.getString("name"))) {
                    ruleNameList.add(identityModelAdapter.getString("name"));
                }
            }

            return ruleNameList;
        } else {
            return SlPersonIdentityManager.findIdentityNameByPersonId(personId);
        }
    }

    public static void savePersonIdentity(ModelAdapter person_identity) {
        if (Constants.useCouchbase) {
            BaseManager.save(person_identity);
        } else {
            SlPersonIdentityManager.savePersonIdentity(person_identity);
        }
    }

}