
//根据pageInfo,question列表获取试卷的ui展示数据  pageInfo 为页面信息数据   questionList 为试题结构列表数据
export function GetPaperUiData(pageInfo,questionList) {

  console.log("在线制卡方法库打印pageInfo",pageInfo);
  console.log("在线制卡方法库打印questionList",questionList);
  let templateObject=GetPaperTemplateObject(pageInfo,1);//初始默认第一页
  let paperTemplateData=[templateObject];
  const pageTop=56;//页面内容区到顶部留白高度 56px 固定值 
  const pageLeft=57;//页面内容区到左边留白宽度 57px 固定值 后期可以写成配置
  const questionTitleHeight=34;//题目标题高度 34px 固定值 后期可以写成配置

  //试题结构循环处理
  questionList.forEach(questionItem=> {
    // console.log("打印questionItem",questionItem);
    // type 题目类型  1  选择题 2.填空题 3:解答题 4.作文英 5.作文语 6.非作答区

    let remainingHeight = GetPaperRemainingHeight(paperTemplateData[paperTemplateData.length - 1], pageInfo);//获取当前页的剩余高度
    // console.log("打印剩余高度",remainingHeight);
    if(questionItem.type==1)
    {
      // console.log("选择题处理",pageInfo);
      questionItem.w=pageInfo.mainWidth;//大题区域宽度 这里需要用内容区域宽度
      let questionUiData = GetChooseUiData(questionItem);//获取选择题UI数据
      //计算选择题实际需要的高度 (需要包括标题的高度 34px)
      let requiredHeight = questionUiData.h + questionTitleHeight;//选择题必定有标题  所以直接加上34px的高度
      //如果剩余高度 大于 选择题需要的实际高度 添加到当前页面
      if(remainingHeight >= requiredHeight)
      {
        // console.log("添加选择题时剩余高度大于当前题的高度，直接添加到当前页",questionUiData);

        //计算选择题的x y坐标
        
        let x=pageLeft;
        let y=(pageInfo.mainHeight-remainingHeight)+pageTop+questionTitleHeight;//34 标题的高度
        console.log("选择题x坐标",x);
        console.log("选择题y坐标",y);

        questionUiData.x=x;
        questionUiData.y=y;
        //剩余高度大于当前题的高度，直接添加到当前页
        paperTemplateData[paperTemplateData.length - 1].questionUiData.push(questionUiData);
      }
      else
      {
        // console.log("添加选择题时剩余高度小于当前题的高度，添加到当新的一页",questionUiData);
        let currentPageIndex = paperTemplateData[paperTemplateData.length - 1].pageIndex;
        //剩余高度小于当前题的高度，需要分页 添加新的页面
        let newPaperTemplateItem=GetPaperTemplateItem(pageInfo,currentPageIndex);//添加新的页面
        // console.log("打印新的页面",newPaperTemplateItem);
        paperTemplateData.push(newPaperTemplateItem);
        paperTemplateData[paperTemplateData.length - 1].questionUiData.push(questionUiData);
      }
      // console.log("打印选择题UI数据",questionUiData);
      
    }
    //填空题
    if(questionItem.type==2)
    {
      console.log("填空题处理",questionItem);
      questionItem.w=pageInfo.mainWidth;//大题区域宽度 这里需要用内容区域宽度
      questionItem.h=GetFillBlankUiHeight(questionItem);//获取填空题的高度
      //计算填空题实际需要的高度 (需要包括标题的高度 34px)
      let requiredHeight = questionItem.h + questionTitleHeight;//填空题必定有标题  所以直接加上34px的高度
      if(remainingHeight >= requiredHeight)
      {
        //  console.log("添加填空时剩余高度大于当前题的高度，添加到当前页",questionItem);
        //剩余高度大于当前题的高度，直接添加到当前页
        paperTemplateData[paperTemplateData.length - 1].questionUiData.push(questionItem);
      }
      else
      {
        // console.log("添加填空题时剩余高度小于当前题的高度，添加到新的一页",questionItem);
        let currentPageIndex = paperTemplateData[paperTemplateData.length - 1].pageIndex;
        //剩余高度小于当前题的高度，需要分页 添加新的页面
        let newPaperTemplateItem=GetPaperTemplateItem(pageInfo,currentPageIndex);//添加新的页面
        // console.log("打印新的页面",newPaperTemplateItem);
        paperTemplateData.push(newPaperTemplateItem);
        paperTemplateData[paperTemplateData.length - 1].questionUiData.push(questionItem);
      }
      // console.log("打印填空题UI数据",questionItem);

    }
    //解答题
    if(questionItem.type==3)
    {
      
      // console.log("解答题处理",questionItem);
      //解答题 添加逻辑处理  根据解答题的总高度 以及剩余可用的高度 计算出当前页可以添加的题目的高度  然后根据剩余高度 切割解答题
      // paperTemplateData = SlicingAnswerQuestion(pageInfo, paperTemplateData, questionItem,remainingHeight);//解答题切割处理
      let answerQuestionList=questionItem.questionList;//解答题小题列表
      //循环处理解答题小题数据
      answerQuestionList.forEach((answerQuestionItem,index)=> {
        // console.log("打印解答题小题",answerQuestionItem);
        let questionUiItem={
          bigQuestionIndex: questionItem.bigQuestionIndex,//大题编号 大题索引
          questionName: questionItem.title+'-'+answerQuestionItem.questionIndex,//小题名称
          questionIndex: answerQuestionItem.questionIndex,//小题编号 小题号 小题名称
          startQuestionIndex:questionItem.startQuestionIndex,//起始题号
          endQuestionIndex:questionItem.endQuestionIndex,//结束题号
          type: 3,//题目类型  1  选择题 2.填空题 3:解答题 4.作文英 5.作文语 6.非作答区
          title: questionItem.title,//大题名称
          questionScore: answerQuestionItem.score,//每小题分数
          fullScore: questionItem.fullScore,//总分
          isShowTitle: index==0?true:false,//是否显示标题 只有解答题的第一个小题上面会显示标题
          pageIndex: 1,//页面号码
          isOver: questionItem.isOver,//是否覆盖编辑内容
          isChoose: questionItem.isChoose,//是否选做题
          chooseType: questionItem.chooseType,//选做题值  2选1 还是3选1
          editorContent:answerQuestionItem.editorContent,//编辑内容
          x: 0,//x坐标
          y: 0,//y坐标
          h: Math.max(50, answerQuestionItem.rectHeight),//高度，最小值为50,//高度
          w: pageInfo.mainWidth,//宽度
        }
        //计算解答题小题实际需要的高度 (需要包括标题的高度 34px)
        let requiredHeight = questionUiItem.h;//解答题的小题不一定有标题  所以需要根据是否显示标题来判断是否加上34px的高度
        if(questionUiItem.isShowTitle)
        {
          requiredHeight += questionTitleHeight;
        }
        //这里需要重新获取当前页的剩余高度
        let remainingHeight = GetPaperRemainingHeight(paperTemplateData[paperTemplateData.length - 1], pageInfo);
        // console.log("循环添加解答题时剩余高度",remainingHeight);
        // console.log("循环添加解答题时实际需要的高度",requiredHeight);
        if(remainingHeight >= requiredHeight)
        {
          // console.log("添加解答题时剩余高度大于当前小题的高度，添加到当前页",questionUiItem);
          //剩余高度大于当前题的高度，直接添加到当前页
          paperTemplateData[paperTemplateData.length - 1].questionUiData.push(questionUiItem);
        }
        else
        {
          // console.log("添加解答题时剩余高度小于当前小题的高度，需要把当前的小题拆分成2个 一个添加到当前页，一个添加到新页面",questionUiItem);
          const  splitQuestion1 = { ...questionUiItem, h: parseFloat(remainingHeight.toFixed(2)) };
          const  splitQuestion2 = { ...questionUiItem, h: parseFloat((requiredHeight - remainingHeight).toFixed(2)) };//实际需要的高度减去剩余的高度 就是下一页的题目的高度
          // 如果超过mainHeight，需要分割最后一个题
         if(questionUiItem.isShowTitle)
         {
          //如果显示标题 需要减去标题的高度再给到第一个切块的高度
          splitQuestion1.h -= questionTitleHeight;
         }

          splitQuestion2.isShowTitle=false;//第二个小题不显示大标题
        //  console.log("循环添加解答题时剩余高度",remainingHeight);
          //如果剩余的高度小于一定值  最小高度50 则直接给上一个题目 不拆 即标题的高度都放不下  直接添加到下一页 当前剩余的高度给上一个 或者不处理
          if(remainingHeight<50)
          {

            // console.log("如果剩余的高度小于一定值 则直接给上一个题目 不拆 即标题的高度都放不下  直接添加到下一页 当前剩余的高度给上一个 或者不处理");
            // let currentCount=currentPage.questionUiData.length;
            // currentPage.questionUiData[currentCount-1].h+=remainingHeight;
            // splitQuestion2.h=question.h;
            let currentPageIndex = paperTemplateData[paperTemplateData.length - 1].pageIndex;
            //剩余高度小于当前题的高度，需要分页 添加新的页面
            let newPaperTemplateItem=GetPaperTemplateItem(pageInfo,currentPageIndex);//添加新的页面
            // console.log("打印新的页面",newPaperTemplateItem);
            // console.log("打印当前页",paperTemplateData);
            paperTemplateData.push(newPaperTemplateItem);
            paperTemplateData[paperTemplateData.length - 1].questionUiData.push(questionUiItem);
           
          }
          else
          {
            // console.log("如果剩余的高度大于一定值 34px,拆分成2个  当前页添加第一个  新页面添加第二个");
            //拆分成2个  当前页添加第一个  新页面添加第二个
            paperTemplateData[paperTemplateData.length - 1].questionUiData.push(splitQuestion1);

            //如果第二个的高度小于多少不添加  大于20才添加 避免内容太少
            if(splitQuestion2.h>30)
            {
              //添加第二个到新的一页
              let currentPageIndex = paperTemplateData[paperTemplateData.length - 1].pageIndex;
              let newPaperTemplateItem=GetPaperTemplateItem(pageInfo,currentPageIndex);//添加新的页面
              // console.log("打印新的页面",newPaperTemplateItem);
              // console.log("打印paperTemplateData",paperTemplateData);
              paperTemplateData.push(newPaperTemplateItem);
              paperTemplateData[paperTemplateData.length - 1].questionUiData.push(splitQuestion2);
            }
            
            
          }
         
        }
        // console.log("打印解答题UI数据",questionUiItem); 
      });
      // console.log("打印paperTemplateData",paperTemplateData); 
    }

    //英语作文题
    if(questionItem.type==4)
    {
      console.log("英语作文题处理",questionItem);
      let totalWidth=pageInfo.mainWidth;//页面可用宽度
      let rowNumber=questionItem.rowCount;//行数
      let startNumber=questionItem.questionIndex;//题号

      let rowHeight=36*rowNumber+16;//单位px(9.6mm 或者 36px) 16是上下的边距 英语作文题的高度

      let questionUiItem={
          questionName: questionItem.questionName,//小题名称
          questionIndex: questionItem.questionIndex,//小题编号 小题号 小题名称
          startQuestionIndex:questionItem.questionIndex,//其实题号
          endQuestionIndex:questionItem.questionIndex,//结束题号
          type: 4,//题目类型  1  选择题 2.填空题 3:解答题 4.作文英 5.作文语 6.非作答区
          title: questionItem.title,//大题名称
          questionScore: questionItem.questionScore,//每小题分数
          rowCount:questionItem.rowCount,//行数
          fullScore: questionItem.fullScore,//总分
          isShowTitle: true,//是否显示标题
          isOver: questionItem.isOver,//是否覆盖编辑内容
          isChoose: questionItem.isChoose,//是否选做题
          editorContent:GetArticleCnContent(totalWidth,rowNumber,startNumber),
          x: 0,//x坐标
          y: 0,//y坐标
          h: rowHeight,//高度
          w: pageInfo.mainWidth,//宽度
      };

        //计算作文英语题实际需要的高度 (需要包括标题的高度 34px)
        let requiredHeight = questionUiItem.h+questionTitleHeight;
        console.log("打印作文英语题实际需要的高度",requiredHeight);
        console.log("打印剩余高度",remainingHeight);
      
        if(remainingHeight >= requiredHeight)
        {
          // console.log("添加英语作文题时剩余高度大于当前题的高度，添加到当前页",questionUiItem);
          //剩余高度大于当前题的高度，直接添加到当前页
          paperTemplateData[paperTemplateData.length - 1].questionUiData.push(questionUiItem);
        }
        else
        {
          // console.log("添加英语作文题时剩余高度小于当前小题的高度，需要把当前的小题拆分成2个 一个添加到当前页，一个添加到新页面",questionUiItem);
          console.log("打印剩余高度",remainingHeight);
          let rowCount1=Math.floor((remainingHeight- 34 - 16)/36);//向下取整 第一个切块的行数
          if(rowCount1<=0)
          {
            //第一个切块如果不足一行 则不拆分 直接插入到新页面
            // 当前页空间不足，直接添加到新页面
            let currentPageIndex = paperTemplateData[paperTemplateData.length - 1].pageIndex;
            let newPaperTemplateItem = GetPaperTemplateItem(pageInfo, currentPageIndex); // 添加新的页面
            paperTemplateData.push(newPaperTemplateItem);
            paperTemplateData[paperTemplateData.length - 1].questionUiData.push(questionUiItem);
          }
          else
          {
            console.log("打印第一个切块的行数",rowCount1);
            let rowCount2=rowNumber-rowCount1;
            console.log("打印第二个切块的行数",rowCount2)
            const  splitQuestion1 = { 
              ...questionUiItem, 
              h: 36*rowCount1+16,
              rowCount:rowCount1,
              editorContent:GetArticleCnContent(totalWidth,rowCount1,startNumber),//编辑内容,//内容重新计算
              isShowTitle:true,
            };
            const  splitQuestion2 = { 
              ...questionUiItem, 
              h: 36*rowCount2+16,
              rowCount:rowCount2,
              editorContent:GetArticleCnContent(totalWidth,rowCount2,''),//编辑内容,//内容重新计算
              isShowTitle:false,
            };//实际需要的高度减去剩余的高度 就是下一页的题目的高度
            // 如果超过mainHeight，需要分割最后一个题
            if(questionUiItem.isShowTitle)
            {
              //如果显示标题 需要减去标题的高度再给到第一个切块的高度
              splitQuestion1.h -= questionTitleHeight;
            }
            splitQuestion2.isShowTitle=false;//第二个小题不显示大标题
          
            //如果剩余的高度小于一定值 则直接给上一个题目 不拆 即标题的高度都放不下  直接添加到下一页 当前剩余的高度给上一个 或者不处理
            if(remainingHeight<34)
            {

              // console.log("如果剩余的高度小于一定值 则直接给上一个题目 不拆 即标题的高度都放不下  直接添加到下一页 当前剩余的高度给上一个 或者不处理");
              // let currentCount=currentPage.questionUiData.length;
              // currentPage.questionUiData[currentCount-1].h+=remainingHeight;
              // splitQuestion2.h=question.h;
              let currentPageIndex = paperTemplateData[paperTemplateData.length - 1].pageIndex;
              //剩余高度小于当前题的高度，需要分页 添加新的页面
              let newPaperTemplateItem=GetPaperTemplateItem(pageInfo,currentPageIndex);//添加新的页面
              // console.log("打印新的页面",newPaperTemplateItem);
              paperTemplateData.push(newPaperTemplateItem);
              paperTemplateData[paperTemplateData.length - 1].questionUiData.push(questionUiItem);
            
            }
            else
            {
              console.log("如果剩余的高度大于一定值 34px,拆分成2个  当前页添加第一个  新页面添加第二个");
              //拆分成2个  当前页添加第一个  新页面添加第二个
              paperTemplateData[paperTemplateData.length - 1].questionUiData.push(splitQuestion1);
              //添加第二个到新的一页
              let currentPageIndex = paperTemplateData[paperTemplateData.length - 1].pageIndex;
              let newPaperTemplateItem=GetPaperTemplateItem(pageInfo,currentPageIndex);//添加新的页面
              // console.log("打印新的页面",newPaperTemplateItem);
              paperTemplateData.push(newPaperTemplateItem);
              paperTemplateData[paperTemplateData.length - 1].questionUiData.push(splitQuestion2);
            }
          }
        }

    }

    //语文作文题 废弃
    if(questionItem.type==15)
    {
      console.log("语文作文题处理",questionItem);
      // GetArticleCnUiData(paperTemplateData, questionItem,pageInfo);
      let totalWidth=pageInfo.mainWidth-20;//总宽度先写死 单位px  减去20px边距 
      let totalCell=questionItem.wordNumber;//总共多少个格子 即总共字数
      let cellWidth=questionItem.cellSize;//格子宽度 单位px
      
      let rowCellCount= Math.floor(totalWidth/cellWidth);//每行总共多少个格子  需要向下取整数
      let rowTotalNumber=Math.ceil(totalCell/rowCellCount);//总共多少行 需要向上取整数
      console.log("打印总共需要添加的行数",rowTotalNumber);
     

      console.log("打印剩余的高度", remainingHeight);
      if(remainingHeight<60)
      {

        let currentPageIndex = paperTemplateData[paperTemplateData.length - 1].pageIndex;
        //剩余高度小于当前题的高度，需要分页 添加新的页面
        let newPaperTemplateItem=GetPaperTemplateItem(pageInfo,currentPageIndex);//添加新的页面
        paperTemplateData.push(newPaperTemplateItem);//插入新页面
        //这里获取新页的剩余高度
        let newPageRemainingHeight = GetPaperRemainingHeight(paperTemplateData[paperTemplateData.length - 1], pageInfo);
        console.log("打印新页面剩余高度",newPageRemainingHeight);
        //根据新页面的剩余高度计算添加的行数
        //计算可添加的作文行数
        let remainingNumber=Math.floor((newPageRemainingHeight - 34 - 45 - 10)/(cellWidth+10));//34是标题高度 45是顶部内容高度 10是底部边距 以及格子上下之间的间距
        console.log("打印可添加的行数",remainingNumber);
      
        
      }

      console.log("打印剩余可用的高度",remainingHeight);
      //计算可添加的作文行数
      let remainingNumber=Math.floor((remainingHeight - 34 - 45 - 10)/(cellWidth+10));//34是标题高度 45是顶部内容高度 -10是底部边距  以及 cellWidth+10格子上下之间的间距
      if(remainingNumber<=0)
      {
        remainingNumber=0;
      }
      let pageTotalNumber=Math.floor((pageInfo.mainHeight-45-10)/(cellWidth+10));//9是标题高度 12是顶部边距 4是底部边距
      console.log("打印剩余可用的行数",remainingNumber);
      console.log("打印一页可显示的行数",pageTotalNumber)

      let cellRowList=[];
      for(let i=0;i<rowTotalNumber;i++)
      {
          let cellList=[];
          
          for(let j=0;j<rowCellCount;j++)
          {
              let currentNumber=i*rowCellCount+j+1;
              let cellItem={
                  width:cellWidth,
                  height:cellWidth,
                  cellIndex:j+1,
                  rowIndex:i+1,
                  numberIndex:currentNumber,
                  isShowNumber:currentNumber%100===0,//是否显示数字 取余100 等于0 则显示数字
                  islast:j==rowCellCount-1,//是不是最后一个
              }
              cellList.push(cellItem);
          }
          let cellRowItem={
              cellList:cellList,
              rowIndex:i+1,
          };
          cellRowList.push(cellRowItem);
      }

      // console.log("questionItem",questionItem);
      
      let resultList=SplitArray(cellRowList,remainingNumber,pageTotalNumber);
      console.log("打印拆分的结果数组",resultList);

      resultList.forEach((item,index)=>{
          let rowCount=item.length;
          let rowHeight=(cellWidth+10)*rowCount+45+10;//单位毫米 语文作文题的高度  2 mm 上下行之间的边距(2.5是算上边框线)  12 mm 顶部边距 4 底部边距
          rowHeight=index===0?rowHeight+34:rowHeight;//第一个需要加上标题的高度
          let questionUiItem={
              questionName: questionItem.questionName,//小题名称
              questionIndex: questionItem.questionIndex,//小题编号 小题号 
              type:5,//题目类型  1  选择题 2.填空题 3:解答题 4.作文英 5.作文语 6.非作答区
              title: questionItem.title,//大题名称
              questionScore: questionItem.questionScore,//每小题分数
              wordNumber:questionItem.wordNumber,//作文字数
              cellSize:questionItem.cellSize,//表格大小
              fullScore: questionItem.fullScore,//总分
              isShowTitle: index==0?true:false,//是否显示标题
              isOver: questionItem.isOver,//是否覆盖编辑内容
              isChoose: questionItem.isChoose,//是否选做题
              chooseType: questionItem.chooseType,//2选1 还是3选1 
              x: 0,//x坐标
              y: 0,//y坐标
              h: rowHeight,//高度
              w: pageInfo.mainWidth,//宽度
              cellRowList:item,//表格数据
          };
          if (index !=0) 
          {
            //添加新的一页
            let currentPageIndex = paperTemplateData[paperTemplateData.length - 1].pageIndex;
            let newPaperTemplateItem=GetPaperTemplateItem(pageInfo,currentPageIndex);//添加新的页面
            console.log("打印新的页面",newPaperTemplateItem);
            paperTemplateData.push(newPaperTemplateItem);
            paperTemplateData[paperTemplateData.length - 1].questionUiData.push(questionUiItem);
          }
          else
          {
            //添加到当前的页面
            console.log("打印当前页面",paperTemplateData[paperTemplateData.length - 1]);
            paperTemplateData[paperTemplateData.length - 1].questionUiData.push(questionUiItem);
          }
      })
    }

    //语文作文题
    if(questionItem.type==5)
    {
      // console.log("语文作文题处理",questionItem);
      let totalWidth=pageInfo.mainWidth-20;//总宽度先写死 单位px  减去20px边距 
      let totalCell=questionItem.wordNumber;//总共多少个格子 即总共字数
      let cellWidth=questionItem.cellSize;//格子宽度 单位px
      
      let rowCellCount= Math.floor(totalWidth/cellWidth);//每行总共多少个格子  需要向下取整数
      
      // 生成所有表格行数据
      let cellRowList=[];
      for(let i=0;i<Math.ceil(totalCell/rowCellCount);i++)
      {
          let cellList=[];
          
          for(let j=0;j<rowCellCount;j++)
          {
              let currentNumber=i*rowCellCount+j+1;
              let cellItem={
                  width:cellWidth,
                  height:cellWidth,
                  cellIndex:j+1,
                  rowIndex:i+1,
                  numberIndex:currentNumber,
                  isShowNumber:currentNumber%100===0,//是否显示数字 取余100 等于0 则显示数字
                  islast:j==rowCellCount-1,//是不是最后一个
              }
              cellList.push(cellItem);
          }
          let cellRowItem={
              cellList:cellList,
              rowIndex:i+1,
          };
          cellRowList.push(cellRowItem);
      }

      // 逐页处理作文题内容
      let remainingCells = totalCell; // 剩余未处理的格子数
      let processedCells = 0; // 已处理的格子数
      let currentPageIndex = paperTemplateData.length - 1; // 当前页面索引
      let isFirstBlock = true; // 是否是第一块

      while(remainingCells > 0) {
        // 获取当前页面的剩余高度
        let currentRemainingHeight = GetPaperRemainingHeight(paperTemplateData[currentPageIndex], pageInfo);
        // console.log("打印当前页面剩余高度", currentRemainingHeight);
        
        // 如果剩余高度不够，创建新页面
        if(currentRemainingHeight < 60) {
          let newPaperTemplateItem = GetPaperTemplateItem(pageInfo, paperTemplateData[currentPageIndex].pageIndex);
          paperTemplateData.push(newPaperTemplateItem);
          currentPageIndex = paperTemplateData.length - 1;
          currentRemainingHeight = GetPaperRemainingHeight(paperTemplateData[currentPageIndex], pageInfo);
          // console.log("创建新页面，剩余高度", currentRemainingHeight);
        }

        // 计算当前页面可以放置的行数
        // 34: 标题高度, 45: 顶部边距, 10: 底部边距, (cellWidth+10): 每行高度(包含间距)
        let availableRows;//可用行数
        if(isFirstBlock) 
        {
          // 第一个块需要考虑标题高度
          availableRows = Math.floor((currentRemainingHeight - questionTitleHeight - 45 - 10)/(cellWidth + 10));
        }
        else
        {
          // 非第一个块不需要考虑标题高度
          availableRows = Math.floor((currentRemainingHeight - 45 - 10)/(cellWidth + 10));

        }
        availableRows = Math.max(0, availableRows); // 确保不为负数
        // console.log("当前页面可放置行数", availableRows);

        
        // 确保不超过剩余行数
        let rowsToPlace = Math.min(availableRows, Math.ceil(remainingCells / rowCellCount));
        rowsToPlace = Math.max(0, rowsToPlace); // 确保不为负数
        
        // 如果当前页面放不下任何行，创建新页面
        if(rowsToPlace === 0) 
        {
          let newPaperTemplateItem = GetPaperTemplateItem(pageInfo, paperTemplateData[currentPageIndex].pageIndex);
          paperTemplateData.push(newPaperTemplateItem);
          currentPageIndex = paperTemplateData.length - 1;
          continue; // 重新计算新页面的可用空间
        }
        
        // 获取当前要放置的行数据
        let currentRows = cellRowList.slice(
          Math.floor(processedCells / rowCellCount), 
          Math.floor(processedCells / rowCellCount) + rowsToPlace
        );
        
        // 计算当前块的高度
        let blockHeight = (cellWidth + 10) * rowsToPlace + 45 + 10; // 行高+顶部边距+底部边距
        // 只有第一个块才加上标题高度
        if(isFirstBlock) 
        {
          blockHeight += questionTitleHeight; // 标题高度
        }
        
        // 创建题目UI数据
        let questionUiItem = {
            questionName: questionItem.questionName,//小题名称
            questionIndex: questionItem.questionIndex,//小题编号 小题号 
            type: 5,//题目类型  1  选择题 2.填空题 3:解答题 4.作文英 5.作文语 6.非作答区
            title: questionItem.title,//大题名称
            questionScore: questionItem.questionScore,//每小题分数
            wordNumber: questionItem.wordNumber,//作文字数
            cellSize: questionItem.cellSize,//表格大小
            fullScore: questionItem.fullScore,//总分
            isShowTitle: isFirstBlock,//是否显示标题
            isOver: questionItem.isOver,//是否覆盖编辑内容
            isChoose: questionItem.isChoose,//是否选做题
            chooseType: questionItem.chooseType,//2选1 还是3选1 
            x: 0,//x坐标
            y: 0,//y坐标
            h: blockHeight,//高度
            w: pageInfo.mainWidth,//宽度
            cellRowList: currentRows,//表格数据
        };
        
        // 添加到当前页面
        paperTemplateData[currentPageIndex].questionUiData.push(questionUiItem);
        
        // 更新计数器
        let cellsInRows = rowsToPlace * rowCellCount;
        processedCells += cellsInRows;
        remainingCells -= cellsInRows;
        
        // console.log(`放置了${rowsToPlace}行，剩余${remainingCells}个格子`);
        // 第一个块已处理完毕，后续块都不显示标题
        isFirstBlock = false;
        // 如果还有剩余内容，准备下一页
        if(remainingCells > 0) 
        {
          let newPaperTemplateItem = GetPaperTemplateItem(pageInfo, paperTemplateData[currentPageIndex].pageIndex);
          paperTemplateData.push(newPaperTemplateItem);
          currentPageIndex = paperTemplateData.length - 1;
        }
      }
    }

    //非作答区
    if(questionItem.type==6)
    {
      console.log("非作答区处理",questionItem);
      console.log("打印剩余的高度", remainingHeight);
      let questionUiItem={
          questionName: questionItem.questionName,//小题名称
          questionIndex: questionItem.questionIndex,//小题编号 小题号 小题名称
        
          type: 6,//题目类型  1  选择题 2.填空题 3:解答题 4.作文英 5.作文语 6.非作答区
          title: questionItem.title,//大题名称
          questionScore: questionItem.questionScore,//每小题分数
          fullScore: questionItem.fullScore,//总分
          isShowTitle: false,//是否显示标题
          x: 0,//x坐标
          y: 0,//y坐标
          h: remainingHeight-20,//高度 减去10是与上面内容的间隔10px
          w: pageInfo.mainWidth,//宽度
      };
      if(remainingHeight<60)
      {
        //小于34  添加到新的一页里
        let currentPageIndex = paperTemplateData[paperTemplateData.length - 1].pageIndex;
        let newPaperTemplateItem=GetPaperTemplateItem(pageInfo,currentPageIndex);//添加新的页面
        newPaperTemplateItem.isShowTitle=false;//非作答区域页面不显示标题
        newPaperTemplateItem.isShowUserInfo=false;//非作答区页面不显示用户信息
        questionUiItem.h=pageInfo.mainHeight;
        paperTemplateData.push(newPaperTemplateItem);
        paperTemplateData[paperTemplateData.length - 1].questionUiData.push(questionUiItem);
      }
      else
      {
        //添加到当前的页面
        paperTemplateData[paperTemplateData.length - 1].questionUiData.push(questionUiItem);
      }
      
      

    }

     
   
   
    
  });
  console.log("打印处理完所有试题后的paperTemplateData",paperTemplateData);
  return paperTemplateData;
}



//根据pageInfo  获取模板初始数据 定位点 宽度 长度 标题等信息
export function GetPaperTemplateObject(pageInfo,pageIndex)
{
  let templateObject={};
  let isShowTitle=false;//是否显示标题区
  let isShowUserInfo=false;//是否显示学生信息区
  let leftMargin=57;//左边距  主题内容到左边的距离
  let topMargin=56;//上边距  主题内容到上边的距离
  // pageCount: 1, //总页数 初始默认1
  // markType: 1, //阅卷方式 1:网阅卷2:纸阅卷
  // positionType: 2, //定位方式 1二维码 2:黑块
  // paperLayout: '1', //页面布局1:A4, 2:A32, 3:A33  A4 一栏 A32:两栏 A33:三栏
  // paperCardType:'A4',//纸张类型   一栏是A4    二栏 三栏是A3   
  // checkedSafeLine: false, //是否密封线
  // pringType: "1", //印刷方式 1-单面,2-双面印刷
  // width: 794, //页面整体宽度 使用像素 宽度 794  
  // height: 1123,//页面整体高度 使用像素 高度 1123
  // mainWidth: 678, //内容区域宽度 794-114-2   114为左右两边的边距 2为左右两边线的宽度
  // stInfoType: 1, //学生信息区样式模式 1:标准模式(展示贴条码) 2:极简模式 不展示贴条码  标准模式：65.6， 极简模式：0
  // mainHeight: 1010,//页面内容区域高度 1123-113 113为上下两边的边距  一栏的计算方式  其他二栏 三栏在重新计算 1010 正常内容区域像素
  // idCardType: 2, //学号填涂类型 1:条形码 2:涂块
  // idCardNumberLen: 8, //涂块位数
  // studentInfoHeight: 233, //学生信息区高度  233px  可配置
  // paperTitleHeight: 100,//标题区域高度 100px  可配置

  //一栏的情况
  if(pageInfo.paperLayout==1)
  {

    //判断是单面印刷还是双面印刷
    if(pageInfo.pringType==1)
    {
      // console.log("单面印刷,每页都有标题区 以及学生信息区");
      //单面  每页都有标题区 以及学生信息区
      isShowTitle=true;
      isShowUserInfo=true;
    }
    else
    {
      // console.log("双面印刷,只有奇数页有标题区 以及学生信息区",pageIndex%2);
      //双面  只有奇数页有标题区  其他页都没有
      if(pageIndex % 2 === 1)
      {
        isShowTitle=true;
        isShowUserInfo=true;
      }
      else
      {
        isShowTitle=false;
        isShowUserInfo=false;
      }
    }
    //一栏
    leftMargin=57;
    templateObject={
      location: [
        {
          x: 0, //横坐标
          y: 0, //y坐标
          w: 25,//宽
          h: 15,//高
          name: '左上角定位',
          url: '',//二维码地址
        },
        {
          x: 0,
          y: 1057,
          w: 25,
          h: 15,
          name: '左下角定位',
          url: '',//二维码地址
        },
        {
          x: 708,
          y: 0,
          w: 25,
          h: 15,
          name: '右上角定位',
          url: '',//二维码地址
        },
        {
          x: 708,
          y: 1057,
          w: 25,
          h: 15,
          name: '右下角定位',
          url: '',//二维码地址
        },


      ],//定位块信息
      isShowTitle: isShowTitle,//是否显示标题
      isShowUserInfo: isShowUserInfo,//是否显示用户姓名区
      left:leftMargin,
      top:topMargin,
      paperTitle: {
        x: '',
        y: '',
        value: pageInfo.pageTitle,
      },
      matterMessage: `
                    1、答题前请将姓名、班级、考场、准考证号填写清楚。<br />
                    2、客观题答案必须使用2B铅笔填涂，修改时用橡皮擦干净。<br />
                    3、主观题使用黑色签字笔书写。<br />
                    4、必须在题号对应的答题区域内作答，超出答题区域书写无效。<br />
                    5、保持卷面整洁、完整。
                    `,//注意事项内容
      pageIndex: pageIndex,//当前页码
      questionUiData: [],//试卷内容列表
    };
    
  }
  else if(pageInfo.paperLayout==2)
  {
    //二栏的情况
    //判断是单面印刷还是双面印刷
    if(pageInfo.pringType==1)
    {
      // console.log("二栏单面印刷，奇数页有标题区 以及学生信息区");
      //两栏单面印刷  奇数页有标题区 以及学生信息区
      if(pageIndex % 2 === 1)
      {
        isShowTitle=true;
        isShowUserInfo=true;
      }
      else
      {
        isShowTitle=false;
        isShowUserInfo=false;
      }
    }
    else
    {
      // console.log("二栏双面印刷,只有 1  5  9 13 等有标题区 以及学生信息区",pageIndex%2);
      //双面  只有奇数页有标题区  其他页都没有
      if((pageIndex - 1) % 4 === 0)
      {
        isShowTitle=true;
        isShowUserInfo=true;
      }
      else
      {
        isShowTitle=false;
        isShowUserInfo=false;
      }
    }
    let locationList=[];
    // console.log("判断是第几页：打印当前页码",pageIndex);
    //判断是第几页
    if(pageIndex % 2 === 1) 
    {
      // 奇数页：使用左上、左下定位块
      locationList = [
        {
          x: 0, //横坐标
          y: 0, //y坐标
          w: 25,//宽
          h: 15,//高
          name: '左上角定位',
          url: '',//二维码地址
        },
        {
          x: 0,
          y: 1057,
          w: 25,
          h: 15,
          name: '左下角定位',
          url: '',//二维码地址
        },
      ];
      leftMargin = 84;//57+27
    } else 
    {
      // 偶数页：使用右上、右下定位块
      locationList = [
        {
          x: 708,
          y: 0,
          w: 25,
          h: 15,
          name: '右上角定位',
          url: '',//二维码地址
        },
        {
          x: 708,
          y: 1057,
          w: 25,
          h: 15,
          name: '右下角定位',
          url: '',//二维码地址
        },
      ];
      leftMargin = 30;//57-27
    }
    templateObject={
      location: locationList,//定位块信息
      isShowTitle: isShowTitle,//是否显示标题
      isShowUserInfo: isShowUserInfo,//是否显示用户姓名区
      left:leftMargin,
      top:topMargin,
      paperTitle: {
        x: '',
        y: '',
        value: pageInfo.pageTitle,
      },
      matterMessage: `
                    1、答题前请将姓名、班级、考场、准考证号填写清楚。<br />
                    2、客观题答案必须使用2B铅笔填涂，修改时用橡皮擦干净。<br />
                    3、主观题使用黑色签字笔书写。<br />
                    4、必须在题号对应的答题区域内作答，超出答题区域书写无效。<br />
                    5、保持卷面整洁、完整。
                    `,//注意事项内容
      pageIndex: pageIndex,//当前页码
      questionUiData: [],//试卷内容列表
    };
  }
  
  return templateObject;
}


/**
 * 根据编辑器的宽度、填空题数量、每行显示个数和起始题号生成填空题的内容。
 *
 * @param {number} totalWidth - 编辑器的总宽度（px）
 * @param {number} groupNumber - 每行显示的题目个数
 * @param {number} questionNumber - 总共的题目数量
 * @param {number} startNumber - 起始题号
 * @returns {string} 返回包含填空题内容的HTML字符串
 */
export function GetFillBlankContent(totalWidth, groupNumber, questionNumber, startNumber) {
  // 计算每行填空题的宽度
  const fillWidth = 7;//一个空格的宽度 大概 7.46  默认7px吧
  let fillBankWidth = ((totalWidth - 20) / groupNumber) - 15 - 15; // 20 为外边框两边边距的宽度 15 为小标题(2个数字)占用的宽度 15为小题之间间隔的距离
  let count = parseInt(fillBankWidth / fillWidth); // 计算一个填空题&nbsp;的数量
  let content = '';
  let questionList = GetQuestionList(groupNumber, questionNumber, startNumber);
  questionList.forEach(row => {
    let rowStr = '<p style="text-align: left;">';//编辑器内容靠左
    row.list.forEach(item => {
      let fillBankArr = item + '.<u>';//题号
      let numStr=item.toString();
      // 题号是一位数 加上一个空格
      if(numStr.length === 1)
      {
        fillBankArr = item + '&nbsp;.<u>';//题号
      }
      else
      {
        fillBankArr = item + '.<u>';//题号
      }
      
      for (let i = 0; i < count; i++) {
        fillBankArr += '&nbsp;';
      }
      fillBankArr += '</u>';
      rowStr += fillBankArr + '&nbsp;&nbsp;';
    });
    rowStr += '</p>';
    content += rowStr;
  });
  return content;//返回填空题的内容
}

/**
 * 根据编辑器的宽度(mm单位)、填空题数量、每行显示个数和起始题号生成填空题的内容。
 *
 * @param {number} totalWidth - 编辑器的总宽度（单位mm）
 * @param {number} groupNumber - 每行显示的题目个数
 * @param {number} questionNumber - 总共的题目数量
 * @param {number} startNumber - 起始题号
 * @returns {string} 返回包含填空题内容的HTML字符串
 */
export function GetFillBlankContentMM(totalWidth, groupNumber, questionNumber, startNumber) {
  // 计算每行填空题的宽度
  
  const fillWidth = 1.9;//一个空格的宽度 大概1.9mm  
  let fillBankWidth = ((totalWidth - 1.7*2) / groupNumber) - 2.5 - 3.8; // 1.7*2 为外边框两边边距的宽度 2.54 为小标题(2个数字)占用的宽度 2.54为小题之间间隔的距离
  let count = parseInt(fillBankWidth / fillWidth); // 计算一个填空题&nbsp;的数量
  let content = '';
  let questionList = GetQuestionList(groupNumber, questionNumber, startNumber);
  questionList.forEach(row => {
    let rowStr = '<p style="text-align: left;">';//编辑器内容靠左
    row.list.forEach(item => {
      let fillBankArr = item + '.<u>';//题号
      for (let i = 0; i < count; i++) {
        fillBankArr += '&nbsp;';
      }
      fillBankArr += '</u>';
      rowStr += fillBankArr + '&nbsp;&nbsp;';
    });
    rowStr += '</p>';
    content += rowStr;
  });
  
  return content;//返回填空题的内容
}

/**
 * 根据编辑器的宽度、英文的总行数和起始题号生成英文作文的html内容。
 *
 * @param {number} totalWidth - 编辑器的总宽度（px）
 * @param {number} rowNumber - 英文的总行数
 * @param {number} startNumber - 起始题号
 * @returns {string} 返回英文作文内容的HTML字符串
 */
export function GetArticleCnContent(totalWidth, rowNumber, startNumber) {
  // 计算英文作文每行的宽度
  const fillWidth = 7.075;//一个空格的宽度 大概7.075px  
  let count = parseInt((totalWidth - 20) / fillWidth); // 20 两边边距的宽度 15 为小题占用的宽度 15为小题之间间隔的距离
  console.log("打印总宽度", totalWidth);
  // let count =93;
  console.log("打印总共的行数", rowNumber);
  console.log("打印每行的空格数量", count);
  let content = '';

  for (let i = 0; i < rowNumber; i++) {
    let rowStr = '<p>';//编辑器内容靠左
    if (i == 0) 
    {
      let num=0;
      //判断第一行是否显示小题号
      if(startNumber)
      {
        rowStr = rowStr + startNumber + '.<u>'
        // 如果 有标题// 第一行 加上小题号 要减去3个空格的位置
        let startNumberLength=startNumber.toString().length;
        if(startNumberLength==1)
        {
          //标题一位数 减去2个空格
          num=2;
        }
        else
        {
          //标题两位数 减去3个空格
          num =3;
        }
      }
      else
      {
        rowStr = rowStr  + '<u>'
        num=0;
      }
      for (let j = 0; j < (count - num); j++) 
      {
          rowStr += '&nbsp;';
      }
    }
    else {
      rowStr = rowStr + '<u>'
      for (let j = 0; j < count; j++) 
      {
        rowStr += '&nbsp;';
      }
    }

    rowStr += '</u></p>';
    // console.log("打印第" + i + "行的内容", rowStr);
    content += rowStr;
  }
  return content;//返回作文编辑器的内容
}
/**
 * 根据编辑器的宽度、英文的总行数和起始题号生成英文作文的html内容。
 *
 * @param {number} totalWidth - 编辑器的总宽度（单位mm）
 * @param {number} rowNumber - 英文的总行数
 * @param {number} startNumber - 起始题号
 * @returns {string} 返回英文作文内容的HTML字符串
 */
export function GetArticleCnContentMM(totalWidth, rowNumber, startNumber) {
  // 计算每行填空题的宽度
  
  const fillWidth = 1.9;//一个空格的宽度 大概1.9mm  
  let count = parseInt((totalWidth - 1.7*2) / fillWidth); // 1.7*2 两边边距的宽度 15 为小题占用的宽度 15为小题之间间隔的距离
  // console.log("打印总共的行数", rowNumber);
  // console.log("打印每行的空格数量", count);
  let content = '';
  for (let i = 0; i < rowNumber; i++) {
    let rowStr = '<p ">';//编辑器内容靠左
    if (i == 0) {
      if(startNumber)
      {
        rowStr = rowStr + startNumber + '.<u>'
        // 第一行 加上小题号 要减去3个空格的位置
        for (let j = 0; j < (count - 3); j++) {
          rowStr += '&nbsp;';
        }
      }
      else
      {
        rowStr = rowStr + '<u>'
        // 无标题 第一行 不用减去3个空格的位置
        for (let j = 0; j < count; j++) {
          rowStr += '&nbsp;';
        }
      }
      
      
    }
    else {
      rowStr = rowStr + '<u>'
      for (let j = 0; j < count; j++) {
        rowStr += '&nbsp;';

      }
    }

    rowStr += '</u></p>';
    // console.log("打印第" + i + "行的内容", rowStr);
    content += rowStr;
  }
  return content;//返回作文的内容
}

/**
 * 获取填空题的 questionList
 * 根据每行显示个数（groupNumber）、填空题的数量（questionNumber）和起始题号（startNumber）生成行列表数据。
 *
 * @param {number} groupNumber - 每行显示的题目个数
 * @param {number} questionNumber - 总共的题目数量
 * @param {number} startNumber - 起始题号
 * @returns {Array<Object>} 返回一个包含各行题号的对象数组
 */
export function GetQuestionList(groupNumber, questionNumber, startNumber) {

  let questionList = [];
  let row = Math.ceil(questionNumber / groupNumber);//行数
  for (let i = 0; i < row; i++) {
    let list = [];
    let endNumber = startNumber + questionNumber;
    for (let j = 0; j < groupNumber; j++) {
      let num = i * groupNumber + j + startNumber;
      if (num < endNumber) {
        list.push(num);
      }
    }
    questionList.push({
      row: i + 1,
      list: list
    });
  }
  return questionList;
}



/**
 * 获取选择题的 ui数据 px单位
 * 根据每行显示个数（groupNumber）、填空题的数量（questionNumber）和起始题号（startNumber）生成行列表数据。
 *
 * @param {number} groupNumber - 每组题目数量
 * @param {number} questionNumber - 小题数量
 * @param {string} questionDirection - 题号方向  vertical 竖向  
 * @param {number} answerNumber - 答案数量 
 * @param {number} startQuestionIndex - 起始题号
 * @param {number} containerWidth - 容器宽度
 * @returns {Array<Object>} 返回一个页面显示选择题的ui数据
 */
export function GetChooseUiData(questionData)
{
      // console.log("打印选择题数据",questionData);
      let newQuestionData=JSON.parse(JSON.stringify(questionData));
      console.log("打印newQuestionData",newQuestionData);
      let questionNumber = questionData.questionNumber;//题目数量
      let startQuestionIndex = questionData.startQuestionIndex;//起始题号
      let endQuestionIndex = startQuestionIndex + (questionNumber - 1);//结束题号
      let groupNumber = questionData.groupNumber;//每组题目数量
      let questionDirection =questionData.questionDirection;//题号方向
      let answerNumber = questionData.answerNumber;//答案数量
      const containerWidth = questionData.w;//容器的可用宽度
      const lettersArr=['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P'];
      const answerWidth = 20;//答案和题目的宽度都是5mm 18px
      const answerHeight = 15;//默认高度4mm 15px
      const answerBlank=5;//答案之间左右的间距 5px
      const answerUpDown=5;//答案上下的间距 5px
      const groupBlank=10;//每组之间的间距 10px
      let questionUiData = [];//返回的页面ui数据
      let chooseHeight=[];//选择题的高度
      // 题号竖向
      if (questionDirection == 'vertical') {

        // 计算每行有多少个列，如果有余数则加1  px 像素 答案之间的间距是answerBlank  每组题目之间的间距是groupBlank
        //groupWidth 组的宽度= 答案宽度*(答案数量+1)+答案数量*答案间距 注：答案数量+1是因为小题跟答案的长宽是一致的
        let groupWidth = answerWidth * (answerNumber + 1) + answerNumber*answerBlank;
        console.log("打印每组的宽度", groupWidth);
        let totalwidth = containerWidth - 20;//总宽度 20 为两边边距的距离 20px
        console.log("打印总宽度", totalwidth);
        let rowCount = Math.floor(totalwidth / (groupWidth+groupBlank));//每行显示数量 向下取整数  总宽度除以组宽+间距宽
        console.log("打印每行显示数量", rowCount);
        let groupCount = Math.ceil(questionNumber / groupNumber);//总组数  需要向上取整  不够5个也是一组
        console.log("打印组数,groupCount", groupCount);
        let height = 0;
        
        // 计算当前组应该包含的题目数量
        for (let i = 0; i < groupCount; i++) {
          let groupObj = {
            groupName: `Group_${i + 1}`,
            questionlist: []
          };
          
          for (let j = 0; j < groupNumber; j++) {
            let currentQuestionIndex = startQuestionIndex + j + i * groupNumber;
            if (currentQuestionIndex <= endQuestionIndex) 
            {
              let answerList = [];
              for(let a=0;a<answerNumber;a++)
              {
                let answerObj={
                  answerName:lettersArr[a],//答案名称  ABCD这些
                  answerNumber:a+1, // 答案序号
                  x:groupBlank+answerWidth+answerBlank+(i%rowCount)*(groupWidth+groupBlank)+a*(answerWidth+answerBlank),//相对外边框容器的坐标 计算方式  第一个3 距离边框的边距 j%rowCount 取余 用余数来乘以每组的宽度(j%rowCount)*groupWidth 加上组与组之间的间距3  也需要用取余乘以3 (j%rowCount)*3 
                  y:groupBlank+j*(answerHeight+answerUpDown)+Math.floor(i/rowCount)*(answerHeight*groupNumber+groupBlank),//同下面标题题号的坐标
                  w: answerWidth,
                  h: answerHeight
                }
                
                console.log(`打印第${i+1}组第${j+1}行第${a+1}个答案的数据`, answerObj);
                answerList.push(answerObj);
              }
              let questionObj = {
                name: currentQuestionIndex,
                score: 2,
                answerNumber: answerNumber, // 假设每个题目的答案数量都是4
                answerList:answerList,//答案列表
                x:10+(i%rowCount)*groupWidth,//这个10是左右边距
                y:10+j*answerHeight+Math.floor(i/rowCount)*(answerHeight*groupNumber+10),//第一个10是上下边距
                w: answerWidth,
                h: answerHeight
              };
              groupObj.questionlist.push(questionObj);
            }
          }
          questionUiData.push(groupObj);

        }
        console.log("打印选择题题目ui数据", questionUiData);
        //按组计算总共有多少行
        let groupRowCount =Math.ceil((questionUiData.length/rowCount));
        console.log("打印总共有多少行", groupRowCount);
        height=groupRowCount*(answerHeight*groupNumber+groupNumber*answerUpDown)+groupRowCount*10;//这里10是每行上下间距的高度
        console.log("打印总高度", height);
        chooseHeight = height+10;//10*2是上下边距的距离

        //如果余数等于1  代表最后一组行只有一组  判断当前组的数量是多少 不满5个减去少的
        if(questionUiData.length%rowCount==1)
        {
          if(questionUiData[questionUiData.length-1].questionlist.length<groupNumber)
          {
            chooseHeight-=(groupNumber-questionUiData[questionUiData.length-1].questionlist.length)*(answerHeight+answerUpDown);
          }
        }
      }
      //题号横向排列
      if (questionDirection == 'horizontal') {

        // 计算每行有多少个列，如果有余数则加1
        //groupWidth 组的宽度= 答案宽度*(答案数量+1)+答案数量*答案间距+组间距
        let groupWidth = answerWidth * (answerNumber + 1) + answerNumber * answerBlank;//单位mm  answerNumber*1 是答案之间的间距1mm  3是每组之间的间距3mm
        let totalwidth = containerWidth - 20;//总宽度 12 为两边边距的距离
        console.log("总宽度", totalwidth);
        console.log("横着一组的宽度groupWidth", groupWidth);
        let rowCount = Math.floor(totalwidth / groupWidth);//每行显示数量 向下取整数  
        let groupTotal = groupNumber * rowCount;

        let groupCount = Math.ceil(questionNumber / groupTotal);//计算有多少个组，如果有余数则加1

        console.log("打印组数,groupCount", groupCount);
        console.log("打印每行多少列", rowCount);
        let height = 0;
        for (let i = 0; i < groupCount; i++) {
          let groupObj = {
            groupName: `Group_${i + 1}`,
            questionlist: []
          };
          let groupHeight = 0;
          for (let j = 0; j < groupTotal; j++) {
            let currentQuestionIndex = startQuestionIndex + j + i * groupTotal;
            if (currentQuestionIndex <= endQuestionIndex) {
              let answerList = [];
              for(let a=0;a<answerNumber;a++)
              {
                let answerObj={
                  answerName:lettersArr[a],//答案名称  ABCD这些
                  answerNumber:a+1, // 答案序号
                  x:groupBlank+(j%rowCount)*groupWidth+(j%rowCount)*answerWidth+answerBlank+a*(answerWidth+answerBlank),//相对外边框容器的坐标 计算方式  第一个3 距离边框的边距 j%rowCount 取余 用余数来乘以每组的宽度(j%rowCount)*groupWidth 加上组与组之间的间距3  也需要用取余乘以3 (j%rowCount)*3 
                  y:groupBlank+Math.floor(j/rowCount)*(answerHeight+answerUpDown)+i*(answerHeight*groupNumber+groupBlank),//同下面标题题号的坐标
                  w: answerWidth,
                  h: answerHeight
                }
                console.log(`打印第${i+1}组第${j+1}个第${a+1}个答案的数据`, answerObj);
                answerList.push(answerObj);
              }
              let questionObj = {
                name: currentQuestionIndex,
                score: 2,//小题分数
                answerNumber: answerNumber, // 答案数量
                answerList:answerList,//ABCD答案列表
                x:groupBlank+(j%rowCount)*groupWidth,//x坐标 计算方式  第一个3 距离边框的边距 j%rowCount 取余 用余数来乘以每组的宽度(j%rowCount)*groupWidth 加上组与组之间的间距3  也需要用取余乘以3 (j%rowCount)*3 
                y:0.5+groupBlank+Math.floor(j/rowCount)*answerHeight+i*(answerHeight*groupNumber+groupBlank),//y坐标  计算方式 第一个3 距离顶部边框的间距  Math.floor(j/rowCount)  必须用商向下取整 计算出是第几行 再乘以答案的高度  i*3 是组与组之间的间距3mm
                w: answerWidth,
                h: answerHeight
              };
              groupObj.questionlist.push(questionObj);
              groupHeight += questionObj.h;
            }

          }
          questionUiData.push(groupObj);

        }
        if (questionUiData.length <= 1) 
        {
          //如果只有一组 找到行数最高的那一列 并计算出高度
          let maxRowCount = Math.ceil(questionNumber / rowCount);
          height = (answerHeight+answerUpDown) * maxRowCount - answerUpDown;
          chooseHeight = height + 10+10;//上边距的距离 
          
        }
        else
        {
          
          //如果有多组 计算最后一组行数最高的行数 并计算出高度
          height=(questionUiData.length-1)*((answerHeight+answerUpDown)*groupNumber);//除了最后一组的高度
          let lastQuestionlist=questionUiData[questionUiData.length-1].questionlist;
          let lastQuestionCount=lastQuestionlist.length;
          let lastMaxRowCount = Math.ceil( lastQuestionCount/ rowCount);
          height+=(answerHeight+answerUpDown)*lastMaxRowCount;
          chooseHeight = (questionUiData.length-1)*10+height + 10;//3*2是上下边距的距离 (questionUiData.length-1)*3 是上下组之间的间距
        }

      }
      let allQuestionList=[];//把所有小题的数据取出来 
      questionUiData.forEach(item => {
        item.questionlist.forEach(questionItem => {
          allQuestionList.push(questionItem);
        })
      });


      newQuestionData.h=chooseHeight;//加上底部边缘 的边界距离
      newQuestionData.questionList=allQuestionList;
      newQuestionData.questionUiData=questionUiData;
      // console.log("打印allQuestionList", allQuestionList);
      // console.log("打印questionUiData", questionUiData);
      // console.log("打印传进来的questionData", newQuestionData);
      // console.log("计算选择题的高度", chooseHeight)
    return newQuestionData;
}

/**
 * 获取选择题的 ui数据 mm单位
 * 根据每行显示个数（groupNumber）、填空题的数量（questionNumber）和起始题号（startNumber）生成行列表数据。
 *
 * @param {number} groupNumber - 每组题目数量
 * @param {number} questionNumber - 小题数量
 * @param {string} questionDirection - 题号方向  vertical 竖向  
 * @param {number} answerNumber - 答案数量 
 * @param {number} startQuestionIndex - 起始题号
 * @param {number} containerWidth - 容器宽度
 * @returns {Array<Object>} 返回一个页面显示选择题的ui数据
 */
export function GetChooseUiDataMm(questionData)
{
      console.log("打印选择题数据",questionData);
      let newQuestionData=JSON.parse(JSON.stringify(questionData));
      console.log("打印newQuestionData",newQuestionData);
      let questionNumber = questionData.questionNumber;//题目数量
      let startQuestionIndex = questionData.startQuestionIndex;//起始题号
      let endQuestionIndex = startQuestionIndex + (questionNumber - 1);//结束题号
      let groupNumber = questionData.groupNumber;//每组题目数量
      let questionDirection =questionData.questionDirection;//题号方向
      let answerNumber = questionData.answerNumber;//答案数量
      const containerWidth = questionData.w;//容器的可用宽度
      const lettersArr=['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P'];
      const answerWidth = 5;//答案和题目的宽度都是5mm
      const answerHeight = 4;//默认高度4mm
      let questionUiData = [];//返回的页面ui数据
      let chooseHeight=[];//选择题的高度
      // 题号竖向
      if (questionDirection == 'vertical') {

        // 计算每行有多少个列，如果有余数则加1
        let groupWidth = answerWidth * (answerNumber + 1) + answerNumber * 1+3;//单位mm  answerNumber*1 是答案之前的间距1mm  3是每组之间的间距3mm
        let totalwidth = containerWidth - 12;//总宽度 12 为两边边距的距离
        let rowCount = Math.floor(totalwidth / groupWidth);//每行显示数量 向下取整数  

        let groupCount = Math.ceil(questionNumber / groupNumber);//总组数  需要向上取整  不够5个也是一组
        console.log("打印组数,groupCount", groupCount);
        let height = 0;
        
        // 计算当前组应该包含的题目数量
        for (let i = 0; i < groupCount; i++) {
          let groupObj = {
            groupName: `Group_${i + 1}`,
            questionlist: []
          };
          
          for (let j = 0; j < groupNumber; j++) {
            let currentQuestionIndex = startQuestionIndex + j + i * groupNumber;
            if (currentQuestionIndex <= endQuestionIndex) 
            {
              let answerList = [];
              for(let a=0;a<answerNumber;a++)
              {
                let answerObj={
                  answerName:lettersArr[a],//答案名称  ABCD这些
                  answerNumber:a+1, // 答案序号
                  x:0.2+3+(i%rowCount)*groupWidth+answerWidth+0.5+a*(answerWidth+1),//相对外边框容器的坐标 计算方式  第一个3 距离边框的边距 j%rowCount 取余 用余数来乘以每组的宽度(j%rowCount)*groupWidth 加上组与组之间的间距3  也需要用取余乘以3 (j%rowCount)*3 
                  y:0.5+3+j*answerHeight+Math.floor(i/rowCount)*(answerHeight*groupNumber+3),//同下面标题题号的坐标
                  w: answerWidth,
                  h: answerHeight
                }
                answerList.push(answerObj);
              }
              let questionObj = {
                name: currentQuestionIndex,
                score: 2,
                answerNumber: answerNumber, // 假设每个题目的答案数量都是4
                answerList:answerList,//答案列表
                x:3+(i%rowCount)*groupWidth,
                y: 0.5+3+j*answerHeight+Math.floor(i/rowCount)*(answerHeight*groupNumber+3),
                w: answerWidth,
                h: answerHeight
              };
              groupObj.questionlist.push(questionObj);
            }
          }
          questionUiData.push(groupObj);

        }

        //按组计算总共有多少行
        let groupRowCount =Math.ceil((questionUiData.length/rowCount));
        height=groupRowCount*(answerHeight*groupNumber)+(groupRowCount-1)*3;
        chooseHeight = height+3*2;
        //如果余数等于1  代表最后一组行只有一组  判断当前组的数量是多少 不满5个减去少的
        if(questionUiData.length%rowCount==1)
        {
          if(questionUiData[questionUiData.length-1].questionlist.length<groupNumber)
          {
            chooseHeight-=(groupNumber-questionUiData[questionUiData.length-1].questionlist.length)*answerHeight;
          }
        }
      }
      //题号横向排列
      if (questionDirection == 'horizontal') {

        // 计算每行有多少个列，如果有余数则加1
        let groupWidth = answerWidth * (answerNumber + 1) + answerNumber * 1+3;//单位mm  answerNumber*1 是答案之前的间距1mm  3是每组之间的间距3mm
        let totalwidth = containerWidth - 12;//总宽度 12 为两边边距的距离
        console.log("总宽度", totalwidth);
        console.log("竖着一组的宽度groupWidth", groupWidth);
        let rowCount = Math.floor(totalwidth / groupWidth);//每行显示数量 向下取整数  
        let groupTotal = groupNumber * rowCount;

        let groupCount = Math.ceil(questionNumber / groupTotal);//计算有多少个组，如果有余数则加1

        console.log("打印组数,groupCount", groupCount);
        console.log("打印每行多少列", rowCount);
        let height = 0;
        for (let i = 0; i < groupCount; i++) {
          let groupObj = {
            groupName: `Group_${i + 1}`,
            questionlist: []
          };
          let groupHeight = 0;
          for (let j = 0; j < groupTotal; j++) {
            let currentQuestionIndex = startQuestionIndex + j + i * groupTotal;
            if (currentQuestionIndex <= endQuestionIndex) {
              let answerList = [];
              for(let a=0;a<answerNumber;a++)
              {
                let answerObj={
                  answerName:lettersArr[a],//答案名称  ABCD这些
                  answerNumber:a+1, // 答案序号
                  x:3+(j%rowCount)*groupWidth+answerWidth+1+a*(answerWidth+1),//相对外边框容器的坐标 计算方式  第一个3 距离边框的边距 j%rowCount 取余 用余数来乘以每组的宽度(j%rowCount)*groupWidth 加上组与组之间的间距3  也需要用取余乘以3 (j%rowCount)*3 
                  y:0.5+3+Math.floor(j/rowCount)*answerHeight+i*(answerHeight*groupNumber+3),//同下面标题题号的坐标
                  w: answerWidth,
                  h: answerHeight
                }
                answerList.push(answerObj);
              }
              let questionObj = {
                name: currentQuestionIndex,
                score: 2,//小题分数
                answerNumber: answerNumber, // 答案数量
                answerList:answerList,//ABCD答案列表
                x:3+(j%rowCount)*groupWidth,//x坐标 计算方式  第一个3 距离边框的边距 j%rowCount 取余 用余数来乘以每组的宽度(j%rowCount)*groupWidth 加上组与组之间的间距3  也需要用取余乘以3 (j%rowCount)*3 
                y:0.5+3+Math.floor(j/rowCount)*answerHeight+i*(answerHeight*groupNumber+3),//y坐标  计算方式 第一个3 距离顶部边框的间距  Math.floor(j/rowCount)  必须用商向下取整 计算出是第几行 再乘以答案的高度  i*3 是组与组之间的间距3mm
                w: answerWidth,
                h: answerHeight
              };
              groupObj.questionlist.push(questionObj);
              groupHeight += questionObj.h;
            }

          }
          questionUiData.push(groupObj);

        }
        if (questionUiData.length <= 1) 
        {
          //如果只有一组 找到行数最高的那一列 并计算出高度
          let maxRowCount = Math.ceil(questionNumber / rowCount);
          height = answerHeight * maxRowCount;
          chooseHeight = height + 3 * 2;//3*2是上下边距的距离
          
        }
        else
        {
          
          //如果有多组 计算最后一组行数最高的行数 并计算出高度
          height=(questionUiData.length-1)*(answerHeight*groupNumber);//除了最后一组的高度
          let lastQuestionlist=questionUiData[questionUiData.length-1].questionlist;
          let lastQuestionCount=lastQuestionlist.length;
          let lastMaxRowCount = Math.ceil( lastQuestionCount/ rowCount);
          height+=answerHeight*lastMaxRowCount;
          chooseHeight = (questionUiData.length-1)*3+height + 3 * 2;//3*2是上下边距的距离 (questionUiData.length-1)*3 是上下组之间的间距
        }

      }
      let allQuestionList=[];//把所有小题的数据取出来 
      questionUiData.forEach(item => {
        item.questionlist.forEach(questionItem => {
          allQuestionList.push(questionItem);
        })
      });


      newQuestionData.h=chooseHeight+3;//加上底部边缘 的边界距离
      newQuestionData.questionList=allQuestionList;
      newQuestionData.questionUiData=questionUiData;
      // console.log("打印allQuestionList", allQuestionList);
      // console.log("打印questionUiData", questionUiData);
      // console.log("打印传进来的questionData", newQuestionData);
      // console.log("计算选择题的高度", chooseHeight)
    return newQuestionData;
}


/**
 * 获取填空题的高度 px单位
 * 根据每行显示个数（groupNumber）、填空题的数量（questionNumber）和起始题号（startNumber）生成行列表数据。
 *
 * @param {number} groupNumber - 每组题目数量
 * @param {number} questionNumber - 小题数量
 * @param {string} questionDirection - 题号方向  vertical 竖向  
 * @param {number} answerNumber - 答案数量 
 * @param {number} startQuestionIndex - 起始题号
 * @param {number} containerWidth - 容器宽度
 * @returns {Array<Object>} 返回一个页面显示选择题的ui数据
 */
export function GetFillBlankUiHeight(questionData)
{
  
  console.log("打印传进来的questionData",questionData);
  let questionNumber = questionData.questionNumber;//题目数量
  let startQuestionIndex = questionData.startQuestionIndex;//起始题号
  let groupNumber = questionData.groupNumber;//每行题目数量


  // // 计算每行填空题的宽度
  // const fillWidth = 1.8788;//一个空格的宽度 大概1.8788mm 保留4位小数  
  // let fillBankWidth = ((totalWidth - 1.6932*2) / groupNumber) - 8; // 1.6932*2 为外边框两边边距的宽度10px 2.54 为小标题(2个数字)占用的宽度 2.54为小题之间间隔的距离
  // let count = parseInt(fillBankWidth / fillWidth); // 计算一个填空题&nbsp;的数量
  
  let questionList = GetQuestionList(groupNumber, questionNumber, startQuestionIndex);
  console.log("questionList",questionList);
  let rowHeight=0;//高度计算方法  经测试  一行的高度是13.7mm (52px)  2行的高度是23.3mm(88px)  3行的高度是32.9mm(124px)  n行的高度是6.1n+2.7   (px计算是36n+16)

  rowHeight=36*questionList.length+16+2;//单位px  2是上下边框线的高度

  return parseFloat(rowHeight.toFixed(2));
}
/**
 * 获取填空题的高度 mm单位  备份
 * 根据每行显示个数（groupNumber）、填空题的数量（questionNumber）和起始题号（startNumber）生成行列表数据。
 *
 * @param {number} groupNumber - 每组题目数量
 * @param {number} questionNumber - 小题数量
 * @param {string} questionDirection - 题号方向  vertical 竖向  
 * @param {number} answerNumber - 答案数量 
 * @param {number} startQuestionIndex - 起始题号
 * @param {number} containerWidth - 容器宽度
 * @returns {Array<Object>} 返回一个页面显示选择题的ui数据
 */
export function GetFillBlankUiHeightMM(questionData)
{
  
  console.log("打印传进来的questionData",questionData);
  let newQuestionData=JSON.parse(JSON.stringify(questionData));
  let questionNumber = questionData.questionNumber;//题目数量
  let startQuestionIndex = questionData.startQuestionIndex;//起始题号
  let endQuestionIndex = startQuestionIndex + (questionNumber - 1);//结束题号
  let groupNumber = questionData.groupNumber;//每行题目数量
  const totalWidth = questionData.w;//容器的可用宽度

  // 计算每行填空题的宽度
  const fillWidth = 1.8788;//一个空格的宽度 大概1.8788mm 保留4位小数  
  let fillBankWidth = ((totalWidth - 1.6932*2) / groupNumber) - 8; // 1.6932*2 为外边框两边边距的宽度10px 2.54 为小标题(2个数字)占用的宽度 2.54为小题之间间隔的距离
  let count = parseInt(fillBankWidth / fillWidth); // 计算一个填空题&nbsp;的数量
  let content = GetFillBlankContentMM(totalWidth, groupNumber,questionNumber,startQuestionIndex);//根据mm宽度生成html内容
  console.log("打印填空题的html内容",content);
  let questionList = GetQuestionList(groupNumber, questionNumber, startQuestionIndex);
  let rowHeight=0;//高度计算方法  经测试  一行的高度是13.7mm (52px)  2行的高度是23.3mm(88px)  3行的高度是32.9mm(124px)  n行的高度是6.1n+2.7   (px计算是36n+16)

  rowHeight=9.6*questionList.length+4.1;//单位毫米
  newQuestionData.editorContent=content;
  newQuestionData.h=parseFloat(rowHeight.toFixed(2));
  return newQuestionData;
}


//获取当前模板答题卡的最大题号
export function GetQuestionMaxNumber(paperTemplateData)
{
  
  // console.log("打印当前的模板数据",paperTemplateData);
  let maxNumber=0;
  if(paperTemplateData.length>0)
  {
    paperTemplateData.forEach(item => {
      item.questionUiData.forEach(questionItem => {
        if(questionItem.endQuestionIndex>maxNumber)
        {
          maxNumber=questionItem.endQuestionIndex;
        }
      })
    });
  }
  return maxNumber;
}

//计算当前模板答题卡的剩余可用高度
export function GetPaperRemainingHeight(paperTemplateItem,pageInfo)
{

  // 创建一个副本以避免意外修改原始数据
  const paperTemplateItemCopy = JSON.parse(JSON.stringify(paperTemplateItem));
  // console.log("打印当前的模板数据",paperTemplateItemCopy);
  // console.log("计算当前模板答题卡的剩余可用高度页面信息",pageInfo);
   try {

    const questionTitleHeight=34;//大题题目标题行的高度固定是34px
    let mainHeight=pageInfo.mainHeight;//页面可用高度

    // 减去标题区域高度（如果显示）
    if(paperTemplateItem.isShowTitle)
    {
      mainHeight=mainHeight-pageInfo.paperTitleHeight;
    }
    // 减去学生信息区域高度（如果显示）
    if(paperTemplateItem.isShowUserInfo)
    {
      mainHeight=mainHeight-pageInfo.studentInfoHeight;//减去学生信息区域高度
    }
    // 计算已存在题目的总高
    let usedHeight = 0;
    const questionUiData = paperTemplateItemCopy.questionUiData;
    // console.log("questionUiData",questionUiData);
   
    if(questionUiData && questionUiData.length>0)
    {
      // console.log("questionUiData",questionUiData);
      //计算所有题目占用的高度  
      questionUiData.forEach((item, index) => {
        // console.log(`处理第${index + 1}个题目:`, item);
        // console.log("题目高度:", item.h);
        // 累加题目本身的高度
        usedHeight += item.h;
        // console.log("累加题目高度后:", usedHeight);
        
        // 如果题目需要显示标题，则加上标题高度
        if (item.isShowTitle) {
          usedHeight += questionTitleHeight; // 大题题目标题行的高度固定是34px
          // console.log("累加标题高度后:", usedHeight);
        }
        //特殊处理 语文作文题块区域 如果是当前页第一个 且不显示表头 或者和下一个题目类型不同 则需要加上间隔的10px
        if(item.type==5)
        {
          if(index==0 && item.isShowUserInfo)
          {
            usedHeight += 10; // 间隔距离10px
          }
          
        }
        
        // console.log("最终当前题目处理后高度:", usedHeight);
      });
      
    }
    // console.log("所有题目总高度:", usedHeight);
    // 剩余可用高度 = 总可用高度 - 已使用高度
    const remainingHeight = mainHeight - usedHeight - 2;//减去的2是外部边框线的距离
    //用总高度 减去 所有题目占用的高度 
    return remainingHeight;
   }catch(error){
      // console.error("计算剩余高度时发生错误:", error);
      return 0; // 发生错误时返回0，避免影响后续逻辑
   }
  
}

//根据当前页剩余可用的高度 以及需要添加的解答题的高度 切割出不同的页对应的数据
export function SlicingAnswerQuestion(pageInfo,paperTemplateData,addAnswerQuestion,remainingHeight)
{
  // console.log("打印页面信息",pageInfo);
  // console.log("打印模板数据信息",paperTemplateData);
  // console.log("打印当前要添加的题目信息",addAnswerQuestion);
  // console.log("打印剩余的高度信息",remainingHeight);

  // let remainingHeight=GetPaperRemainingHeight(paperTemplateData[paperTemplateData.length-1],pageInfo);//剩余可用高度
  let questionList=addAnswerQuestion.questionList;//解答题小题数组
  let questionUiList=[];
  questionList.forEach((item,index)=>{
    let questionUiItem={
      questionName: addAnswerQuestion.title+'-'+item.questionIndex,//小题名称
      questionIndex: item.questionIndex,//小题编号 小题号 小题名称
      startQuestionIndex:item.questionIndex,//其实题号
      endQuestionIndex:item.questionIndex,//结束题号
      type: 3,//题目类型  1  选择题 2.填空题 3:解答题 4.作文英 5.作文语 6.非作答区
      title: addAnswerQuestion.title,//大题名称
      questionScore: addAnswerQuestion.questionScore,//每小题分数
      fullScore: item.score,//总分
      isShowTitle: index==0?true:false,//是否显示标题
      pageIndex: 1,//页面号码
      isOver: addAnswerQuestion.isOver,//是否覆盖编辑内容
      isChoose: addAnswerQuestion.isChoose,//是否选做题
      editorContent:item.editorContent,//编辑内容
      x: 0,//x坐标
      y: 0,//y坐标
      h: item.rectHeight,//高度
      w: pageInfo.mainWidth,//宽度
    }
    questionUiList.push(questionUiItem);
  })
  console.log("打印要添加的questionUiList",questionUiList);
  let newList=addQuestionsToPages(paperTemplateData,questionUiList,pageInfo);
  //分几种情况  第一种  剩余高度够用
  console.log("打印paperTemplateData",paperTemplateData);
  return paperTemplateData;
}

//添加小题数组到页面
export function addDataToQuestionList(arr, newData, heightThreshold,pageInfo,) 
{
  
  let currentIndex = arr.length - 1;//数组的最后一个索引
  let currentTotalHeight = 0;
  
  for (let i = 0; i < newData.length; i++) {
      let item = newData[i];
      currentTotalHeight += item.h;

      if (currentTotalHeight > heightThreshold) 
      {
          // 如果超出阈值，将当前项及剩余项移到下一个对象
          let remainingItems = newData.slice(i);
          item.h=item.h-(currentTotalHeight-heightThreshold);
          arr[currentIndex].questionUiData.push(item);

          if (currentIndex + 1 < arr.length) 
          {
              arr[currentIndex + 1].questionUiData=remainingItems;

          } else 
          {
           let newPaperTemplateItem=GetPaperTemplateItem(pageInfo,arr[currentIndex].pageIndex);
            arr.push(newPaperTemplateItem);
          }
          // break;
      } else 
      {
  
        arr[currentIndex].questionUiData.push(item);
      }
  }
  console.log(arr);
}

export function addQuestionsToPages(arr, newData,pageInfo) 
{
  
  let mainHeight=pageInfo.mainHeight;
  let currentPageIndex = arr.length - 1;
  let currentPage = arr[currentPageIndex];
  let currentHeight =calculateQuestionHeight(currentPage.questionUiData);//当前页面的总高度
  if(currentPage.isShowTitle)
  {
    //有标题页 需要加上标题的高度
    currentHeight += pageInfo.paperTitleHeight;
  }
  if(currentPage.isShowUserInfo)
  {
    //学生信息区 需要加上学生信息区域的高度
    currentHeight += pageInfo.studentInfoHeight;
  }
  for (let i = 0; i < newData.length; i++) {
      const question = newData[i];
      let newHeight=question.h+0.5;//1mm 线的高度
      if(question.isShowTitle)
      {
        newHeight += 9;//大标题区域高度9mm
      }
      if (currentHeight+newHeight <= mainHeight) 
      {
          // 如果加上当前问题的高度不超过mainHeight，则直接添加到当前页面
          currentPage.questionUiData.push(question);
          currentHeight += newHeight;//0.5 线的高度
      } 
      else 
      {
          // 如果超过mainHeight，需要分割最后一个题
          const remainingHeight = (mainHeight - currentHeight);//剩余的高度 这里的5调试出来的(可能是边框线的累加 也可能是别的)  为了保证底部的边距

          const splitQuestion1 = { ...question, h: parseFloat(remainingHeight.toFixed(2)) };
          const splitQuestion2 = { ...question, h: parseFloat((question.h - remainingHeight).toFixed(2)) };

         
          //如果剩余的高度小于一定值 则直接给上一个题目 不拆
          if(remainingHeight<30)
          {
            let currentCount=currentPage.questionUiData.length;
            currentPage.questionUiData[currentCount-1].h+=remainingHeight;
            splitQuestion2.h=question.h;
           
          }
          else
          {
            currentPage.questionUiData.push(splitQuestion1);
          }

          

          // 创建新页面或使用下一个页面
          if (arr.length <= currentPageIndex + 1) {
              // arr.push({ questionUiData: [], pageIndex: currentPage.pageIndex + 1 });
              let item=GetPaperTemplateItem(pageInfo,currentPageIndex+1);
              console.log("增加的页面",item);
              arr.push(item);
          }
          currentPageIndex++;
          currentPage = arr[currentPageIndex];
          // arr[currentPageIndex+1].questionUiData.push(splitQuestion2);
          currentPage.questionUiData.push(splitQuestion2);
          currentHeight = splitQuestion2.h;
      }
  }
  let newPageHeight =calculateQuestionHeight(arr[0].questionUiData);//当前页面的总高度
  // console.log("添加后的页面的总高度",newPageHeight);
  return arr;
}

/**
 * 计算问题列表的总高度
 * 此函数通过累加每个问题的高度来计算问题列表的总高度如果问题有标题显示，则额外增加高度
 * 
 * @param {Array} questionList - 问题列表，每个问题应包含高度 (h) 和标题显示状态 (isShowTitle)
 * @returns {number} 问题列表的总高度
 */
export function calculateQuestionHeight(questionList) 
{
  // console.log("计算问题列表的总高度",questionList);
  return questionList.reduce((totalHeight, question) => {
    // 累加当前题目的高度
    totalHeight += question.h;// 线的高度

    // 如果 isShowTitle 为 true，额外加上 34px  标题的高度
    if (question.isShowTitle) 
    {
      totalHeight += 34;
    }
    return totalHeight;
  }, 0);
}

//
/**
 * 获取新的模板页面
 * 此函数通过pageInfo 信息和当前页面页码信息 生成新的页面信息
 * 
 * @param {Object} pageInfo - 页面相关信息数据
 * @returns {number} currentPageIndex 页面页码
 */
export function GetPaperTemplateItem(pageInfo,currentPageIndex)
{
  
  console.log("打印页面pageInfo信息",pageInfo);
  let newPageIndex=currentPageIndex+1;//新页面的页码
  console.log("打印新页面页码",newPageIndex);
  // pageCount: 1, //总页数 初始默认1
  // markType: 1, //阅卷方式 1:网阅卷2:纸阅卷
  // positionType: 2, //定位方式 1二维码 2:黑块
  // paperLayout: '1', //页面布局1:A4, 2:A32, 3:A33  A4 一栏 A32:两栏 A33:三栏
  // paperCardType:'A4',//纸张类型   一栏是A4    二栏 三栏是A3   
  // checkedSafeLine: false, //是否密封线
  // pringType: "1", //印刷方式 1-单面,2-双面印刷
  // width: 794, //页面整体宽度 使用像素 宽度 794  
  // height: 1123,//页面整体高度 使用像素 高度 1123
  // mainWidth: 678, //内容区域宽度 794-114-2   114为左右两边的边距 2为左右两边线的宽度
  // stInfoType: 1, //学生信息区样式模式 1:标准模式(展示贴条码) 2:极简模式 不展示贴条码  标准模式：65.6， 极简模式：0
  // mainHeight: 1010,//页面内容区域高度 1123-113 113为上下两边的边距  一栏的计算方式  其他二栏 三栏在重新计算 1010 正常内容区域像素
  // idCardType: 2, //学号填涂类型 1:条形码 2:涂块
  // idCardNumberLen: 8, //涂块位数
  // studentInfoHeight: 233, //学生信息区高度  233px  可配置
  // paperTitleHeight: 100,//标题区域高度 100px  可配置
  
  let newTemplateObject=GetPaperTemplateObject(pageInfo,newPageIndex);

  // let newPaperTemplateItem={
  //   location: [
  //       {
  //         x: 0, //横坐标
  //         y: 0, //y坐标
  //         w: 25,//宽
  //         h: 15,//高
  //         name: '左上角定位',
  //         url: '',//二维码地址
  //       },
  //       {
  //         x: 0,
  //         y: 1057,
  //         w: 25,
  //         h: 15,
  //         name: '左下角定位',
  //         url: '',//二维码地址
  //       },
  //       {
  //         x: 708,
  //         y: 0,
  //         w: 25,
  //         h: 15,
  //         name: '右上角定位',
  //         url: '',//二维码地址
  //       },
  //       {
  //         x: 708,
  //         y: 1057,
  //         w: 25,
  //         h: 15,
  //         name: '右下角定位',
  //         url: '',//二维码地址
  //       },
  //   ],//定位块信息
  //   isShowTitle: isShowTitle,
  //   isShowUserInfo: isShowUserInfo,
  //   paperTitle: {
  //     x: '',
  //     y: '',
  //     value: pageInfo.pageTitle,
  //   },
  //   matterMessage: `
  //                 1、答题前请将姓名、班级、考场、准考证号填写清楚。<br />
  //                 2、客观题答案必须使用2B铅笔填涂，修改时用橡皮擦干净。<br />
  //                 3、主观题使用黑色签字笔书写。<br />
  //                 4、必须在题号对应的答题区域内作答，超出答题区域书写无效。<br />
  //                 5、保持卷面整洁、完整。
  //                 `,//注意事项内容
  //   pageIndex: newPageIndex,//当前页码
  //   questionUiData: [],//试卷内容列表
  // };
  return newTemplateObject;

}

//修改试卷模板的高度
export function ChanagePaperHeight(paperTemplateData,pageInfo)
{
  
  let newData=[];
  
  for (let i = 0; i < paperTemplateData.length; i++) 
  {
    paperTemplateData[i].questionUiData.forEach((question,index)=>{

      //插入之前判断是否存在 如果存在相同题号 则不插入 只累加高度
      
      const existingItem = newData.find(
        data => data.questionName === question.questionName
      );
      if (existingItem) {
        // 如果已存在，累加 h 高度
        existingItem.h += question.h;
      } else {
        // 如果不存在，插入到 newData 中
        newData.push(question);
      }
      
    })
  }
  console.log("打印所有要重新添加的数据",newData);
  
  let arr=JSON.parse(JSON.stringify(paperTemplateData));
  arr.forEach((item,index)=>{
    item.questionUiData=[];
  })
  let mainHeight=pageInfo.mainHeight;
  let currentPageIndex = 0;
  let currentPage = arr[currentPageIndex];
  let currentHeight =0;//当前页面的总高度
  
  if(currentPage.isShowTitle)
  {
    //有标题页 需要加上标题的高度
    currentHeight += pageInfo.paperTitleHeight;
  }
  if(currentPage.isShowUserInfo)
  {
    //学生信息区 需要加上学生信息区域的高度
    currentHeight += pageInfo.studentInfoHeight;
  }
  
  for (let i = 0; i < newData.length; i++) {
      const question = newData[i];
      let newHeight=question.h+0.5;//1mm 线的高度
      if(question.isShowTitle)
      {
        newHeight += 9;//大标题区域高度9mm
      }
      if (currentHeight+newHeight <= mainHeight) 
      {
          // 如果加上当前问题的高度不超过mainHeight，则直接添加到当前页面
          currentPage.questionUiData.push(question);
          currentHeight += newHeight;//0.5 线的高度
      } 
      else 
      {
          // 如果超过mainHeight，需要分割最后一个题
          const remainingHeight = (mainHeight - currentHeight);//剩余的高度 这里的5调试出来的(可能是边框线的累加 也可能是别的)  为了保证底部的边距

          const splitQuestion1 = { ...question, h: parseFloat(remainingHeight.toFixed(2)) };
          const splitQuestion2 = { ...question, h: parseFloat((question.h - remainingHeight).toFixed(2)) };

          //如果剩余的高度小于一定值 则直接给上一个题目 不拆
          if(remainingHeight<10)
          {
            let currentCount=currentPage.questionUiData.length;
            currentPage.questionUiData[currentCount-1].h+=remainingHeight;
            splitQuestion2.h=question.h;
           
          }
          else
          {
            currentPage.questionUiData.push(splitQuestion1);
          }

          

          // 创建新页面或使用下一个页面
          if (arr.length <= currentPageIndex + 1) {
              let item=GetPaperTemplateItem(pageInfo,currentPageIndex+1);
              console.log("增加的页面",item);
              arr.push(item);
          }
          currentPageIndex++;
          currentPage = arr[currentPageIndex];
          // arr[currentPageIndex+1].questionUiData.push(splitQuestion2);
          currentPage.questionUiData.push(splitQuestion2);
          currentHeight = splitQuestion2.h;
      }
  }
  let newPageHeight =calculateQuestionHeight(arr[0].questionUiData);//当前页面的总高度
  console.log("添加后的页面的总高度",newPageHeight);
  return arr;

}

//添加英文题数据 px单位
export function GetArticleEnUiData(paperTemplateData,questionItem,pageInfo)
{

  
  let totalWidth=pageInfo.mainWidth;//页面可用宽度
  let rowNumber=questionItem.rowCount;//行数
  let startNumber=questionItem.questionIndex;//题号

  let rowHeight=9.6*rowNumber+4.1;//单位毫米 英语作文题的高度
  console.log("questionItem",questionItem);
  let questionUiData={
      questionName: questionItem.questionName,//小题名称
      questionIndex: questionItem.questionIndex,//小题编号 小题号 小题名称
      startQuestionIndex:questionItem.questionIndex,//其实题号
      endQuestionIndex:questionItem.questionIndex,//结束题号
      type: 4,//题目类型  1  选择题 2.填空题 3:解答题 4.作文英 5.作文语 6.非作答区
      title: questionItem.title,//大题名称
      questionScore: questionItem.questionScore,//每小题分数
      rowCount:questionItem.rowCount,//行数
      fullScore: questionItem.fullScore,//总分
      isShowTitle: true,//是否显示标题
      isOver: questionItem.isOver,//是否覆盖编辑内容
      isChoose: questionItem.isChoose,//是否选做题
      editorContent:GetArticleCnContentMM(totalWidth,rowNumber,startNumber),
      x: 0,//x坐标
      y: 0,//y坐标
      h: rowHeight,//高度
      w: pageInfo.mainWidth,//宽度
  };
  // paperTemplateData[paperTemplateData.length-1].questionUiData.push(questionUiData);
  let mainHeight=pageInfo.mainHeight;//页面可用区域高度
  let currentPageIndex = paperTemplateData.length-1;
  let currentPage = paperTemplateData[currentPageIndex];
  let currentHeight =calculateQuestionHeight(currentPage.questionUiData);//当前页面的总高度;
 
  if(currentPage.isShowTitle)
  {
    //有标题页 需要加上标题的高度
    currentHeight += pageInfo.paperTitleHeight;
  }
  if(currentPage.isShowUserInfo)
  {
    //学生信息区 需要加上学生信息区域的高度
    currentHeight += pageInfo.studentInfoHeight;
  }
  

  let newHeight=questionUiData.h+0.5;//1mm 线的高度
  if(questionUiData.isShowTitle)
  {
    newHeight += 9;//大标题区域高度9mm
  }
  if (currentHeight+newHeight <= mainHeight) 
  {
      // 如果加上当前问题的高度不超过mainHeight，则直接添加到当前页面
      currentPage.questionUiData.push(questionUiData);
      currentHeight += newHeight;//0.5 线的高度
  } 
  else 
  {
      // 如果超过mainHeight，需要分割最后一个题
      const remainingHeight = (mainHeight - currentHeight);//剩余的高度  为了保证底部的边距
      let rowCount1=Math.floor((remainingHeight-4.1)/9.6);//向下取整
      const splitQuestion1 = { ...questionUiData,
         h: parseFloat(remainingHeight.toFixed(2)),//高度重新计算
         editorContent:GetArticleCnContentMM(totalWidth,rowCount1,startNumber),//编辑内容,//内容重新计算
         isShowTitle:true,
        };
      let rowCount2=rowNumber-rowCount1;
      const splitQuestion2 = { ...questionUiData, 
        h: 9.6*rowCount2+4.1,//单位毫米 英语作文题的高度,
        editorContent:GetArticleCnContentMM(totalWidth,rowCount2,''),//编辑内容,//内容重新计算

        isShowTitle:false,
      };
      
      currentPage.questionUiData.push(splitQuestion1);
      // 创建新页面或使用下一个页面
      if (paperTemplateData.length <= currentPageIndex + 1) {
          let item=GetPaperTemplateItem(pageInfo,currentPageIndex+1);
          console.log("增加的页面",item);
          paperTemplateData.push(item);
      }
      currentPageIndex++;
      currentPage = paperTemplateData[currentPageIndex];
      // arr[currentPageIndex+1].questionUiData.push(splitQuestion2);
      currentPage.questionUiData.push(splitQuestion2);
      
  }
  


  
}

//添加英文题数据 mm单位 保留备用
export function GetArticleEnUiDataMM(paperTemplateData,questionItem,pageInfo)
{

  
  let totalWidth=pageInfo.mainWidth;//页面可用宽度
  let rowNumber=questionItem.rowCount;//行数
  let startNumber=questionItem.questionIndex;//题号

  let rowHeight=9.6*rowNumber+4.1;//单位毫米 英语作文题的高度
  console.log("questionItem",questionItem);
  let questionUiData={
      questionName: questionItem.questionName,//小题名称
      questionIndex: questionItem.questionIndex,//小题编号 小题号 小题名称
      startQuestionIndex:questionItem.questionIndex,//其实题号
      endQuestionIndex:questionItem.questionIndex,//结束题号
      type: 4,//题目类型  1  选择题 2.填空题 3:解答题 4.作文英 5.作文语 6.非作答区
      title: questionItem.title,//大题名称
      questionScore: questionItem.questionScore,//每小题分数
      rowCount:questionItem.rowCount,//行数
      fullScore: questionItem.fullScore,//总分
      isShowTitle: true,//是否显示标题
      isOver: questionItem.isOver,//是否覆盖编辑内容
      isChoose: questionItem.isChoose,//是否选做题
      editorContent:GetArticleCnContentMM(totalWidth,rowNumber,startNumber),
      x: 0,//x坐标
      y: 0,//y坐标
      h: rowHeight,//高度
      w: pageInfo.mainWidth,//宽度
  };
  // paperTemplateData[paperTemplateData.length-1].questionUiData.push(questionUiData);
  let mainHeight=pageInfo.mainHeight;//页面可用区域高度
  let currentPageIndex = paperTemplateData.length-1;
  let currentPage = paperTemplateData[currentPageIndex];
  let currentHeight =calculateQuestionHeight(currentPage.questionUiData);//当前页面的总高度;
 
  if(currentPage.isShowTitle)
  {
    //有标题页 需要加上标题的高度
    currentHeight += pageInfo.paperTitleHeight;
  }
  if(currentPage.isShowUserInfo)
  {
    //学生信息区 需要加上学生信息区域的高度
    currentHeight += pageInfo.studentInfoHeight;
  }
  

  let newHeight=questionUiData.h+0.5;//1mm 线的高度
  if(questionUiData.isShowTitle)
  {
    newHeight += 9;//大标题区域高度9mm
  }
  if (currentHeight+newHeight <= mainHeight) 
  {
      // 如果加上当前问题的高度不超过mainHeight，则直接添加到当前页面
      currentPage.questionUiData.push(questionUiData);
      currentHeight += newHeight;//0.5 线的高度
  } 
  else 
  {
      // 如果超过mainHeight，需要分割最后一个题
      const remainingHeight = (mainHeight - currentHeight);//剩余的高度  为了保证底部的边距
      let rowCount1=Math.floor((remainingHeight-4.1)/9.6);//向下取整
      const splitQuestion1 = { ...questionUiData,
         h: parseFloat(remainingHeight.toFixed(2)),//高度重新计算
         editorContent:GetArticleCnContentMM(totalWidth,rowCount1,startNumber),//编辑内容,//内容重新计算
         isShowTitle:true,
        };
      let rowCount2=rowNumber-rowCount1;
      const splitQuestion2 = { ...questionUiData, 
        h: 9.6*rowCount2+4.1,//单位毫米 英语作文题的高度,
        editorContent:GetArticleCnContentMM(totalWidth,rowCount2,''),//编辑内容,//内容重新计算

        isShowTitle:false,
      };
      
      currentPage.questionUiData.push(splitQuestion1);
      // 创建新页面或使用下一个页面
      if (paperTemplateData.length <= currentPageIndex + 1) {
          let item=GetPaperTemplateItem(pageInfo,currentPageIndex+1);
          console.log("增加的页面",item);
          paperTemplateData.push(item);
      }
      currentPageIndex++;
      currentPage = paperTemplateData[currentPageIndex];
      // arr[currentPageIndex+1].questionUiData.push(splitQuestion2);
      currentPage.questionUiData.push(splitQuestion2);
      
  }
  


  
}


//添加语文作文题数据
export function GetArticleCnUiData(paperTemplateData,questionItem,pageInfo)
{
  
  let totalWidth=pageInfo.mainWidth-20;//总宽度先写死 单位px  减去20px边距 
  let totalCell=questionItem.wordNumber;//总共多少个格子 
  let cellWidth=questionItem.cellSize;//格子宽度 单位px
  
  let rowCellCount= Math.floor(totalWidth/cellWidth);//每行总共多少个格子  需要向下取整数
  let rowNumber=Math.ceil(totalCell/rowCellCount);//总共多少行 需要向上取整数
  let rowHeight=(cellWidth+2.5)*rowNumber+12+4;//单位毫米 语文作文题的高度  2 mm 上下行之间的边距  12 mm 顶部边距 4 底部边距
  let mainHeight=pageInfo.mainHeight;//页面可用区域总高度
  let currentPageIndex = paperTemplateData.length-1;//当前的页索引
  let currentPage = paperTemplateData[currentPageIndex];//当前的页面数据
  let currentHeight =calculateQuestionHeight(currentPage.questionUiData);//当前页面已使用的总高度
  if(currentPage.isShowTitle)
  {
    //有标题页 需要加上标题的高度
    currentHeight += pageInfo.paperTitleHeight;
  }
  if(currentPage.isShowUserInfo)
  {
    //学生信息区 需要加上学生信息区域的高度
    currentHeight += pageInfo.studentInfoHeight;
  }
  let remainingHeight = (mainHeight - currentHeight);//剩余可用高度 
  if(remainingHeight<60)
  {
    //剩余高度小于60px，则需要换页
    let newPage=GetPaperTemplateItem(pageInfo,currentPageIndex+1);
    paperTemplateData.push(newPage);
    currentPageIndex = paperTemplateData.length-1;//当前的页索引
    currentPage = paperTemplateData[currentPageIndex];//当前的页面数据
    currentHeight=0;//新的页面高度重置为0
    if(currentPage.isShowTitle)
    {
      //有标题页 需要加上标题的高度
      currentHeight += pageInfo.paperTitleHeight;
    }
    if(currentPage.isShowUserInfo)
    {
      //学生信息区 需要加上学生信息区域的高度
      currentHeight += pageInfo.studentInfoHeight;
    }
    remainingHeight = (mainHeight - currentHeight);//剩余可用高度 
    
  }

  // console.log("打印剩余可用的高度",remainingHeight);
  //计算可添加的作文行数
  let remainingNumber=Math.floor((remainingHeight-34-10-10)/(cellWidth+2.5));//9是标题高度 12是顶部边距 4是底部边距
  if(remainingNumber<=0)
  {
    remainingNumber=0;
  }
  let pageTotalNumber=Math.floor((pageInfo.mainHeight-12-4)/(cellWidth+2.5));//9是标题高度 12是顶部边距 4是底部边距
  // console.log("打印剩余可用的行数",remainingNumber);
  // console.log("打印一页可显示的行数",pageTotalNumber)

  let cellRowList=[];
  for(let i=0;i<rowNumber;i++)
  {
      let cellList=[];
      
      for(let j=0;j<rowCellCount;j++)
      {
          let currentNumber=i*rowCellCount+j+1;
          let cellItem={
              width:cellWidth,
              height:cellWidth,
              cellIndex:j+1,
              rowIndex:i+1,
              numberIndex:currentNumber,
              isShowNumber:currentNumber%100===0,//是否显示数字 取余100 等于0 则显示数字
              islast:j==rowCellCount-1,//是不是最后一个
          }
          cellList.push(cellItem);
      }
      let cellRowItem={
          cellList:cellList,
          rowIndex:i+1,
      };
      cellRowList.push(cellRowItem);
  }

  // console.log("questionItem",questionItem);
  
  let resultList=SplitArray(cellRowList,remainingNumber,pageTotalNumber);
  console.log("打印拆分的结果数组",resultList);

  resultList.forEach((item,index)=>{
      let rowCount=item.length;
      let rowHeight=(cellWidth+2.5)*rowCount+12+4;//单位毫米 语文作文题的高度  2 mm 上下行之间的边距(2.5是算上边框线)  12 mm 顶部边距 4 底部边距
      rowHeight=index===0?rowHeight+9:rowHeight;
      let questionUiData={
          questionName: questionItem.questionName,//小题名称
          questionIndex: questionItem.questionIndex,//小题编号 小题号 
          type:5,//题目类型  1  选择题 2.填空题 3:解答题 4.作文英 5.作文语 6.非作答区
          title: questionItem.title,//大题名称
          questionScore: questionItem.questionScore,//每小题分数
          wordNumber:questionItem.wordNumber,//作文字数
          cellSize:questionItem.cellSize,//表格大小
          fullScore: questionItem.fullScore,//总分
          isShowTitle: index==0?true:false,//是否显示标题
          isOver: questionItem.isOver,//是否覆盖编辑内容
          isChoose: questionItem.isChoose,//是否选做题
          x: 0,//x坐标
          y: 0,//y坐标
          h: rowHeight,//高度
          w: pageInfo.mainWidth,//宽度
          cellRowList:item,//表格数据
      };
      if(rowCount==0)
      {

      }
      else
      {
        currentPage.questionUiData.push(questionUiData);
      }
      
      if (index <resultList.length-1) 
      {
        let item=GetPaperTemplateItem(pageInfo,currentPageIndex+1);
        console.log("增加的页面",item);
        paperTemplateData.push(item);
      }
      currentPageIndex++;
      currentPage = paperTemplateData[currentPageIndex];
  })
  // console.log("打印paperTemplateData",paperTemplateData);
} 



//添加语文作文题数据 mm单位 保留备用
export function GetArticleCnUiDataMM(paperTemplateData,questionItem,pageInfo)
{
  
  let totalWidth=pageInfo.mainWidth-6;//总宽度先写死 单位mm  减去6mm边距
  let totalCell=questionItem.wordNumber;//总共多少个格子 
  let cellWidth=questionItem.cellSize;//格子宽度 单位毫米
  let rowCellCount= Math.floor(totalWidth/cellWidth);//每行总共多少个格子  需要向下取整数
  let rowNumber=Math.ceil(totalCell/rowCellCount);//总共多少行 需要向上取整数
  let rowHeight=(cellWidth+2.5)*rowNumber+12+4;//单位毫米 语文作文题的高度  2 mm 上下行之间的边距  12 mm 顶部边距 4 底部边距
  let mainHeight=pageInfo.mainHeight;//页面可用区域总高度
  let currentPageIndex = paperTemplateData.length-1;//当前的页索引
  let currentPage = paperTemplateData[currentPageIndex];//当前的页面数据
  let currentHeight =calculateQuestionHeight(currentPage.questionUiData);//当前页面已使用的总高度
  if(currentPage.isShowTitle)
  {
    //有标题页 需要加上标题的高度
    currentHeight += pageInfo.paperTitleHeight;
  }
  if(currentPage.isShowUserInfo)
  {
    //学生信息区 需要加上学生信息区域的高度
    currentHeight += pageInfo.studentInfoHeight;
  }
  let remainingHeight = (mainHeight - currentHeight);//剩余可用高度 
  if(remainingHeight<16)
  {
    //剩余高度小于30mm，则需要换页
    let newPage=GetPaperTemplateItem(pageInfo,currentPageIndex+1);
    paperTemplateData.push(newPage);
    currentPageIndex = paperTemplateData.length-1;//当前的页索引
    currentPage = paperTemplateData[currentPageIndex];//当前的页面数据
    currentHeight=0;//新的页面高度重置为0
    if(currentPage.isShowTitle)
    {
      //有标题页 需要加上标题的高度
      currentHeight += pageInfo.paperTitleHeight;
    }
    if(currentPage.isShowUserInfo)
    {
      //学生信息区 需要加上学生信息区域的高度
      currentHeight += pageInfo.studentInfoHeight;
    }
    remainingHeight = (mainHeight - currentHeight);//剩余可用高度 
    
  }

  // console.log("打印剩余可用的高度",remainingHeight);
  //计算可添加的作文行数
  let remainingNumber=Math.floor((remainingHeight-9-12-4)/(cellWidth+2.5));//9是标题高度 12是顶部边距 4是底部边距
  if(remainingNumber<=0)
  {
    remainingNumber=0;
  }
  let pageTotalNumber=Math.floor((pageInfo.mainHeight-12-4)/(cellWidth+2.5));//9是标题高度 12是顶部边距 4是底部边距
  // console.log("打印剩余可用的行数",remainingNumber);
  // console.log("打印一页可显示的行数",pageTotalNumber)

  let cellRowList=[];
  for(let i=0;i<rowNumber;i++)
  {
      let cellList=[];
      
      for(let j=0;j<rowCellCount;j++)
      {
          let currentNumber=i*rowCellCount+j+1;
          let cellItem={
              width:cellWidth,
              height:cellWidth,
              cellIndex:j+1,
              rowIndex:i+1,
              numberIndex:currentNumber,
              isShowNumber:currentNumber%100===0,//是否显示数字 取余100 等于0 则显示数字
              islast:j==rowCellCount-1,//是不是最后一个
          }
          cellList.push(cellItem);
      }
      let cellRowItem={
          cellList:cellList,
          rowIndex:i+1,
      };
      cellRowList.push(cellRowItem);
  }

  // console.log("questionItem",questionItem);
  
  let resultList=SplitArray(cellRowList,remainingNumber,pageTotalNumber);
  console.log("打印拆分的结果数组",resultList);

  resultList.forEach((item,index)=>{
      let rowCount=item.length;
      let rowHeight=(cellWidth+2.5)*rowCount+12+4;//单位毫米 语文作文题的高度  2 mm 上下行之间的边距(2.5是算上边框线)  12 mm 顶部边距 4 底部边距
      rowHeight=index===0?rowHeight+9:rowHeight;
      let questionUiData={
          questionName: questionItem.questionName,//小题名称
          questionIndex: questionItem.questionIndex,//小题编号 小题号 
          type:5,//题目类型  1  选择题 2.填空题 3:解答题 4.作文英 5.作文语 6.非作答区
          title: questionItem.title,//大题名称
          questionScore: questionItem.questionScore,//每小题分数
          wordNumber:questionItem.wordNumber,//作文字数
          cellSize:questionItem.cellSize,//表格大小
          fullScore: questionItem.fullScore,//总分
          isShowTitle: index==0?true:false,//是否显示标题
          isOver: questionItem.isOver,//是否覆盖编辑内容
          isChoose: questionItem.isChoose,//是否选做题
          x: 0,//x坐标
          y: 0,//y坐标
          h: rowHeight,//高度
          w: pageInfo.mainWidth,//宽度
          cellRowList:item,//表格数据
      };
      if(rowCount==0)
      {

      }
      else
      {
        currentPage.questionUiData.push(questionUiData);
      }
      
      if(index<resultList.length-1) 
      {
        let item=GetPaperTemplateItem(pageInfo,currentPageIndex+1);
        console.log("增加的页面",item);
        paperTemplateData.push(item);
      }
      currentPageIndex++;
      currentPage = paperTemplateData[currentPageIndex];
  })
  // console.log("打印paperTemplateData",paperTemplateData);
} 
//拆分数组
export function SplitArray(data,firstPageRows,maxRowsPerPage)
{
  let result=[];
  let totalRows=data.length;
  let start=0;


  //处理第一页
  let firstPage=data.slice(start,firstPageRows);
  result.push(firstPage);
  start+=firstPageRows;
  //处理剩余页面
  while(start<totalRows)
  {
     let page=data.slice(start,start+maxRowsPerPage);
     result.push(page);
     start+=maxRowsPerPage;
  }
  return result;
}

//获取答题卡试题结构数据
export function GetPaperQuestionStructureData(paperTemplateData)
{
  let questionList=[];//试题结构数据列表
  const mergedData ={};
  console.log("试题结果数据合并",paperTemplateData);
  paperTemplateData.forEach((page,index)=>{
    //遍历每一个questionUiData
    page.questionUiData.forEach(question=>{
      //判断是否是同一个大题
      const questionTitle=question.title;
      if(mergedData[questionTitle])
      {
        mergedData[questionTitle]={
          ...mergedData[questionTitle],
          ...question,
        };
      }
      else
      {
        mergedData[questionTitle]=question;
      }
    })
  })
  questionList=Object.values(mergedData);
  return questionList;
}

/**
 * 将任意字符串（包括中文、符号、HTML）编码为 Base64
 * @param {string} str - 要编码的字符串
 * @returns {string} Base64 编码后的字符串
 */
export function Base64EnCode(str) { 
  return btoa(
    encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, (match, p1) => {
      return String.fromCharCode('0x' + p1);
    })
  );
}

/**
 * 将 Base64 字符串解码为原始字符串（支持中文、HTML）
 * @param {string} base64Str - Base64 编码的字符串
 * @returns {string} 解码后的原始字符串
 */
export function Base64DeCode(base64Str) {
  return decodeURIComponent(
    atob(base64Str)
      .split('')
      .map(c => {
        return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
      })
      .join('')
  );
}