package com.casic.accessControl.feature.manager;

import com.casic.accessControl.common.CommonEnum;
import com.casic.accessControl.core.hibernate.HibernateEntityDao;
import com.casic.accessControl.core.mapper.JsonMapper;
import com.casic.accessControl.core.page.Page;
import com.casic.accessControl.core.util.StringUtils;
import com.casic.accessControl.feature.domain.Feature;
import com.casic.accessControl.feature.dto.FeatureDto;
import com.casic.accessControl.feature.dto.OrgDto;
import com.casic.accessControl.marker.domain.Marker;
import com.casic.accessControl.marker.manager.MarkerManager;
import com.casic.accessControl.user.domain.Company;
import com.casic.accessControl.user.domain.User;
import com.casic.accessControl.util.DataTable;
import com.casic.accessControl.util.DataTableParameter;
import com.casic.accessControl.util.DataTableUtils;
import org.apache.commons.collections.CollectionUtils;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.criterion.Restrictions;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.jdbc.object.SqlQuery;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * Created by lenovo on 2016/5/16.
 */
@Service
public class FeatureManager extends HibernateEntityDao<Feature> {

    private Logger logger = LoggerFactory.getLogger(this.getClass());
    @Resource
    private MarkerManager markerManager;


    public Feature getFeatureById(Long id) {
        Feature feature = null;
        try {
            Criteria criteria = this.getSession().createCriteria(Feature.class);
            criteria.add(Restrictions.eq("id", id)).add(Restrictions.eq("isValid", 1));
            feature = (Feature) criteria.list().get(0);
        } catch (Exception e) {
            return null;
        }
        return feature;
    }

    public FeatureDto getFeatureDtoById(Long id) {
        return FeatureDto.convert2FeatureDto(getFeatureById(id));
    }

    /**
     * 根据id，软删除某个点或线或片
     * 删除的时候判断是否有标识器或者子节点挂载在本feature上，如果有，则不能删除
     *
     * @param ids 多个id
     */
    @CacheEvict(value = "getOrgList", allEntries = true)
    public String invalidFeature(String ids) {
        if (StringUtils.isBlank(ids) || ids.indexOf(")") != -1) {//未传入值，直接返回，防止无效查询,过滤非法请求，防止sql注入
            return "";
        }
        String[] idsArr = ids.split(",");
        StringBuilder canDeleteIds = new StringBuilder("");
        StringBuilder cantDeleleIds = new StringBuilder("");
        //找出能删除的和不能删除的id组合
        for (String id : idsArr) {
            Long longId = Long.valueOf(id);
            if (this.isCanDelete(longId)) {
                if (canDeleteIds.length() > 0) {
                    canDeleteIds.append(",");
                }
                canDeleteIds.append(id);

            } else {
                if (cantDeleleIds.length() > 0) {
                    cantDeleleIds.append(",");
                }
                cantDeleleIds.append(id);
            }
        }

        String temp1Ids = canDeleteIds.toString();
        String temp2Ids = cantDeleleIds.toString();
        if (StringUtils.isNotBlank(temp2Ids)) {//有不能删除的，都不删除
            return "";
        }
        Query query = this.getSession().createQuery("update Feature f set f.isValid = 0 where id in (" + temp1Ids + ")");
        query.executeUpdate();

        return "success";
    }

    /**
     * 判断feature是否可以删除
     * 删除的时候判断是否有标识器或者子节点挂载在本feature上，如果有，则不能删除
     *
     * @param id
     * @return
     */
    private boolean isCanDelete(Long id) {
        Feature feature = this.getFeatureById(id);
        if (feature.getParent() == null) {//所有用户共用的根节点不能删除
            return false;
        }
        if (CollectionUtils.isNotEmpty(feature.getChildren())) {
            for (Feature child : feature.getChildren()) {
                if (child.isValid() == 1) {
                    return false;
                }
            }

        }
        List<Marker> markers = markerManager.getMarkerByFeature(feature);
        if (CollectionUtils.isNotEmpty(markers)) {
            return false;
        }
        return true;
    }

    /**
     * 将数据库中的feature信息按照参数更新
     *
     * @param feature
     */
    @CacheEvict(value = "getOrgList", allEntries = true)
    public void saveOrupdateFeature(Feature feature, User user) {
        this.getSession().saveOrUpdate(feature);
    }


    /**
     * 获取某组织机构下的特定类型Feature列表
     *
     * @param user 特定的Feature类型
     * @return
     */
//    @Cacheable(value = "getFeaturesByUser")
    public List<FeatureDto> getFeaturesByUser(Integer type, User user) {
        if (user == null) {
            return Collections.emptyList();
        }
        Company company = user.getCompany();
        Criteria criteria = this.getSession().createCriteria(Feature.class);
//        if (user.getRole().getType() != CommonEnum.ROLE_TYPE.ADMIN.getType()) {//是管理员，获取该租户下所有类型
//            criteria.add(Restrictions.eq("owner", user));
//        }
        criteria.add(Restrictions.eq("company", company)).add(Restrictions.eq("type", type));
        criteria.add(Restrictions.eq("isValid", 1));
        List<Feature> features = criteria.list();
        return FeatureDto.convert2FeatureDtos(features);
    }

    /**
     * 分页使用，datatable获取相应type的feature某页数据
     *
     * @param params
     * @param user
     * @return
     */
    public DataTable<FeatureDto> getPageFeatureListByTye(String params, Feature parent, User user) {
        DataTable<FeatureDto> result = new DataTable<FeatureDto>();
        DataTableParameter parameter = DataTableUtils.getDataTableParameterByJsonParam(params);
        int start = parameter.getiDisplayStart();
        int pageSize = parameter.getiDisplayLength();
        int pageNo = (start / pageSize) + 1;
        Criteria criteria = this.createCriteria(Feature.class);
//        if (user.getRole().getType() != CommonEnum.ROLE_TYPE.ADMIN.getType()) {//是管理员，获取该租户下所有类型
//            criteria.add(Restrictions.eq("owner", user));
//        }
        Company company = user.getCompany();
        criteria.add(Restrictions.eq("company", company)).add(Restrictions.eq("isValid", 1)).add(Restrictions.eq("parent", parent));
        Page page = pagedQuery(criteria, pageNo, pageSize);
        List<FeatureDto> featureDtos = FeatureDto.convert2FeatureDtos((List<Feature>) page.getResult());
        result.setAaData(featureDtos);
        result.setiTotalDisplayRecords((int) page.getTotalCount());
        result.setiTotalRecords((int) page.getTotalCount());
        result.setsEcho(parameter.getsEcho());
        return result;


    }

    /**
     * 获取层次结构列表,增加缓存
     *
     * @param type
     * @param company
     * @return
     */
    @Cacheable(value = "getOrgList")
    public String getOrgList(Integer type, Company company) {
        List<OrgDto> orgDtos = new ArrayList<OrgDto>();
        List<Feature> features = this.getRootFeatures(type);
        for (Feature feature : features) {
            orgDtos.add(this.getChildrenByParentId(feature.getId(), company));
        }
        String jsonStr = null;
        try {
            jsonStr = new JsonMapper().toJson(orgDtos);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return jsonStr;
    }

    //    @Cacheable(value = "getChildrenByParentId", key = "#id")
    public OrgDto getChildrenByParentId(Long id, Company company) {
        if (id == null) {
            return null;
        }
        Feature feature = getFeatureById(id);
        if (feature == null) {
            return null;
        }
        //创建OrgDto节点
        OrgDto orgDto = new OrgDto();
        orgDto.setId(id); //保存ID信息
        orgDto.setName(feature.getFeatureName());
        if (feature.getParent() != null) {
            orgDto.setParentId(feature.getParent().getId());
        }
        List<Feature> departments = this.getActiveChildrenOrgs(feature, company);
        for (Feature fea : departments) {
            orgDto.getChildren().add(this.getChildrenByParentId(fea.getId(), company));
        }
        return orgDto;
    }

    //    @Cacheable(value = "getActiveChildrenOrgs", key = "#department.getId()")
    private List<Feature> getActiveChildrenOrgs(Feature department, Company company) {
        List<Feature> features = new ArrayList<Feature>();
        for (Feature feature : department.getChildren()) {
            if (feature.isValid() == 1 && feature.getCompany().getId().equals(company.getId())) {
                features.add(feature);
            }
        }
        return features;
    }


    public List<Feature> getRootFeatures(Integer type) {
        List<Feature> features = null;
        try {
            Criteria criteria = this.getSession().createCriteria(Feature.class);
            criteria.add(Restrictions.eq("type", type)).add(Restrictions.isNull("parent"));
            features = criteria.list();
        } catch (Exception e) {
            return Collections.emptyList();
        }
        return features;

    }


    /**
     * 获取某组织机构下的特定类型Feature列表
     *
     * @param company 特定的Feature类型
     * @return
     */
//    @Cacheable(value = "getFeaturesByCompany", key = "#company.getId()")
    public List<Feature> getFeaturesByCompany(Company company) {
        Criteria criteria = this.getSession().createCriteria(Feature.class);
        criteria.add(Restrictions.eq("company", company));
        criteria.add(Restrictions.eq("isValid", 1));
        List<Feature> features = criteria.list();

        for (Feature f : features) {
            f.getChildren().toString();
            f.getOwner().toString();
            if (f.getParent() != null)
                f.getParent().toString();
        }
        return features;
    }

    /**
     * 根据组织结构的id获取叶子节点
     ***重要：**已更改为包含本节点****
     * @param type
     * @param feature
     * @return
     */
    public List<Feature> getLeafByParentId(Integer type, Feature feature) {
        if (feature == null || feature.isValid() == 0) return Collections.emptyList();
        List<Feature> features = new ArrayList<Feature>();
        if (CollectionUtils.isEmpty(feature.getChildren())) {
            features.add(feature);
            return features;
        }
        List<Feature> children = feature.getChildren();
        boolean flag = false;
        for (Feature child : children) {
            if (child.isValid() == 1) {
                flag = true;
                features.addAll(getLeafByParentId(type, child));
            }
        }
//        if (!flag) {//没有有效的子节点
            features.add(feature);
//        }
        return features;
    }

}