package com.ibeetl.jlw.service;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.bean.copier.CopyOptions;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.jlw.util.ToolUtils;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.ibeetl.admin.core.entity.CoreUser;
import com.ibeetl.admin.core.service.CoreBaseService;
import com.ibeetl.admin.core.util.PlatformException;
import com.ibeetl.admin.core.web.JsonResult;
import com.ibeetl.admin.core.web.JsonReturnCode;
import com.ibeetl.jlw.dao.TeacherOpenCourseMergeResourcesInfoDao;
import com.ibeetl.jlw.entity.CourseInfo;
import com.ibeetl.jlw.entity.FileEntity;
import com.ibeetl.jlw.entity.ResourcesInfo;
import com.ibeetl.jlw.entity.TeacherOpenCourseMergeResourcesInfo;
import com.ibeetl.jlw.web.query.ResourcesInfoQuery;
import com.ibeetl.jlw.web.query.TeacherOpenCourseMergeResourcesInfoQuery;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.beetl.sql.core.SqlId;
import org.beetl.sql.core.engine.PageQuery;
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.annotation.Nullable;
import javax.validation.constraints.NotNull;
import java.io.*;
import java.util.*;

import static com.ibeetl.admin.core.util.ExcelUtil.getCellFormatValue;
import static java.util.stream.Collectors.joining;
import static java.util.stream.Collectors.toSet;
import static org.apache.commons.lang3.StringUtils.join;

/**
 * 开课资源拉取 Service
 * 当分布式ID开启后请勿使用insert(*,true)
 */

@Service
@Transactional
@Validated
@Slf4j
public class TeacherOpenCourseMergeResourcesInfoService extends CoreBaseService<TeacherOpenCourseMergeResourcesInfo> implements DeleteResourcesBy {

    @Autowired private TeacherOpenCourseMergeResourcesInfoDao teacherOpenCourseMergeResourcesInfoDao;
    @Autowired
    private ResourcesInfoService resourcesInfoService;
    @Autowired
    private TeacherOpenCourseMergeCourseInfoService teacherOpenCourseMergeCourseInfoService;

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

    public PageQuery<TeacherOpenCourseMergeResourcesInfo>queryByConditionQuery(PageQuery query){
        PageQuery ret =  teacherOpenCourseMergeResourcesInfoDao.queryByConditionQuery(query);
        queryListAfter(ret.getList());
        return ret;
    }

    public void deleteByList(List list){
        String ids = "";
        ToolUtils.deleteNullList(list);
        for(int i=0;null != list && i<list.size();i++){
            ids += list.get(i).toString()+(i==list.size()-1?"":",");
        }
        if(StringUtils.isNotBlank(ids)){
            teacherOpenCourseMergeResourcesInfoDao.deleteTeacherOpenCourseMergeResourcesInfoByIds(ids);
        }
    }

    public void deleteTeacherOpenCourseMergeResourcesInfo(String ids){
        try {
            teacherOpenCourseMergeResourcesInfoDao.deleteTeacherOpenCourseMergeResourcesInfoByIds(ids);
        } catch (Exception e) {
            throw new PlatformException("批量删除开课资源拉取失败", e);
        }
    }
    public void logicDeleteTeacherOpenCourseMergeResourcesInfo(String ids){
        try {
            teacherOpenCourseMergeResourcesInfoDao.logicDeleteTeacherOpenCourseMergeResourcesInfo(ids);
        } catch (Exception e) {
            throw new PlatformException("批量删除开课资源拉取失败", e);
        }
    }

    public String addAll(TeacherOpenCourseMergeResourcesInfoQuery teacherOpenCourseMergeResourcesInfoQuery){
        String msg = "";
        List<TeacherOpenCourseMergeResourcesInfo> teacherOpenCourseMergeResourcesInfoList = new ArrayList<>();
        try {
            teacherOpenCourseMergeResourcesInfoList = JSON.parseArray(teacherOpenCourseMergeResourcesInfoQuery.getTeacherOpenCourseMergeResourcesInfoJsonStr(), TeacherOpenCourseMergeResourcesInfo.class);
        } catch (Exception e) {
            try {
                teacherOpenCourseMergeResourcesInfoList.add(JSONObject.parseObject(teacherOpenCourseMergeResourcesInfoQuery.getTeacherOpenCourseMergeResourcesInfoJsonStr(), TeacherOpenCourseMergeResourcesInfo.class));
            } catch (Exception e1) {}
        }
        ToolUtils.deleteNullList(teacherOpenCourseMergeResourcesInfoList);
        if(null != teacherOpenCourseMergeResourcesInfoList && teacherOpenCourseMergeResourcesInfoList.size()>0){
            for(int i=0;i<teacherOpenCourseMergeResourcesInfoList.size();i++){
                TeacherOpenCourseMergeResourcesInfo teacherOpenCourseMergeResourcesInfo = teacherOpenCourseMergeResourcesInfoList.get(i);
                teacherOpenCourseMergeResourcesInfo.setUserId(teacherOpenCourseMergeResourcesInfoQuery.getUserId());
                teacherOpenCourseMergeResourcesInfo.setOrgId(teacherOpenCourseMergeResourcesInfoQuery.getOrgId());
            }
            insertBatch(teacherOpenCourseMergeResourcesInfoList);
        }
        return msg;
    }

    public JsonResult add(TeacherOpenCourseMergeResourcesInfoQuery teacherOpenCourseMergeResourcesInfoQuery){
        String msg = "";
        TeacherOpenCourseMergeResourcesInfo teacherOpenCourseMergeResourcesInfo = teacherOpenCourseMergeResourcesInfoQuery.pojo();
        teacherOpenCourseMergeResourcesInfoDao.insert(teacherOpenCourseMergeResourcesInfo);
        teacherOpenCourseMergeResourcesInfoQuery.setTeacherOpenCourseMergeResourcesInfoId(teacherOpenCourseMergeResourcesInfo.getTeacherOpenCourseMergeResourcesInfoId());
        JsonResult jsonResult = new JsonResult();
        jsonResult.setData(teacherOpenCourseMergeResourcesInfo.getTeacherOpenCourseMergeResourcesInfoId());//自增的ID丢进去
        jsonResult.setCode(JsonReturnCode.SUCCESS.getCode());
        jsonResult.setMsg(msg);

        // 刷新缓存
        teacherOpenCourseMergeCourseInfoService.invalidateCourseInfoTreeLocalCache(teacherOpenCourseMergeResourcesInfo.getTeacherOpenCourseMergeCourseInfoId());
        return jsonResult;
    }

    public String edit(TeacherOpenCourseMergeResourcesInfoQuery teacherOpenCourseMergeResourcesInfoQuery){
        String msg = "";
        TeacherOpenCourseMergeResourcesInfo teacherOpenCourseMergeResourcesInfo = teacherOpenCourseMergeResourcesInfoQuery.pojo();
        teacherOpenCourseMergeResourcesInfoDao.updateTemplateById(teacherOpenCourseMergeResourcesInfo);

        // 刷新缓存
        teacherOpenCourseMergeCourseInfoService.invalidateCourseInfoTreeLocalCache(teacherOpenCourseMergeResourcesInfo.getTeacherOpenCourseMergeCourseInfoId());
        return msg;
    }

    public String updateGivenByIds(TeacherOpenCourseMergeResourcesInfoQuery teacherOpenCourseMergeResourcesInfoQuery){
        String msg = "";
        if(StringUtils.isNotBlank(teacherOpenCourseMergeResourcesInfoQuery.get_given())){
            boolean flag = teacherOpenCourseMergeResourcesInfoDao.updateGivenByIds(teacherOpenCourseMergeResourcesInfoQuery) > 0;
            if(!flag){
                msg = "更新指定参数失败";
            }
        }else{
            msg = "指定参数为空";
        }
        return msg;
    }

    public List<TeacherOpenCourseMergeResourcesInfo> getValues (Object paras){
        return sqlManager.select(SqlId.of("jlw.teacherOpenCourseMergeResourcesInfo.getTeacherOpenCourseMergeResourcesInfoValues"), TeacherOpenCourseMergeResourcesInfo.class, paras);
    }

    public List<TeacherOpenCourseMergeResourcesInfo> getValuesByQuery (TeacherOpenCourseMergeResourcesInfoQuery teacherOpenCourseMergeResourcesInfoQuery){
        return teacherOpenCourseMergeResourcesInfoDao.getValuesByQuery(teacherOpenCourseMergeResourcesInfoQuery);
    }

    public List<TeacherOpenCourseMergeResourcesInfo> getValuesByQueryNotWithPermission (TeacherOpenCourseMergeResourcesInfoQuery teacherOpenCourseMergeResourcesInfoQuery){
        return teacherOpenCourseMergeResourcesInfoDao.getValuesByQueryNotWithPermission(teacherOpenCourseMergeResourcesInfoQuery);
    }

    public TeacherOpenCourseMergeResourcesInfo getInfo (Long teacherOpenCourseMergeResourcesInfoId){
        TeacherOpenCourseMergeResourcesInfoQuery teacherOpenCourseMergeResourcesInfoQuery = new TeacherOpenCourseMergeResourcesInfoQuery();
        teacherOpenCourseMergeResourcesInfoQuery.setTeacherOpenCourseMergeResourcesInfoId(teacherOpenCourseMergeResourcesInfoId);
        List<TeacherOpenCourseMergeResourcesInfo> list = teacherOpenCourseMergeResourcesInfoDao.getValuesByQuery(teacherOpenCourseMergeResourcesInfoQuery);
        if(null != list && list.size()>0){
            return list.get(0);
        }else{
            return null;
        }
    }

    public TeacherOpenCourseMergeResourcesInfo getInfo (TeacherOpenCourseMergeResourcesInfoQuery teacherOpenCourseMergeResourcesInfoQuery){
        List<TeacherOpenCourseMergeResourcesInfo> list = teacherOpenCourseMergeResourcesInfoDao.getValuesByQuery(teacherOpenCourseMergeResourcesInfoQuery);
        if(null != list && list.size()>0){
            return list.get(0);
        }else{
            return null;
        }
    }


    public JsonResult importTemplate(List<FileEntity> fileEntityList,List<Long>list,CoreUser coreUser){
        List<String[]>errMsg = new ArrayList<>();
        String msg ="";
        int count = 0;
        Date date = new Date();
        for(int item=0;null != fileEntityList && item<fileEntityList.size();item++){
            FileEntity fileEntity = fileEntityList.get(item);
            if(null != fileEntity){
                File file = new File(fileEntity.getAbsoluteUrl());
                if(file.exists() && file.isFile() && file.canRead() && ToolUtils.findInSet("xls,xlsx",fileEntity.getFormat())){
                    Workbook wb = null;
                    InputStream is = null;
                    try {
                        is = new FileInputStream(fileEntity.getAbsoluteUrl());
                        if("xls".equals(fileEntity.getFormat())){
                            wb = new HSSFWorkbook(is);
                        }else if("xlsx".equals(fileEntity.getFormat())){
                            wb = new XSSFWorkbook(is);
                        }
                    } catch (FileNotFoundException e) {
                        e.printStackTrace();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    try {
                        if(null != is){
                        is.close();
                    }
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                    if(wb != null){
                        //获取Sheet1
                        Sheet sheet = wb.getSheet("Sheet1");
                        //获取最大行数
                        int rowNum = sheet.getPhysicalNumberOfRows();
                        //获取第一行
                        Row firstRow = sheet.getRow(0);
                        //获取最大列数
                        int colNum = firstRow.getPhysicalNumberOfCells();

                        String[] columns = {
                                        "开课课程",
                                        "教师开课",
                                        "资源名称",
                                        "资源类型 数据字典",
                                        "资源内容",
                        };

                        Map<String,Integer> map = new HashMap<>();//获取需要的表头的列

                        //从第一列找到需要的表头
                        for (int i=0; i<colNum; i++){
                            String cellData = getCellFormatValue(firstRow.getCell(i));
                            for(int j=0;j<columns.length;j++){
                                if(columns[j].equals(cellData)){
                                    map.put(columns[j],i);
                                }
                            }
                        }

                        //验证所需要的表头是否全
                        Integer flag = 0;
                        for(int i=0;i<columns.length;i++){
                            if(null != map.get(columns[i])){
                                flag ++;
                            }
                        }
                        if(flag != columns.length){
                            String str = " ";
                            for(int i=0;i<columns.length;i++){
                                str += "\""+columns[i]+"\""+(i == columns.length-1?"":", ");
                            }
                            return JsonResult.failMessage("导入失败，表格表头应包含"+str);
                        }

                        for (int i = 1; i<rowNum; i++) {
                            Row row = sheet.getRow(i);
                            if(null == row){
                                errMsg.add(new String[]{"第"+(i+1)+"数据为空"});
                                continue;
                            }

                            String teacherOpenCourseMergeCourseInfoId = getCellFormatValue(row.getCell(map.get(columns[0])));
                            String teacherOpenCourseId = getCellFormatValue(row.getCell(map.get(columns[1])));
                            String resourcesInfoName = getCellFormatValue(row.getCell(map.get(columns[2])));
                            String resourcesInfoType = getCellFormatValue(row.getCell(map.get(columns[3])));
                            String resourcesInfoContent = getCellFormatValue(row.getCell(map.get(columns[4])));
                            //TODO 判断（如重复等复杂判断要额外写）
                            if(StringUtils.isBlank(teacherOpenCourseMergeCourseInfoId)){
                                errMsg.add(new String[]{"第"+ToolUtils.numberToLetter(map.get(columns[0])+1)+"列，第"+(i+1)+"行开课课程为空"});
                                continue;
                            }else
                            if(StringUtils.isBlank(teacherOpenCourseId)){
                                errMsg.add(new String[]{"第"+ToolUtils.numberToLetter(map.get(columns[1])+1)+"列，第"+(i+1)+"行教师开课为空"});
                                continue;
                            }else
                            if(StringUtils.isBlank(resourcesInfoName)){
                                errMsg.add(new String[]{"第"+ToolUtils.numberToLetter(map.get(columns[2])+1)+"列，第"+(i+1)+"行资源名称为空"});
                                continue;
                            }else
                            if(StringUtils.isBlank(resourcesInfoType)){
                                errMsg.add(new String[]{"第"+ToolUtils.numberToLetter(map.get(columns[3])+1)+"列，第"+(i+1)+"行资源类型 数据字典为空"});
                                continue;
                            }else
                            if(StringUtils.isBlank(resourcesInfoContent)){
                                errMsg.add(new String[]{"第"+ToolUtils.numberToLetter(map.get(columns[4])+1)+"列，第"+(i+1)+"行资源内容为空"});
                                continue;
                            }else
                            {
                            //TODO 保存
                            TeacherOpenCourseMergeResourcesInfo teacherOpenCourseMergeResourcesInfo = new TeacherOpenCourseMergeResourcesInfo();
                            teacherOpenCourseMergeResourcesInfo.setTeacherOpenCourseMergeCourseInfoId(Long.parseLong(teacherOpenCourseMergeCourseInfoId));
                            teacherOpenCourseMergeResourcesInfo.setTeacherOpenCourseId(Long.parseLong(teacherOpenCourseId));
                            teacherOpenCourseMergeResourcesInfo.setResourcesInfoName(resourcesInfoName);
                            teacherOpenCourseMergeResourcesInfo.setResourcesInfoType(Integer.parseInt(resourcesInfoType));
                            teacherOpenCourseMergeResourcesInfo.setResourcesInfoContent(resourcesInfoContent);
                            teacherOpenCourseMergeResourcesInfo.setOrgId(coreUser.getOrgId());
                            teacherOpenCourseMergeResourcesInfo.setUserId(coreUser.getId());

                            count++;
                            }
                        }
                    }
                }
            }
        }
        JsonResult jsonResult = new JsonResult();
        jsonResult.setCode(count>0?JsonReturnCode.SUCCESS.getCode():JsonReturnCode.FAIL.getCode());
        jsonResult.setData(errMsg);
        jsonResult.setMsg((count>0?"导入成功,共导入"+count+"条":"导入失败")+(StringUtils.isNotBlank(msg)?"<br>"+msg:""));
        return jsonResult;
    }

    public List<Map<String,Object>> getExcelValues (TeacherOpenCourseMergeResourcesInfoQuery teacherOpenCourseMergeResourcesInfoQuery){
        return teacherOpenCourseMergeResourcesInfoDao.getExcelValues(teacherOpenCourseMergeResourcesInfoQuery);
    }

    /**
     * 根据指定的课程ID和章节ID集合，去从系统资源拷贝到开课资源库
     *
     * @param teacherOpenCourseId   开课ID
     * @param allCourseInfo         指定的所有课程章节
     * @param courseInfoIdPair                拷贝过来的ID段，旧ID和新ID的一个映射关系（非必填）
     */
    public void copySystemResourcesInfoToOpenCourse(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId,
                                                    Collection<CourseInfo> allCourseInfo, @Nullable Map<Long, Long> courseInfoIdPair) {
        ResourcesInfoQuery resourcesInfoQuery = new ResourcesInfoQuery();
        // 取出所有的课程章节ID
        String courseInfoIds = allCourseInfo.stream().map(item -> item.getCourseInfoId().toString()).collect(joining(","));
        resourcesInfoQuery.setCourseInfoIds(courseInfoIds);
        List<ResourcesInfo> resourcesInfoList = resourcesInfoService.getValuesByQuery(resourcesInfoQuery);

        // 系统资源库ID集合
        Set<Long> resourcesInfoIds = resourcesInfoList.stream().map(ResourcesInfo::getResourcesInfoId).collect(toSet());
        // 拷贝系统资源库到教师开课
        copyFromResourcesInfo(resourcesInfoIds, teacherOpenCourseId, courseInfoIdPair);
    }

    /**
     * 根据指定的课程ID和章节ID集合，去从系统资源拷贝到开课资源库
     *
     * @param teacherOpenCourseId   开课ID
     * @param allCourseInfoIdsJoin  指定的所有课程章节ID
     * @param courseInfoIdPair                拷贝过来的ID段，旧ID和新ID的一个映射关系（非必填）
     */
    public void copySystemResourcesInfoToOpenCourse(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId,
                                                    String allCourseInfoIdsJoin, @Nullable Map<Long, Long> courseInfoIdPair) {
        ResourcesInfoQuery resourcesInfoQuery = new ResourcesInfoQuery();
        resourcesInfoQuery.setCourseInfoIds(allCourseInfoIdsJoin);
        List<ResourcesInfo> resourcesInfoList = resourcesInfoService.getValuesByQuery(resourcesInfoQuery);

        // 系统资源库ID集合
        Set<Long> resourcesInfoIds = resourcesInfoList.stream().map(ResourcesInfo::getResourcesInfoId).collect(toSet());
        // 拷贝系统资源库到教师开课
        copyFromResourcesInfo(resourcesInfoIds, teacherOpenCourseId, courseInfoIdPair);
    }


    /**
     * 教师端-导入资源操作，逻辑拆分
     * <p>
     * 从系统资源库拉取到教师开课的资源中。
     *
     * @param resourcesInfoIds    资源信息ID集合
     * @param teacherOpenCourseId 开课ID
     * @param courseInfoIdPair
     * @return
     */
    public void copyFromResourcesInfo(Set<Long> resourcesInfoIds,
                                      @NotNull(message = "开课ID不能为空！") final Long teacherOpenCourseId, Map<Long, Long> courseInfoIdPair) {

        if (ObjectUtil.isEmpty(resourcesInfoIds)) { return; }
        ResourcesInfoQuery resourcesInfoQuery = new ResourcesInfoQuery();
        resourcesInfoQuery.setResourcesInfoIds(join(resourcesInfoIds.toArray(), ","));
        List<ResourcesInfo> resourcesInfoList = resourcesInfoService.getValuesByQuery(resourcesInfoQuery);
        if (ObjectUtil.isEmpty(resourcesInfoList)) { return; }

        // 拷贝部分字段映射
        CopyOptions copyOptions = CopyOptions.create().setFieldMapping(MapUtil.of("courseInfoId", "teacherOpenCourseMergeCourseInfoId"));
        List<TeacherOpenCourseMergeResourcesInfo> copyToList =
                BeanUtil.copyToList(resourcesInfoList, TeacherOpenCourseMergeResourcesInfo.class, copyOptions);
        copyToList.forEach(item -> item.setTeacherOpenCourseId(teacherOpenCourseId));

        resetNewId(copyToList, courseInfoIdPair);

        // 批量插入资源和开课关联表
        insertBatch(copyToList);
    }

    /**
     * 重置开课课程ID。需要拿到新旧改变的关系
     * @param copyToList
     * @param courseInfoIdPair
     */
    public void resetNewId(List<TeacherOpenCourseMergeResourcesInfo> copyToList, Map<Long, Long> courseInfoIdPair) {
        if (ObjectUtil.isEmpty(courseInfoIdPair)) {return;}
        copyToList.forEach(item -> {
            item.setTeacherOpenCourseMergeCourseInfoId(courseInfoIdPair.get(item.getTeacherOpenCourseMergeCourseInfoId()));
        });
    }

    /**
     * 教师端-重置操作之一
     * 根据开课ID清空离线资源信息
     *
     * @param teacherOpenCourseId
     */
    @Override
    public void resetOperationByTeacherOpenCourseId(Long teacherOpenCourseId) {
        log.info("重置开课课程资源");
        sqlManager.lambdaQuery(TeacherOpenCourseMergeResourcesInfo.class)
                .andEq(TeacherOpenCourseMergeResourcesInfo::getTeacherOpenCourseId, teacherOpenCourseId)
                .delete();
    }

    @Override
    public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId) {

    }

    /**
     * 验证操作的数据，是否是教师本人上传的
     * @param resourcesInfoIds
     * @param coreUser
     */
    public void validateIsTeacher(@NotNull(message = "开课资源ID不能为空！") String resourcesInfoIds, @NotNull(message = "登录用户信息不能为空！") CoreUser coreUser) {
        if (coreUser.isTeacher()) {
            for (String id : resourcesInfoIds.split(",")) {
                Long userId = getInfo(Long.valueOf(id)).getUserId();
                Assert.isTrue(coreUser.getId().equals(userId), "只能编辑自己上传的资源");
            }
        }
    }
}