package com.product.org.admin.service;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.product.admin.service.OrganizationCacheService;
import com.product.core.cache.DataPoolRefreshCache;
import com.product.core.entity.FieldMetaEntity;
import com.product.module.sys.entity.SystemUser;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import org.apache.commons.lang3.StringUtils;
import com.product.admin.service.UpdateLoginUserInfoService;
import com.product.core.dao.BaseDao;
import com.product.core.entity.DataTableEntity;
import com.product.core.entity.FieldSetEntity;
import com.product.core.exception.BaseException;
import com.product.core.service.support.AbstractBaseService;
import com.product.core.service.support.QueryFilterService;
import com.product.core.spring.context.SpringMVCContextHolder;
import com.product.org.admin.config.CmnConst;
import com.product.org.admin.config.SystemCode;
import com.product.org.admin.util.InternationalLanguage;
import com.product.util.BaseUtil;
import com.product.core.permission.PermissionService;

import java.util.*;
import java.util.Map.Entry;

/**
 * Copyright © 2020 LX-BASE
 *
 * @Title: LX-BASE-SERVER
 * @Project: base-server-org-admin
 * @Date: 2020年6月10日
 * @Author: Mr.Xu
 * @Description:岗位管理Service
 */
@Component
public class SystemPostsService extends AbstractBaseService {

    @Autowired
    public BaseDao dao;
    @Autowired
    PermissionService permissionService;
    @Autowired
    private UpdateLoginUserInfoService updateLoginUserInfoService;
    @Autowired
    public QueryFilterService queryFilterService;
    @Autowired
    public OrganizationCacheService organizationCacheService;

    /**
     * 岗位管理列表
     *
     * @param fse
     * @return
     * @throws BaseException
     */
    public DataTableEntity listPosts(FieldSetEntity fse) throws BaseException {
        // 郑盟 2020年12月22日 下午18:34
        String queryFilter = "";
        if (!BaseUtil.dataTableIsEmpty(fse.getSubDataTable("systemSeniorQueryString"))) {
            queryFilter = " and " + queryFilterService.getQueryFilter(fse);
        }
        // 数据条件
        String dataFilter;
        SystemUser currentUser = SpringMVCContextHolder.getCurrentUser();
        if(1 == currentUser.getUserType()){
//            dataFilter = CmnConst.DEPT_UUID +" = "+ "'"+currentUser.getOrg_level_uuid()+"'";
            dataFilter = CmnConst.DEPT_UUID + " = 1";
        }else {
            fse.setValue(CmnConst.ORG_LEVEL_UUID, currentUser.getOrg_level_uuid());
            dataFilter = permissionService.getDataFilter(CmnConst.ORG_LEVEL_UUID) + " and " + CmnConst.DEPT_UUID + " != 1";
        }

        // 岗位信息
        DataTableEntity dtJobPostInfo = dao.listTable("product_sys_job_posts", dataFilter + queryFilter, new Object[]{},
                new Object[]{}, CmnConst.SEQUENCE, fse.getInteger(CmnConst.PAGESIZE), fse.getInteger(CmnConst.CPAGE));
        // 岗位信息国际化
        // 遍历岗位信息
        if (dtJobPostInfo != null && dtJobPostInfo.getRows() > 0) {
            for (int i = 0; i < dtJobPostInfo.getRows(); i++) {
                FieldSetEntity fseJobPostInfo = dtJobPostInfo.getFieldSetEntity(i);

                String job_post_uuid = fseJobPostInfo.getUUID(); // 岗位uuid
                String dept_uuid = fseJobPostInfo.getString("dept_uuid"); // 所属部门

                // 获取岗位对应岗位等级
                DataTableEntity dtPostGrade = dao.listTable("product_sys_job_posts_grades_mapping", "job_post_uuid=?",
                        new Object[]{job_post_uuid});
                StringBuilder job_post_grades = new StringBuilder();
                forDtPostGrade(dtPostGrade, job_post_grades);
                // 装载人员数量
                DataTableEntity staffsNum = dao.listTable("product_sys_staffs", "job_post_uuid=?",
                        new Object[]{job_post_uuid});
                fseJobPostInfo.setValue("staffs_number", staffsNum == null ? 0 : staffsNum.getRows());
                if(1 == currentUser.getUserType()){
                    continue;
                }
                // 装载岗位等级
                fseJobPostInfo.setValue("job_post_grades", job_post_grades);

                // 获取部门信息
                FieldSetEntity fseDeptInfo = dao.getFieldSetEntity(CmnConst.PRODUCT_SYS_ORG_LEVELS, dept_uuid, false);
                if (fseDeptInfo == null) {
                    throw new BaseException(SystemCode.SYSTEM_GET_DEPARTMENTINFO_FAIL.getValue(), SystemCode.SYSTEM_GET_DEPARTMENTINFO_FAIL.getText());
                }
                FieldSetEntity fseDeptLanguage = dao.listInternationDataTable(fseDeptInfo, null);

                // 获取部门国际化全称
                Map<String, String> deptAllLanguage = InternationalLanguage
                        .parseLanguage(fseDeptLanguage.getSubDataTable(CmnConst.ORG_LEVEL_ALL));

                // 获取客户信息
                FieldSetEntity fseClientInfo = dao.getFieldSetEntity(CmnConst.PRODUCT_SYS_CLIENTS,
                        fseDeptInfo.getString("client_uuid"), false);
                if (fseClientInfo == null) {
                    throw new BaseException(SystemCode.GET_CLINET_FIAL.getValue(), SystemCode.GET_CLINET_FIAL.getText());
                }
                FieldSetEntity fseClientLanguage = dao.listInternationDataTable(fseClientInfo, null);

                // 获取部门国际化名称
                Map<String, String> clientNameLanguage = InternationalLanguage
                        .parseLanguage(fseClientLanguage.getSubDataTable(CmnConst.CLIENT_NAME));

                Map<String, DataTableEntity> international = new HashMap<>();

                // 创建国际化信息
                DataTableEntity dtInternational = new DataTableEntity();
                FieldMetaEntity fseMate = new FieldMetaEntity();
                fseMate.setTableName(new Object[]{"dept_all"});

                // 遍历客户名称国际化
                forClientNameLanguage(clientNameLanguage, deptAllLanguage, dtInternational);
                international.put("dept_all", dtInternational);

                // 装载全路径
                fseJobPostInfo.setSubData(international);
            }
        }
        DataTableEntity dtJobPostLanguage = dao.listInternationDataTable(dtJobPostInfo, null);
        dao.loadPromptData(dtJobPostLanguage);

        return dtJobPostLanguage;
    }

    private void forDtPostGrade(DataTableEntity dtPostGrade, StringBuilder job_post_grades) {
        if (dtPostGrade.getRows() > 0) {
            for (int j = 0; j < dtPostGrade.getRows(); j++) {
                FieldSetEntity fsePostGradeInfo = dtPostGrade.getFieldSetEntity(j);
                job_post_grades.append(fsePostGradeInfo.getUUID());
                if (j != dtPostGrade.getRows() - 1) {
                    job_post_grades.append(",");
                }
            }
        }
    }

    private void forClientNameLanguage(Map<String, String> clientNameLanguage, Map<String, String> deptAllLanguage,
                                       DataTableEntity dtInternational) {

        if (clientNameLanguage == null) {
            return;
        }
        for (Entry<String, String> clientNameLanguageMap : clientNameLanguage.entrySet()) {
            String languageCode = clientNameLanguageMap.getKey();
            String languageClientName = clientNameLanguageMap.getValue();

            if (deptAllLanguage != null) {
                String languageDeptAll = deptAllLanguage.get(languageCode);
                FieldSetEntity fseLanguage = new FieldSetEntity();
                fseLanguage.setTableName("dept_all");
                fseLanguage.setValue(languageCode, languageClientName + ">" + languageDeptAll);
                dtInternational.addFieldSetEntity(fseLanguage);
            } else {
                FieldSetEntity fseLanguage = new FieldSetEntity();
                fseLanguage.setTableName("dept_all");
                fseLanguage.setValue(languageCode, languageClientName);
                dtInternational.addFieldSetEntity(fseLanguage);
            }

        }
    }

    /**
     * 岗位详情
     *
     * @param fse
     * @return
     * @throws BaseException
     */
    public FieldSetEntity findPost(FieldSetEntity fse) throws BaseException {
        FieldSetEntity fs = dao.getFieldSetEntity(fse.getTableName(), fse.getString(CmnConst.UUID), false);
        DataTableEntity dt2 = dao.listTable("product_sys_job_posts_grades_mapping", "job_post_uuid=?",
                new String[]{fs.getString("uuid")});
        StringBuilder grade_uuids = new StringBuilder();
        if (dt2.getRows() > 0) {
            for (int j = 0; j < dt2.getRows(); j++) {
                FieldSetEntity fs2 = dt2.getFieldSetEntity(j);
                grade_uuids.append(fs2.getString("job_grade_uuid"));
                if (j + 1 < dt2.getRows() && dt2.getFieldSetEntity(j + 1) != null) {
                    grade_uuids.append(",");
                }
            }
        }
        fs.setValue("job_post_grades", grade_uuids);
        // xu pengcheng updateTime 2020-11-28 14:33:18 删除手动国际化代码

        // 杜洪波 updatetime 2020-12-08 17:19:00 岗位详情封装使用人数
        DataTableEntity postToStaff = dao.listTable(CmnConst.PRODUCT_SYS_STAFFS, "job_post_uuid=?",
                new Object[]{fse.getString(CmnConst.UUID)});
        if (BaseUtil.dataTableIsEmpty(postToStaff)) {
            fs.setValue("staffs_number", 0);
        } else {
            fs.setValue("staffs_number", postToStaff.getRows());
        }

        return dao.listInternationDataTable(fs, null);
    }

    /**
     * 新增岗位
     *
     * @param fse
     * @return
     * @throws BaseException
     */
    public String addPost(FieldSetEntity fse) throws BaseException {
        FieldSetEntity post = findPostByAdd(fse);
        if (post != null && !StringUtils.isEmpty(post.getUUID())) {
            throw new BaseException(SystemCode.SYSTEM_POST_EXIST_DEPT_ADD_FAIL.getValue(),
                    SystemCode.SYSTEM_POST_EXIST_DEPT_ADD_FAIL.getText());
        }
        fse = BaseUtil.createCreatorAndCreationTime(SpringMVCContextHolder.getCurrentUser(), fse);
        FieldSetEntity fs = fse;
        fs.remove("job_post_grades");
        fs.setValue("org_level_uuid", SpringMVCContextHolder.getCurrentUser().getOrg_level_uuid());
        String uuid = dao.add(fs);
        String job_post_grades = fse.getString("job_post_grades");
        if(!BaseUtil.strIsNull(job_post_grades)){
            String[] grades = job_post_grades.split(",");
            for (int i = 0; i < grades.length; i++) {
                FieldSetEntity fsg = new FieldSetEntity();
                FieldMetaEntity f = new FieldMetaEntity();
                f.setTableName(new Object[]{"product_sys_job_posts_grades_mapping"});
                fsg.setMeta(f);
                fsg.setValue("job_post_uuid", uuid);
                fsg = BaseUtil.createCreatorAndCreationTime(SpringMVCContextHolder.getCurrentUser(), fsg);
                String grade_uuid = grades[i];
                fsg.setValue("job_grade_uuid", grade_uuid);
                dao.add(fsg);
            }
        }
        return uuid;
    }

    /**
     * 查重
     */
    public FieldSetEntity findPostByAdd(FieldSetEntity fse) throws BaseException {
        fse = BaseUtil.createCreatorAndCreationTime(SpringMVCContextHolder.getCurrentUser(), fse);
        return dao.getFieldSetEntityByFilter(
                "product_sys_job_posts", "job_post_name=? and org_level_uuid=? and dept_uuid=?", new String[]{
                        fse.getString("job_post_name"), fse.getString("org_level_uuid"), fse.getString("dept_uuid")},
                false);
    }

    /**
     * 修改岗位
     *
     * @param fse
     * @return
     * @throws BaseException
     */
    public boolean updatePost(FieldSetEntity fse) throws BaseException {
        FieldSetEntity fieldSetEntity = dao.getFieldSetEntity(fse.getTableName(), fse.getString(CmnConst.UUID), false);
        String job_post_grades = fse.getString("job_post_grades");
        // 验证岗位等级是否被删除，如有被删除的验证员工是否引用了此岗位
        verifPostGrades(job_post_grades, fse);
        // 验证是否修改所属部门
        if (!fieldSetEntity.getString("dept_uuid").equals(fse.getString("dept_uuid"))) {
            boolean verifyPostExistStaffs = verifyPostExistStaffs(fse.getString(CmnConst.UUID));
            if (verifyPostExistStaffs) {
                throw new BaseException(SystemCode.SYSTEM_POSTS_UPDATE_EXIST_STAFF_FAIL.getValue(),
                        SystemCode.SYSTEM_POSTS_UPDATE_EXIST_STAFF_FAIL.getText(), this.getClass(), "updatePost");
            }
        }
        fse = BaseUtil.createCreatorAndCreationTime(SpringMVCContextHolder.getCurrentUser(), fse);
        DataTableEntity grades_mapping = dao.listTable("product_sys_job_posts_grades_mapping", "job_post_uuid=?",
                new String[]{fse.getUUID()});
        List<String> list = new ArrayList<>();
        if (grades_mapping.getRows() > 0) {
            for (int i = 0; i < grades_mapping.getRows(); i++) {
                FieldSetEntity fss = grades_mapping.getFieldSetEntity(i);
                list.add(fss.getString("job_grade_uuid"));
            }
        }
        addDelGrade(fse, list);
        fse.remove("job_post_grades");
        // xupengcheng dateTime 2020年11月28日14:35:21 修改岗位更新所属岗位人员信息
        updateLoginUserInfoService.updateUserInfoByPostUuid(fse.getUUID(), true);
        return dao.update(fse);
    }

    private void verifPostGrades(String job_post_grades, FieldSetEntity fse) {
        if (!StringUtils.isEmpty(job_post_grades)) {
            String newjob_post_grades = fse.getString("job_post_grades");
            String[] job_post_grade = job_post_grades.split(",");
            StringBuilder uuids = new StringBuilder();
            appendUuids(newjob_post_grades, job_post_grade, uuids, job_post_grades);
            if (uuids.length() != 0) {
                String uuidString = uuids.toString().substring(1);
                String sql = "select * from " + CmnConst.PRODUCT_SYS_STAFFS + " where job_post_grade_uuid in ('"
                        + uuidString.replace(",", "','") + "')";
                DataTableEntity listTable = dao.listTable(sql, new Object[]{});
                if (listTable != null && listTable.getRows() > 0)
                    throw new BaseException(SystemCode.SYSTEM_POSTS_DELETE_EXIST_POST_GRAGES_FAIL.getValue(),
                            SystemCode.SYSTEM_POSTS_DELETE_EXIST_POST_GRAGES_FAIL.getText(), this.getClass(),
                            "updatePost");
            }
        }
    }

    private void appendUuids(String newjob_post_grades, String[] job_post_grade, StringBuilder uuids,
                             String job_post_grades) {
        if (!StringUtils.isEmpty(newjob_post_grades)) {
            String[] newjob_post_grade = newjob_post_grades.split(",");
            for (int i = 0; i < job_post_grade.length; i++) {
                boolean is_exist = false;
                for (int j = 0; j < newjob_post_grade.length; j++) {
                    if (job_post_grade[i].equals(newjob_post_grade[j])) {
                        is_exist = true;
                        break;
                    }
                }
                if (!is_exist) {
                    uuids.append(",");
                    uuids.append(job_post_grade[i]);
                }
            }
        } else {
            // 改变 等于空
            uuids.append(",");
            uuids.append(job_post_grades);
        }
    }

    private void addDelGrade(FieldSetEntity fse, List<String> list) {
        // 前台等级
        String[] grade_view = fse.getString("job_post_grades").split(",");
        // 数据库等级
        List<String> list_view = Arrays.asList(grade_view);
        // 新增等级
        for (int i = 0; i < grade_view.length; i++) {
            String grade_v = grade_view[i];
            if (list.contains(grade_v)) {
                continue;
            } else {
                FieldSetEntity fs = new FieldSetEntity();
                fs.setTableName("product_sys_job_posts_grades_mapping");
                fs.setValue("job_post_uuid", fse.getString("uuid"));
                fs.setValue("job_grade_uuid", grade_v);
                fs = BaseUtil.createCreatorAndCreationTime(SpringMVCContextHolder.getCurrentUser(), fs);
                dao.add(fs);
            }
        }
        // 删除等级
        for (int i = 0; i < list.size(); i++) {
            String grade_v = list.get(i);
            if (list_view.contains(grade_v)) {
                continue;
            } else {
                FieldSetEntity fsd = dao.getFieldSetEntityByFilter("product_sys_job_posts_grades_mapping",
                        "job_post_uuid=? and job_grade_uuid=?", new String[]{fse.getString("uuid"), grade_v}, false);
                dao.delete("product_sys_job_posts_grades_mapping", "uuid=?", new String[]{fsd.getString("uuid")});
            }
        }
    }

    /**
     * 查询岗位是否有关联员工
     *
     * @param post_uuid
     * @return
     * @throws BaseException
     */
    private boolean verifyPostExistStaffs(String post_uuid) throws BaseException {
        DataTableEntity listTable = dao.listTable(CmnConst.PRODUCT_SYS_STAFFS, "job_post_uuid=?",
                new Object[]{post_uuid});
        if (!BaseUtil.dataTableIsEmpty(listTable))
            return true;
        return false;
    }

    /**
     * 删除岗位
     *
     * @param fse
     * @return
     * @throws BaseException
     */
    public boolean deletePost(FieldSetEntity fse) throws BaseException {
        boolean verifyPostExistStaffs = verifyPostExistStaffs(fse.getString(CmnConst.UUID));
        if (verifyPostExistStaffs) {
            throw new BaseException(SystemCode.SYSTEM_POSTS_DELETE_EXIST_STAFF_FAIL.getValue(),
                    SystemCode.SYSTEM_POSTS_DELETE_EXIST_STAFF_FAIL.getText(), this.getClass(), "deletePost");
        }
        DataTableEntity dt = dao.listTable("product_sys_job_posts_grades_mapping", "job_post_uuid=?",
                new String[]{fse.getUUID()});
        if (dt.getRows() > 0) {
            for (int i = 0; i < dt.getRows(); i++) {
                FieldSetEntity fs = dt.getFieldSetEntity(i);
                dao.delete("product_sys_job_posts_grades_mapping", "uuid=?", new String[]{fs.getString("uuid")});
            }
        }
        return dao.delete(fse.getTableName(), new String[]{fse.getString(CmnConst.UUID)});
    }

    // 数据迁移
    public Boolean movePost() throws BaseException {
        DataTableEntity dt = dao.listTable("product_sys_job_posts");
        if (dt.getRows() > 0) {
            for (int i = 0; i < dt.getRows(); i++) {
                FieldSetEntity fs = dt.getFieldSetEntity(i);
                String[] job_post_grades = fs.getString("job_post_grades").split(",");
                for (int j = 0; j < job_post_grades.length; j++) {
                    String job_post_grade = job_post_grades[j];
                    FieldSetEntity fsd = new FieldSetEntity();
                    fsd.setTableName("product_sys_job_posts_grades_mapping");
                    fsd.setValue("job_post_uuid", fs.getString("uuid"));
                    fsd.setValue("job_grade_uuid", job_post_grade);
                    fsd.setValue("created_by", fs.getString("created_by"));
                    fsd.setValue("created_utc_datetime", fs.getString("created_utc_datetime"));
                    dao.add(fsd);
                }
            }
            return true;
        }
        return false;
    }

    /**
     * 获取通用岗位
     * @param fse
     * @return
     */
    public DataTableEntity getGeneralPostName(FieldSetEntity fse){
        DataTableEntity dataTableEntity = dao.listTable(" SELECT * FROM product_sys_job_posts WHERE LENGTH(dept_uuid) < 16 ",new String[]{},fse.getInteger(CmnConst.PAGESIZE),fse.getInteger(CmnConst.CPAGE));
        return dataTableEntity;
    }

    public Boolean addGeneralPostName(FieldSetEntity fse){
        //获取org_level_uuid
        String orgLevelUuid = SpringMVCContextHolder.getCurrentUser().getOrg_level_uuid();
        Integer userId = SpringMVCContextHolder.getCurrentUser().getUser_id();
        FieldSetEntity sqlFse = dao.getFieldSetBySQL(" SELECT MAX(sequence) maxSequence FROM product_sys_job_posts ", new String[]{},false);
        String maxSequence = sqlFse.getString("maxSequence");
        Integer indexNum = 0;
        if(!BaseUtil.strIsNull(maxSequence)){
            indexNum = Integer.parseInt(maxSequence);
        }
        //岗位名称集
        String[] job_post_name = fse.getString("job_post_names").split(",");
        //部门元素集
        String dept = fse.getString("dept");
        JSONArray deptArray = JSONArray.parseArray(dept);
        DataTableEntity dataTableEntity = new DataTableEntity();
        FieldMetaEntity f = new FieldMetaEntity();
        f.setTableName(new String[]{ "product_sys_job_posts" });
        dataTableEntity.setMeta(f);
            for (int j = 0; j < job_post_name.length; j++) {
                contDept:
                for (int i = 0; i < deptArray.size(); i++) {
                    JSONObject deptObject = deptArray.getJSONObject(i);
                    JSONArray children = deptObject.getJSONArray("children");
                    //下面没有岗位
                    if(children != null && children.size() > 0){
                        for (int k = 0; k < children.size(); k++) {
                            JSONObject postObject = children.getJSONObject(k);
                            if(job_post_name[j].equals(postObject.getString("label"))){
                                //相同就不添加岗位
                                continue contDept;
                            }
                        }
                    }
                    indexNum ++;
                    FieldSetEntity fieldSetEntity = new FieldSetEntity();
                    fieldSetEntity.setTableName("product_sys_job_posts");
                    fieldSetEntity.setValue("org_level_uuid",orgLevelUuid);
                    fieldSetEntity.setValue("job_post_description",job_post_name[j]);
                    fieldSetEntity.setValue("is_used",1);
                    fieldSetEntity.setValue("sequence",indexNum);
                    fieldSetEntity.setValue("dept_uuid",deptObject.getString("value"));
                    fieldSetEntity.setValue("job_post_name",job_post_name[j]);
                    fieldSetEntity.setValue("created_by" ,userId);
                    fieldSetEntity.setValue("created_utc_datetime" , new Date());
                    dataTableEntity.addFieldSetEntity(fieldSetEntity);
                }
            }
            if(dataTableEntity.getRows() == 0){
                throw new BaseException(SystemCode.SYSTEM_POST_EXIST_DEPT_ADD_FAIL.getValue(), SystemCode.SYSTEM_POST_EXIST_DEPT_ADD_FAIL.getText());
            }
        Boolean flag = dao.add(dataTableEntity);
            //刷新岗位缓存
//        organizationCacheService.cachePost(null);
        //更新缓存数据-------------------------------------------
//        DataPoolRefreshCache.getInstance().put("product_sys_job_posts");
        return flag;
    }
}