package com.basic.security.fragment;

import android.text.TextUtils;

import com.basic.security.model.ModelAdapter;
import com.basic.security.model.Org;
import com.basic.security.model.OrgUI;

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

public class TreeNodeList implements Serializable {
    public List<ModelAdapter> orgList = new ArrayList<>();
    public ModelAdapter selectedOrg = null;
    public int count = 0;
    public Map<String, ModelAdapter> orgIdOrgMap = new HashMap<>();
    Map<String, List<ModelAdapter>> parentIdChildrenMap = new HashMap<>();
    Map<Integer, ModelAdapter> positionOrgMap = new HashMap<>();
    Map<Integer, ModelAdapter> idOrgUIgMap = new HashMap<>();
    Map<String, Integer> orgIdPositionMap = new HashMap<>();

    public TreeNodeList() {
    }

    public TreeNodeList(List<ModelAdapter> orgList, Map<String, List<ModelAdapter>> parentIdChildrenMap) {
        this.orgList = orgList;
        this.parentIdChildrenMap = parentIdChildrenMap;
        reCount();
    }

    public int getCount() {
        return count;
    }

    public void reCount() {
        count = 0;
        positionOrgMap.clear();
        idOrgUIgMap.clear();
        orgIdOrgMap.clear();
        reCount(orgList.get(0));
    }

    public ModelAdapter buildOrgUI(ModelAdapter org) {
        ModelAdapter orgUI = new ModelAdapter();
        orgUI.setString(Org.id, org.getId());
        setUIDefault(org, orgUI);
        return orgUI;
    }

    public void setUIDefault(ModelAdapter org, ModelAdapter orgUI) {
        if (!TextUtils.isEmpty(org.getString(Org.name))) {
            orgUI.setTrue(Org.name);
            orgUI.setFalse(OrgUI.name_selected);
            orgUI.setFalse(Org.edit);
            orgUI.setFalse(Org.add);
            orgUI.setFalse(Org.delete);
            orgUI.setFalse(Org.nameInput);
        } else {
            orgUI.setFalse(Org.name);
            orgUI.setTrue(Org.edit);
            orgUI.setTrue(Org.add);
            orgUI.setTrue(Org.delete);
            orgUI.setTrue(Org.nameInput);
        }
    }

    public boolean setUIFalse(int position, String key) {
        idOrgUIgMap.get(position).setFalse(key);
        return false;
    }

    public boolean setUITrue(int position, String key) {
        idOrgUIgMap.get(position).setTrue(key);
        return true;
    }

    public void setUISelected(int position, String key) {
        clearUI();
        idOrgUIgMap.get(position).setTrue(key);
        selectedOrg = idOrgUIgMap.get(position);
    }

    public void setUISelected(ModelAdapter selectedOrg) {
        if (selectedOrg != null) {
            String orgId = selectedOrg.getString(Org.id);
            if (!TextUtils.isEmpty(orgId)) {
                for (ModelAdapter orgUI : idOrgUIgMap.values()) {
                    if (orgId.equals(orgUI.getString(Org.id))) {
                        orgUI.setTrue(OrgUI.name_selected);
                        this.selectedOrg = selectedOrg;
                        break;
                    }
                }
            }
        }
    }

    public boolean getUIBool(int position, String key) {
        return idOrgUIgMap.get(position).getBool(key);
    }

    public void reCount(ModelAdapter org) {
        boolean expand = org.getBool(Org.expand);
        boolean leaf = org.getBool(Org.leaf);
        positionOrgMap.put(count, org);
        idOrgUIgMap.put(count, buildOrgUI(org));
        orgIdPositionMap.put(org.getString(Org.id), count);
        orgIdOrgMap.put(org.getString(Org.id), org);
        count++;
        if (expand && !leaf) {
            List<ModelAdapter> children = parentIdChildrenMap.get(org.getId());
            for (ModelAdapter child : children) {
                reCount(child);
            }
        }
    }

    public void expand(ModelAdapter treeNode) {
        treeNode.setTrue(Org.expand);
        reCount();
    }

    public void collapse(ModelAdapter treeNode) {
        treeNode.setFalse(Org.expand);
        reCount();
    }

    public ModelAdapter getItem(int position) {
        return positionOrgMap.get(position);
    }

    public void editTrue(int position) {
        clearUI();
        setUITrue(position, Org.edit);
        setUITrue(position, Org.add);
        setUITrue(position, Org.delete);
    }

    public void clearUI() {
        selectedOrg = null;
        for (Map.Entry<Integer, ModelAdapter> entry : idOrgUIgMap.entrySet()) {
            ModelAdapter orgUI = entry.getValue();
            ModelAdapter org = positionOrgMap.get(entry.getKey());
            setUIDefault(org, orgUI);
        }
    }

    public String getFullName(ModelAdapter treeNode) {
        if (treeNode == null) {
            return "";
        }
        List<String> nameList = new ArrayList<>();
        nameList.add(treeNode.getString(Org.name));
        String pid = treeNode.getString(Org.pid);
        while (!"0".equals(pid)) {
            treeNode = orgIdOrgMap.get(pid);
            nameList.add(0, treeNode.getString(Org.name));
            pid = treeNode.getString(Org.pid);
        }
        return TextUtils.join("/", nameList);
    }

    public String getFullName(String orgId) {
        return getFullName(orgIdOrgMap.get(orgId));
    }

    public void setUI(String initOrgId) {
        if (!TextUtils.isEmpty(initOrgId)) {
            for (Map.Entry<Integer, ModelAdapter> entry : idOrgUIgMap.entrySet()) {
                ModelAdapter orgUI = entry.getValue();
                ModelAdapter org = positionOrgMap.get(entry.getKey());
                if (initOrgId.equals(org.getString(Org.id))) {
                    orgUI.setTrue(OrgUI.name_selected);
                } else {
                    orgUI.setFalse(OrgUI.name_selected);
                }
            }
        }
    }

    public TreeNodeList cloneTreeNodeList() {
        TreeNodeList treeNodeList = new TreeNodeList();
        treeNodeList.count = count;
        treeNodeList.parentIdChildrenMap = new HashMap<>();
        treeNodeList.orgIdOrgMap = new HashMap<>();
        treeNodeList.positionOrgMap = new HashMap<>();
        treeNodeList.idOrgUIgMap = new HashMap<>();
        treeNodeList.orgIdPositionMap = new HashMap<>();
        treeNodeList.orgList = new ArrayList<>();
        for (Map.Entry<String, List<ModelAdapter>> entry : parentIdChildrenMap.entrySet()) {
            List<ModelAdapter> newChildren = new ArrayList<>();
            for (ModelAdapter modelAdapter : entry.getValue()) {
                ModelAdapter newChild = modelAdapter.cloneModelAdapter();
                treeNodeList.orgIdOrgMap.put(newChild.getString(Org.id), newChild);
                newChildren.add(newChild);
            }
            treeNodeList.parentIdChildrenMap.put(entry.getKey(), newChildren);
        }
        for (Map.Entry<Integer, ModelAdapter> entry : positionOrgMap.entrySet()) {
            ModelAdapter org = treeNodeList.orgIdOrgMap.get(entry.getValue().getString(Org.id));
            Integer position = entry.getKey();
            treeNodeList.positionOrgMap.put(position, org);
            treeNodeList.orgIdPositionMap.put(org.getString(Org.id), position);
            treeNodeList.idOrgUIgMap.put(position, buildOrgUI(org));
        }
        for (ModelAdapter org : orgList) {
            ModelAdapter newOrg = treeNodeList.orgIdOrgMap.get(org.getString(Org.id));
            treeNodeList.orgList.add(newOrg);
        }
        return treeNodeList;
    }

    public int getSelection(String initOrgId) {
        return orgIdPositionMap.get(initOrgId);
    }
}