package com.ibeetl.jlw.service;


import cn.hutool.core.lang.Assert;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.extra.spring.SpringUtil;
import cn.hutool.extra.validation.BeanValidationResult;
import cn.hutool.extra.validation.ValidationUtil;
import com.alibaba.fastjson.JSONObject;
import com.ibeetl.admin.console.service.OrgConsoleService;
import com.ibeetl.admin.core.entity.CoreOrg;
import com.ibeetl.admin.core.entity.CoreUser;
import com.ibeetl.admin.core.service.CoreBaseService;
import com.ibeetl.admin.core.service.CorePlatformService;
import com.ibeetl.admin.core.service.CoreUserService;
import com.ibeetl.jlw.dao.UniversitiesCollegesDao;
import com.ibeetl.jlw.entity.*;
import com.ibeetl.jlw.entity.dto.CreateUserDTO;
import com.ibeetl.jlw.util.BxJDBCUtil;
import com.ibeetl.jlw.util.HttpJsonRequest;
import com.ibeetl.jlw.web.query.SchoolClassQuery;
import com.ibeetl.jlw.web.query.UniversitiesCollegesQuery;
import jodd.http.HttpUtil;
import org.beetl.sql.core.SqlId;
import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.core.query.LambdaQuery;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;

import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
import java.sql.*;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import static cn.hutool.core.collection.CollUtil.getFirst;
import static com.aspose.pdf.printing.PrinterPaperKind.Statement;
import static com.ibeetl.admin.core.enums.MenuEnums.JT_01;
import static com.ibeetl.admin.core.enums.MenuEnums.JT_S_04;
import static com.ibeetl.admin.core.util.user.CacheUserUtil.getUser;

/**
 * UniversitiesColleges Service
 */

@Service
@Transactional
@Validated
public class UniversitiesCollegesService extends CoreBaseService<UniversitiesColleges> {

    @Autowired
    private UniversitiesCollegesDao universitiesCollegesDao;

    @Autowired
    private SchoolClassService schoolClassService;
    @Autowired
    private OrgConsoleService orgConsoleService;
    @Autowired
    private CoreUserService coreUserService;
    @Autowired
    private WebPlatformService webPlatformService;
    @Autowired
    private CorePlatformService corePlatformService;
    @Autowired
    private SysLogService sysLogService;

    public PageQuery<UniversitiesColleges> queryByCondition(PageQuery query) {
        PageQuery ret = universitiesCollegesDao.queryByCondition(query);
        queryListAfter(ret.getList());
        return ret;
    }

    public void deleteUniversitiesColleges(String ids) {
        universitiesCollegesDao.deleteUniversitiesCollegesByIds(ids);

        for (int i = 0; i < ids.split(",").length; i++) {
            final UniversitiesColleges universitiesColleges = this.queryById(Long.parseLong(ids.split(",")[i]));
            Long orgId = universitiesColleges.getOrgId();

            {
                CoreOrg coreOrg = new CoreOrg();
                coreOrg.setId(orgId);
                coreOrg.setName(universitiesColleges.getUniversitiesCollegesName());
                coreOrg.setCode("u_" + universitiesColleges.getUniversitiesCollegesId());
                coreOrg.setDelFlag(((Integer) 1).equals(universitiesColleges.getUniversitiesCollegesStatus()) ? 0 : 1);
                orgConsoleService.updateTemplate(coreOrg);
            }

            // 标记删除用户
            {
                CoreUser query = new CoreUser();
                query.setOrgId(orgId);
                List<CoreUser> coreUserList = coreUserService.getCoreUserList(query);

                List<CoreUser> upList = coreUserList.stream().map(item -> {
                    CoreUser user = new CoreUser();
                    user.setId(item.getId());
                    user.setCode("del_" + item.getCode());
                    user.setDelFlag(((Integer) 1).equals(universitiesColleges.getUniversitiesCollegesStatus()) ? 0 : 1);
                    return user;
                }).collect(Collectors.toList());

                coreUserService.updateBatchTemplate(upList);
            }
        }
        corePlatformService.clearDictCache();
    }

    public boolean add(UniversitiesColleges universitiesColleges) {

        universitiesCollegesDao.insert(universitiesColleges);
        CoreOrg coreOrg = new CoreOrg();
        coreOrg.setName(universitiesColleges.getUniversitiesCollegesName());
        coreOrg.setCode("u_" + universitiesColleges.getUniversitiesCollegesId());
        coreOrg.setType("ORGT1");
        coreOrg.setParentOrgId(1L);
        coreOrg.setDelFlag(0);
        coreOrg.setCreateTime(new Date());
        orgConsoleService.insert(coreOrg);

        // 机构ID
        universitiesColleges.setOrgId(coreOrg.getId());

        UniversitiesColleges u = new UniversitiesColleges();
        u.setUniversitiesCollegesId(universitiesColleges.getUniversitiesCollegesId());
        u.setOrgId(coreOrg.getId());
        // 三位数字+三个小写字母. 组成的授权动态码
        u.setUniversitiesCollegesAuthCode(RandomUtil.randomString(6));
        u.setOldSchoolId(universitiesColleges.getUniversitiesCollegesId() + 500);
        universitiesCollegesDao.updateTemplateById(u);

        universitiesColleges.setUniversitiesCollegesAuthCode(u.getUniversitiesCollegesAuthCode());

        corePlatformService.clearDictCache();
        return true;
    }

    /**
     * 添加院校信息，添加机构信息，修改院校的授权码
     * 默认创建院校管理员权限的用户
     *
     * @param universitiesColleges
     * @param dto
     */
    public void addAndCreateCoreUser(UniversitiesColleges universitiesColleges, CreateUserDTO dto) {
        // 添加院校信息，添加机构信息，修改院校的授权码
        add(universitiesColleges);
        // 验证 javax.validation.constraints注解
        BeanValidationResult beanValidationResult = ValidationUtil.warpValidate(dto);

        // 验证通过，代表是要创建院校管理员身份的用户。
        // 这里不抛出异常，如果没有验证通过，则不新增用户
        if (beanValidationResult.isSuccess()) {
            // 默认创建院校管理员权限的用户
            Long defaultAdminUserId = webPlatformService.createUserWithRole(dto.getUserCode(), dto.getPassword(), universitiesColleges.getOrgId(), JT_01, JT_S_04);

            //保险系统同步新增学校数据
            String schoolName = universitiesColleges.getUniversitiesCollegesName();
            int icibtSchoolId = createBxSchool(schoolName);
            if (icibtSchoolId == 0) throw new IllegalArgumentException("新增院校异常");
            // 用户添加成功后，将用户ID 回传给该学校的默认管理员字段

            UniversitiesColleges u = new UniversitiesColleges();
            u.setUniversitiesCollegesId(universitiesColleges.getUniversitiesCollegesId());
            u.setUniversitiesCollegesDefaultAdminUserId(defaultAdminUserId);
            u.setIcibtSchoolId(icibtSchoolId);
            universitiesCollegesDao.updateTemplateById(u);
        }

        corePlatformService.clearDictCache();
    }

    private int createBxSchool(String schoolName) {
        String request = HttpJsonRequest.sendPostRequest("http://120.79.161.177:8183/SignIn/AddSchool", null, "{'SchoolName':'" + schoolName + "'}", "application/json");
        JSONObject jsonObject = JSONObject.parseObject(request);
        String schoolId = jsonObject.getString("schoolId");
        if(schoolId!=null){
            return Integer.parseInt(schoolId);
        }else{
            return 0;
        }
    }

    public boolean edit(UniversitiesColleges universitiesColleges) {

        universitiesCollegesDao.updateTemplateById(universitiesColleges);

        universitiesColleges = this.queryById(universitiesColleges.getUniversitiesCollegesId());

        CoreOrg coreOrg = new CoreOrg();
        coreOrg.setId(universitiesColleges.getOrgId());
        coreOrg.setName(universitiesColleges.getUniversitiesCollegesName());
        coreOrg.setCode("u_" + universitiesColleges.getUniversitiesCollegesId());
        coreOrg.setDelFlag(((Integer) 1).equals(universitiesColleges.getUniversitiesCollegesStatus()) ? 0 : 1);
        orgConsoleService.updateTemplate(coreOrg);

        corePlatformService.clearDictCache();
        return true;

    }

    public UniversitiesColleges getByOrgId(Long orgId) {
        return universitiesCollegesDao.getByOrgId(orgId);
    }

    public List<UniversitiesColleges> getValues(Object paras) {
        return sqlManager.select(SqlId.of("jlw.universitiesColleges.getUniversitiesCollegesValues"), UniversitiesColleges.class, paras);
    }

    public List<UniversitiesColleges> getValuesByQuery(UniversitiesCollegesQuery universitiesCollegesQuery) {

        List<UniversitiesColleges> universitiesCollegesList = universitiesCollegesDao.getValuesByQuery(universitiesCollegesQuery);

        SchoolClassQuery schoolClassQuery = new SchoolClassQuery();
        schoolClassQuery.setClassStatus(1);
        List<SchoolClass> schoolClassList = schoolClassService.getValuesByQuery(schoolClassQuery);

        Map<Long, List<SchoolClass>> groupByUniversitiesCollegesId = null;
        try {
            groupByUniversitiesCollegesId = schoolClassList.stream().collect(Collectors.groupingBy(e -> e.getUniversitiesCollegesId()));
        } catch (Exception e) {
        }

        for (int i = 0; i < universitiesCollegesList.size(); i++) {
            Long universitiesCollegesId = universitiesCollegesList.get(i).getUniversitiesCollegesId();
            if (null != groupByUniversitiesCollegesId) {
                universitiesCollegesList.get(i).set("children", groupByUniversitiesCollegesId.get(universitiesCollegesId));
            } else {
                universitiesCollegesList.get(i).set("children", null);
            }
        }

        return universitiesCollegesList;
    }

    /**
     * 刷新所有已经启用状态的 授权码
     */
    public Integer refreshUniversitiesCollegesAuthCode(Boolean isOnlyUpdateAuthCodeNullValue) {
        return universitiesCollegesDao.refreshUniversitiesCollegesAuthCode(isOnlyUpdateAuthCodeNullValue);
    }

    public UniversitiesColleges getByUserId(@NotNull(message = "用户ID不能为空！") Long userId) {
        return universitiesCollegesDao.getByUserId(userId);
    }

    /**
     * 院校用户中心信息
     *
     * @return
     */
    public UniversitiesCollegesUserInfo userCenter() {
        CoreUser user = getUser();
        Assert.isTrue(user.isUniAdmin(), "该接口只有学校管理管理员可以使用！");

        Long userId = user.getId();
        Long orgId = user.getOrgId();

        CoreUser dbUser = coreUserService.getUserById(userId);
        // 设置登录时间和最后登录时间
        sysLogService.setLoginLogInfo(userId, dbUser);

        // 构建返回实体
        UniversitiesCollegesUserInfo universitiesCollegesUserInfo = new UniversitiesCollegesUserInfo();
        // 当前的登录的学校管理员登录信息
        universitiesCollegesUserInfo.setCoreUser(dbUser);

        // 院校信息
        UniversitiesColleges universitiesColleges = universitiesCollegesDao.getByOrgId(orgId);
        universitiesCollegesUserInfo.setUniversitiesColleges(universitiesColleges);

        // 院校权限信息
        UniversitiesCollegesRuleInfo ruleInfo = universitiesCollegesDao.getUniversitiesCollegesRuleInfoByOrgId(user.getOrgId());
        universitiesCollegesUserInfo.setUniversitiesCollegesRuleInfo(ruleInfo);
        return universitiesCollegesUserInfo;
    }


    /**
     * 验证院校授权码是否正确
     *
     * @param universitiesCollegesId       院校ID
     * @param universitiesCollegesAuthCode 院校授权码
     * @return
     */
    public boolean verifyUniAuthCode(@NotNull(message = "院校ID不能为空！") Long universitiesCollegesId,
                                     @NotEmpty(message = "院校授权码不能为空！") String universitiesCollegesAuthCode) {
        return universitiesCollegesDao.createLambdaQuery()
                .andEq(UniversitiesColleges::getUniversitiesCollegesStatus, 1)
                .andEq(UniversitiesColleges::getUniversitiesCollegesId, universitiesCollegesId)
                .andEq(UniversitiesColleges::getUniversitiesCollegesAuthCode, universitiesCollegesAuthCode)
                .count() > 0;
    }

    public void verifyUniAuthCodeThrows(@NotNull(message = "院校ID不能为空！") Long universitiesCollegesId,
                                        @NotEmpty(message = "院校授权码不能为空！") String universitiesCollegesAuthCode) {
        boolean verifyUniAuthCode = verifyUniAuthCode(universitiesCollegesId, universitiesCollegesAuthCode);
        Assert.isTrue(verifyUniAuthCode, "院校授权码，验证失败！");
    }

    /**
     * 通过学生获取院校信息
     *
     * @param student
     * @return
     */
    public UniversitiesColleges getUniversitiesCollegesByStudent(@NotNull Student student) {
        SchoolClassQuery schoolClassQuery = new SchoolClassQuery();
        schoolClassQuery.setClassId(student.getClassId());
        schoolClassQuery.setClassStatus(1);
        List<SchoolClass> classes = schoolClassService.getValuesByQueryNotWithPermission(schoolClassQuery);
        if (ObjectUtil.isEmpty(classes)) {
            return null;
        }

        SchoolClass schoolClass = classes.get(0);
        UniversitiesCollegesQuery universitiesCollegesQuery = new UniversitiesCollegesQuery();
        universitiesCollegesQuery.setUniversitiesCollegesId(schoolClass.getUniversitiesCollegesId());
        universitiesCollegesQuery.setUniversitiesCollegesStatus(1);
        List<UniversitiesColleges> collegesList = getValuesByQuery(universitiesCollegesQuery);

        if (ObjectUtil.isEmpty(collegesList)) {
            return null;
        }

        return collegesList.get(0);
    }

    /**
     * 通过教师获取院校信息
     *
     * @param teacher
     * @return
     */
    public UniversitiesColleges getUniversitiesCollegesByTeacher(@NotNull Teacher teacher) {
        UniversitiesCollegesQuery universitiesCollegesQuery = new UniversitiesCollegesQuery();
        universitiesCollegesQuery.setUniversitiesCollegesId(teacher.getUniversitiesCollegesId());
        universitiesCollegesQuery.setUniversitiesCollegesStatus(1);
        List<UniversitiesColleges> collegesList = getValuesByQuery(universitiesCollegesQuery);

        if (ObjectUtil.isEmpty(collegesList)) {
            return null;
        }

        return collegesList.get(0);
    }

    /**
     * 查询院系和专业的关系数据
     *
     * @return 结果 院系和专业的一对多关系
     */
    public static List<String> getAllUniversitiesColleges() {
        return SpringUtil.getBean(UniversitiesCollegesDao.class).getAllUniversitiesColleges();
    }

    public UniversitiesColleges getByName(String name) {
        UniversitiesCollegesQuery query = new UniversitiesCollegesQuery();
        query.setUniversitiesCollegesStatus(1);
        query.setUniversitiesCollegesName(name.trim());
        return getFirst(getValuesByQuery(query));
    }

    public UniversitiesColleges getById(Long id) {
        UniversitiesCollegesQuery query = new UniversitiesCollegesQuery();
        query.setUniversitiesCollegesStatus(1);
        query.setUniversitiesCollegesId(id);
        return getFirst(getValuesByQuery(query));
    }

    public UniversitiesColleges getByNameOrCreate(String name) {

        UniversitiesColleges universitiesColleges = getByName(name);

        if (universitiesColleges != null) {
            return universitiesColleges;
        }

        UniversitiesColleges insertPO = new UniversitiesColleges();
        insertPO.setUniversitiesCollegesName(name);
        insertPO.setUniversitiesCollegesStatus(1);
        insertPO.setAddTime(new Date());
//        universitiesColleges.setOrgId(0L); 这里的orgId 在add方法里存值
        insertPO.setUserId(1L);

        add(insertPO);
        return insertPO;
    }

    public LambdaQuery<UniversitiesColleges> createLambdaQuery() {
        return universitiesCollegesDao.createLambdaQuery();
    }


    public List<Map<String, Object>> findAll() {
        return universitiesCollegesDao.findAllUniversitiesColleges();
    }

    public List<UniversitiesColleges> getAll() {
        return universitiesCollegesDao.getAll();
    }
}