import { replaceDocx, createZip, uploadFileToOSS, docxToPdf, renderDocx } from "../../lib/docs";
// const Parse = global.Parse;

const path = require("path")
const fs = require("fs")
var TemplateDocxPath = path.join(__dirname,"template/模板-推荐申报表.docx")
if(!fs.existsSync(TemplateDocxPath)){
    TemplateDocxPath = path.join(__dirname,"../../template/模板-推荐申报表.docx")
}
/**
 * 定义导出申报合集文档云函数
 * @example
 * Cloud Code test
 导出流程
 curl -X POST -H "Content-Type: application/json" -H 'X-Parse-Application-Id: edu-textbook' -d '{ "processId": "FR7KZtefyR" }' http://127.0.0.1:61337/parse/functions/tbookExportReport
 curl -X POST -H "Content-Type: application/json" -H 'X-Parse-Application-Id: edu-textbook' -d '{ "processId": "FR7KZtefyR" }' http://8.140.98.43/parse/functions/tbookExportReport
 curl -X POST -H "Content-Type: application/json" -H 'X-Parse-Application-Id: edu-textbook' -d '{ "processId": "FR7KZtefyR" }' http://8.140.98.43/parse/api/tbook/export
 curl -X POST -H "Content-Type: application/json" -H 'X-Parse-Application-Id: edu-textbook' -d '{ "processId": "FR7KZtefyR" }' https://145.tbook.com.cn/parse/api/tbook/export
 导出教材列表
 curl -X POST -H "Content-Type: application/json" -H 'X-Parse-Application-Id: edu-textbook' -d '{ "bookList": ["9V575dapEM","2YBKitpCJL","xLdiEaHGrX"] }' http://8.140.98.43/parse/functions/tbookExportReport
 */
 export function defineTbookExportReport(app){
    app.post("/parse/api/tbook/export",async (request,res)=>{
        let processId = request.body.processId;
        let bookList = request.body.bookList;
        console.log(request.body)
        try{
            let result
            if(processId){
                result = await exportProcessReportDocs(processId)
            }
            if(bookList?.length){
                result = await exportProcessReportDocs(null,bookList)
            }
            if(result?.docsList?.length==0){
                // throw new Parse.Error(404,"合集内无申报教材")
                res.json({
                    code:400,
                    err:"合集内无申报教材"
                })
            }
            // return result
            res.json({
                code:200,
                result:result
              })
        }catch(err){
            console.error(err)
            res.json({
                code:400,
                err:err
            })
            // throw new Parse.Error(404,"导出申报合集失败")
        }
        // throw new Parse.Error(404,"未找到该流程合集")
        
      })
    Parse.Cloud.define("tbookExportReport", async (request) => {
        let processId = request.params.processId;
        let bookList = request.params.bookList;
        try{
            let result
            if(processId){
                result = await exportProcessReportDocs(processId)
            }
            if(bookList?.length){
                result = await exportProcessReportDocs(null,bookList)
            }
            if(result?.docsList?.length==0){
                throw new Parse.Error(404,"合集内无申报教材")
            }
            return result
        }catch(err){
            console.error(err)
            throw new Parse.Error(404,"导出申报合集失败")
        }
        throw new Parse.Error(404,"未找到该流程合集")
    },{
        fields : {
            processId:{
                required:false
            },
        }
    });
}
  


/**
 * 导出流程教材申报文件
 * @returns
 * docsList
 * zipUrl
 */
export async function exportProcessReportDocs(processId,bookList) {
    if(!processId && !bookList?.length) return {}

    let textbookList
    if(processId){ // 流程读取教材列表
        let query = new Parse.Query("EduTextbook")
        query.equalTo("eduProcess",processId);
        textbookList = await query.find();
    }
    if(bookList?.length){ // 直接导出教材列表
        let query = new Parse.Query("EduTextbook")
        query.containedIn("objectId",bookList);
        textbookList = await query.find();
    }

    let docsList = []
    let plist = []
    for (let index = 0; index < textbookList.length; index++) {
        let textbook = textbookList[index];
        console.log("textbook",index)
        // 直接将异步调用的 Promise 添加到 plist
        plist.push(renderReportDocsByTextbook(textbook)); // 立即执行并返回 Promise
    }
    let presults = await Promise.all(plist);
    presults.forEach(result=>{
        if(result?.filePath){
            docsList.push(result)
        }
    })

    let zipPath,zipUrl
    if(docsList?.length){
        let now = new Date();
        let fileList = docsList?.map(item=>item?.pdfPath);
        let zipName = `申报书导出-${now.getFullYear()}${now.getMonth()+1}${now.getDate()}-${now.getHours()}${now.getMinutes()}${now.getSeconds()}.zip`
        zipPath = await createZip(fileList,zipName)
        if(zipPath){
            zipUrl = (await uploadFileToOSS(zipPath))?.url || null
        }
        docsList = docsList.map(item=>{return {code:item.code,title:item.title,url:item?.url}})
    }

    let result = {
        docsList,
        zipUrl
    }
    return result
}

module.exports.exportProcessReportDocs = exportProcessReportDocs

function renderReportDocsByTextbook(textbook){
    console.log("renderReportDocsByTextbook")
    let json = textbook.toJSON();
    // console.log(json)
    // 圆圈选中未选 ○ 未选 ● 选中
    let circleCheck = ["○","●"];
    // 方块选中未选 ○ 未选 ● 选中
    let squareCheck = [`□`,String.fromCharCode(0xFE)];

    // 联系电话：默认为作者首个存在的电话;
    let mobile = json?.authorList?.find(item => item.mobile)?.mobile || ""
    // 填报时间：默认为创建时间
    let createdAt = new Date(textbook?.createdAt);
    let createdDate = `${createdAt?.getFullYear()}年${createdAt?.getMonth()+1}月${createdAt?.getDate()}日`;

    // 专业代码：前四位
    let majorCode = json?.majorId || json?.major?.code
    let majorCode6
    if(majorCode?.length>4){
        majorCode = majorCode.slice(0,4)
        majorCode6 = majorCode.slice(0,6)
    }
    let majorName = json?.majorName || json?.major?.name
    // 是否重点立项
    let importantProject = json?.importantProject?.join();

    let isJC = circleCheck[(json?.approval?.indexOf("基础")>-1)?1:0];
    let isZL = circleCheck[(json?.approval?.indexOf("战略")>-1)?1:0];
    
    let is101 = circleCheck[(json?.approval?.indexOf("101计划")>-1)?1:0]; // 2024新重点
    let isZY = circleCheck[(json?.approval?.indexOf("中央")>-1)?1:0];
    let isSX = circleCheck[(json?.approval?.indexOf("四新")>-1)?1:0];
    let isJS = circleCheck[(importantProject?.indexOf("建设")>-1)?1:0];

    let isNotImpt = (json?.approval?.indexOf("101计划")==-1) && (json?.approval?.indexOf("中央")==-1) && (json?.approval?.indexOf("四新")==-1) && (json?.approval?.indexOf("建设")==-1)
    isNotImpt = circleCheck[isNotImpt?1:0];
    // 初版时间
    let firstDate = new Date(textbook?.get("editionFirst"));
    let firstYear = firstDate?.getFullYear();
    let firstMonth = firstDate?.getMonth()+1;
    // 本版时间印次
    let currentDate = new Date(textbook?.get("editionDate"));
    let currentYear = currentDate?.getFullYear();
    let currentMonth = currentDate?.getMonth()+1;
    // 最新时间印次
    let latestDate = new Date(textbook?.get("printDate"));
    let latestYear = latestDate?.getFullYear();
    let latestMonth = latestDate?.getMonth()+1;
    // 初版至今重点项目
    let isBSQT =  !((importantProject?.indexOf("建设")>-1) || (importantProject?.indexOf("本科国家")>-1) || (importantProject?.indexOf("省级优秀")>-1) || (importantProject?.indexOf("省级规划")>-1))// 是否其他省级奖项
    let bsqtName = (json?.importantProject || [])?.filter(item=>(item?.indexOf("建设")==-1&&item?.indexOf("本科国家")==-1&&item?.indexOf("省级优秀")==-1&&item?.indexOf("省级规划")==-1));
    // 教材适用
    let characteristic = (json?.characteristic?.filter(item=>item?.checked).map(item=>item.label) || [])?.join(",")

    // 作者列表 限6人
    let alist = []
    for (let index = 0; index < 9; index++) {
        alist[index] = [json?.authorList?.[index]?.name||" ",json?.authorList?.[index]?.unit||" ",toYearMonth(json?.authorList?.[index]?.birth)||" ",json?.authorList?.[index]?.nationality||" ",json?.authorList?.[index]?.job||" ",json?.authorList?.[index]?.title||" ",json?.authorList?.[index]?.mobile||" ",json?.authorList?.[index]?.email||" ",json?.authorList?.[index]?.work||" "]
    }
    // 相关成果 限5项
    let aclist = []
    for (let index = 0; index < 5; index++) {
        aclist[index] = [json?.achievementOptions?.[index]?.name||" ",json?.achievementOptions?.[index]?.unit||" ",toYearMonth(json?.achievementOptions?.[index]?.date)||" "]
    }
    // 申报历程 限4项
    let clist = []
    for (let index = 0; index < 4; index++) {
        let num = json?.courses?.[index]?(index+1):" ";
        clist[index] = [num,toYearMonth(json?.courses?.[index]?.date)||" ",json?.courses?.[index]?.wordage||" ",json?.courses?.[index]?.num||" ",json?.courses?.[index]?.sumNum||" ",json?.courses?.[index]?.accolade||" "]
    }
    
    // 附件信息
    let mergeFiles = []
    // 1.教材电子版（必须提供）
    // （教材出版单位配合按要求上传各地推荐的本单位出版的纸质教材最新印次的完整PDF电子版；数字教材上传全部教材内容电子版或填写能够查看全部教材内容的链接地址、账号；纸质教材附带数字资源的，上传纸质教材最新印次的完整PDF电子版，以及全部数字资源电子版或能够查看全部数字资源内容的链接地址、账号。）
    // 2.所有作者政治审查意见（必须提供）
    // （对应作者姓名上传“作者政治审查表”。作者单位党委对作者进行审查，对政治思想表现情况进行评价，确保作者的正确政治方向、价值取向，无违法违纪等记录。教材编写成员涉及多个不同单位时需要各单位分别出具意见，并由所在单位党委盖章，格式要求从申报平台下载。）
    // 3.图书编校质量自查结果记录表（必须提供）
    // （教材出版单位对申报教材的编校质量自查后，按要求提供图书编校质量自查结果记录表，并加盖出版社公章。全册教材的不同分册以不同文件分别上传。格式要求从申报平台下载。）
    if(json?.selfResults?.url){mergeFiles.push(json?.selfResults?.url)}
    // 4.专家审查意见表（必须提供）
    // （由第一主编所在单位和出版机构邀请校内外相关学科专业领域专家，对教材进行思想性、学术性审查。专家不少于3名，其中半数以上为校外专家，专家分别实名评价并签字，并注明所在单位及专业身份。评价人不得是本教材的作者。）
    if(json?.expertOpinion?.url){mergeFiles.push(json?.expertOpinion?.url)}
    // 5.教材使用情况证明材料（必须提供）
    // （教材出版单位提供教材主要使用高校名单及使用情况证明材料，并加盖公章。）
    if(json?.evidence?.url){mergeFiles.push(json?.evidence?.url)}
    // 6.版权信息及CIP数据（必须提供）
    // （版权页截图，中国版本图书馆CIP查询截图，如CIP数据中无“教材”字样的，须再上传内容提要或前言或后记中可以证明本书为教材的相关内容截图。）
    if(json?.CIPImgUrl){mergeFiles.push(json?.CIPImgUrl)}
    // 7.其他材料（可选提供）
    if(json?.moreMaterial?.length){
        json?.moreMaterial.forEach(doc=>{
            if(doc?.url){
                mergeFiles.push(doc?.url)
            }
        })
    }

    // （其他佐证材料，限两份以内。）

    let fixData = {
        // 封面信息
        titlePad:padString(json?.title,21),
        ISBNPad:padString(json?.ISBN,21),
        ISBN:json?.ISBN,
        inviteUnit:json?.inviteUnit||"",
        one:squareCheck[(json?.type=="单本"||json?.type=="单册")?1:0], // 单本/单册 方框
        full:squareCheck[json?.type=="全册"?1:0], // 全册
        oneCircle:circleCheck[(json?.type=="单本"||json?.type=="单册")?1:0], // 单本/单册 圆圈
        fullCircle:circleCheck[json?.type=="全册"?1:0], // 全册
        tn:json?.typeNumber,
        authorPad:padString(json?.author,21),
        mobile:padString(mobile,21),
        authorUnit:padString(json?.unit,21),
        publisherPad:padString(json?.editionUnit,21),
        recommandUnit:padString("",14), // 未找到
        majorCodePad:padString((majorCode),6),
        createdDate:padString(createdDate,21),
        // 基本信息
        title:json?.title,
        author:json?.author,
        unit:json?.unit,
        uBS:circleCheck[(json?.unitType?.indexOf("部属")>-1)?1:0],
        uHJ:circleCheck[(json?.unitType?.indexOf("合建")>-1)?1:0],
        uGJ:circleCheck[(json?.unitType?.indexOf("共建")>-1)?1:0],
        uQT:circleCheck[(json?.unitType?.indexOf("其他")>-1)?1:0],
        mc:majorCode,
        mc6:majorCode6,
        mn:majorName,
        lCN:circleCheck[(json?.lang=="中文")?1:0],
        lEN:circleCheck[(json?.lang=="英文")?1:0],
        lOT:circleCheck[(json?.lang?.indexOf("其他")>-1)?1:0],
        lSS:circleCheck[(json?.lang?.indexOf("少数")>-1)?1:0],
        authors:json?.authors, // 其他主编
        editor:json?.editor, // 其他编者
        isJC:isJC,
        isZL:isZL,
        isSX:isSX,
        is101:is101,
        isZY:isZY,
        isJS:isJS,
        isNotImpt:isNotImpt,
        publisher:json?.editionUnit,
        firstYear:firstYear,
        firstMonth:firstMonth,
        isZZ:circleCheck[(json?.carrierShape?.indexOf("纸质")>-1)?1:0],
        isDZ:circleCheck[(json?.carrierShape?.indexOf("电子")>-1)?1:0],
        isSZ:circleCheck[(json?.carrierShape?.indexOf("数字")>-1)?1:0],
        isQT:circleCheck[(json?.carrierShape?.indexOf("附带")>-1)?1:0],
        isFD:circleCheck[(json?.carrierShape?.indexOf("其他")>-1)?1:0],
        latestY:latestYear,
        latestM:latestMonth,
        latestNum:json?.printNumber || "",
        currentY:currentYear,
        currentM:currentMonth,
        currentNum:json?.editionNumber || "",
        printSum:json?.printSum?json?.printSum+"万":"" || "",
        isBGJ:circleCheck[(importantProject?.indexOf("本科国家")>-1)?1:0],
        isBSYX:circleCheck[(importantProject?.indexOf("省级优秀")>-1)?1:0],
        isBSGH:circleCheck[(importantProject?.indexOf("省级规划")>-1)?1:0],
        isBSQT:circleCheck[isBSQT?1:0],
        bsqtName:bsqtName||"",
        isFirstNot:circleCheck[json?.importantProject?0:1],
        // 教材适用情况
        lessons:json?.lessons||[],
        period:json?.period||"", // 学时
        isBX:squareCheck[(characteristic?.indexOf("必修")>-1)?1:0],
        isXX:squareCheck[(characteristic?.indexOf("选修")>-1)?1:0],
        isTS:circleCheck[(characteristic?.indexOf("通识")>-1)?1:0],
        isGG:circleCheck[(characteristic?.indexOf("公共")>-1)?1:0],
        isZY:circleCheck[(characteristic?.indexOf("专业")>-1)?1:0],
        isSXZZ:squareCheck[(characteristic?.indexOf("思想")>-1)?1:0],
        isSY:squareCheck[(characteristic?.indexOf("实验")>-1)?1:0],
        // 作者列表
        a11:alist[0][0],a12:alist[0][1],a13:alist[0][2],a14:alist[0][3],a15:alist[0][4],a16:alist[0][5],a17:alist[0][6],a18:alist[0][7],a19:alist[0][8],
        a21:alist[1][0],a22:alist[1][1],a23:alist[1][2],a24:alist[1][3],a25:alist[1][4],a26:alist[1][5],a27:alist[1][6],a28:alist[1][7],a29:alist[1][8],
        a31:alist[2][0],a32:alist[2][1],a33:alist[2][2],a34:alist[2][3],a35:alist[2][4],a36:alist[2][5],a37:alist[2][6],a38:alist[2][7],a39:alist[2][8],
        a41:alist[3][0],a42:alist[3][1],a43:alist[3][2],a44:alist[3][3],a45:alist[3][4],a46:alist[3][5],a47:alist[3][6],a48:alist[3][7],a49:alist[3][8],
        a51:alist[4][0],a52:alist[4][1],a53:alist[4][2],a54:alist[4][3],a55:alist[4][4],a56:alist[4][5],a57:alist[4][6],a58:alist[4][7],a59:alist[4][8],
        a61:alist[5][0],a62:alist[5][1],a63:alist[5][2],a64:alist[5][3],a65:alist[5][4],a66:alist[5][5],a67:alist[5][6],a68:alist[5][7],a69:alist[5][8],
        // 成果列表
        ac11:aclist[0][0],ac12:aclist[0][1],ac13:aclist[0][2],
        ac21:aclist[1][0],ac22:aclist[1][1],ac23:aclist[1][2],
        ac31:aclist[2][0],ac32:aclist[2][1],ac33:aclist[2][2],
        ac41:aclist[3][0],ac42:aclist[3][1],ac43:aclist[3][2],
        ac51:aclist[4][0],ac52:aclist[4][1],ac53:aclist[4][2],
        // 历程列表
        c11:clist[0][0],c12:clist[0][1],c13:clist[0][2],c14:clist[0][3],c15:clist[0][4],c16:clist[0][5],
        c21:clist[1][0],c22:clist[1][1],c23:clist[1][2],c24:clist[1][3],c25:clist[1][4],c26:clist[1][5],
        c31:clist[2][0],c32:clist[2][1],c33:clist[2][2],c34:clist[2][3],c35:clist[2][4],c36:clist[2][5],
        c41:clist[3][0],c42:clist[3][1],c43:clist[3][2],c44:clist[3][3],c45:clist[3][4],c46:clist[3][5],

    }
    let bookData = json;
    Object.keys(fixData).forEach(key=>{
        bookData[key] = fixData[key]
    })
    // console.log(bookData)
    // console.log(json)
    let bookid = json.code || json?.objectId;
    let tempFileName = path.join(`${bookid}${json.title}.docx`)
    return new Promise(async (resolve)=>{
        let filePath,pdfPath,urlDocx,urlPdf
        try{
            // DOCX模板合成 速度2-3秒
            filePath = renderDocx(TemplateDocxPath,tempFileName,bookData)
            urlDocx = (await uploadFileToOSS(filePath))?.url || null
            console.log("DOCX CREATED:",filePath)

            // PDF文档拼接 速度10-30s 需要API支持
            pdfPath = filePath.replaceAll(".docx",".pdf")
            let options = {
                mergeFiles:mergeFiles
            }
            pdfPath = await docxToPdf(filePath,pdfPath,options) || filePath // 成功用pdf，失败继续用docx
            console.log("PDF CREATED:",filePath)
            if(pdfPath){
                urlPdf = (await uploadFileToOSS(pdfPath))?.url || null
            }
        }catch(err){
            console.error(err)
        }
        resolve({
            code:bookid,
            title:json?.title,
            filePath,
            pdfPath,
            urlDocx,
            urlPdf,
        })
        return
        replaceDocx(TemplateDocxPath,tempFileName,bookData,{onDocxComplete:async (filePath)=>{
            // 需要API支持
            let pdfPath = filePath.replaceAll(".docx",".pdf")
            filePath = await docxToPdf(filePath,pdfPath) || filePath // 成功用pdf，失败继续用docx
            let url = (await uploadFileToOSS(pdfPath))?.url || null
            resolve({
                code:bookid,
                title:json?.title,
                filePath,
                url
            })
        }})
    })
}

function toYearMonth(date){
    if(!date) return ""
    date = new Date(date?.iso||date);
    return `${date.getFullYear()}年${date.getMonth()+1}月`
}

function padString(str,width) {
    str = str || ""
    return str
    str = String(str)
    width = width || 21 // 目标宽度为21个单位
    let spaceChar = " " // 占位符 render可用空格，但document.xml用&#160;
    // 计算字符串的宽度
    const charWidth = {
        'space': 1, // 空格占用1个单位
        'zh': 3,    // 汉字占用3个单位
        'en': 1,    // 英文字母占用1个单位
        'other': 1  // 其他字符（如标点符号）占用1个单位
    };
    let strWidth = 0;
    // console.log(str)
    // 遍历文本中的每个字符
    for (let char of str) {
        if (/\s/.test(char)) {
            strWidth += charWidth.space; // 空格
        } else if (/[\u4e00-\u9fa5]/.test(char)) {
            strWidth += charWidth.zh; // 汉字
        } else if (/[a-zA-Z]/.test(char)) {
            strWidth += charWidth.en; // 英文字母
        } else {
            strWidth += charWidth.other; // 其他字符
        }
    }
    // for (let char of str) {
    //     // 判断字符是否为中文
    //     if (char.match(/[\u4e00-\u9fa5]/)) {
    //         strWidth += 2; // 中文字符占4个单位
    //     } else {
    //         strWidth += 1; // 英文字符占1个单位
    //     }
    // }

    const totalPadding = width - strWidth;
    // 如果已经达到或超过目标宽度，直接返回原字符串
    if (totalPadding <= 0) {
        return str;
    }
    // 计算左右两侧的空格数
    const leftPadding = Math.floor(totalPadding / 2) * 3;
    const rightPadding = Math.ceil(totalPadding / 2) * 3;
    // 生成填充空格的字符串
    const leftSpaces = spaceChar.repeat(leftPadding);
    const rightSpaces = spaceChar.repeat(rightPadding);
    // 返回补充后的字符串
    return leftSpaces + str + rightSpaces;
}