TEAMModelOS/TEAMModelOS.Extension/HTEX.Test/Controllers/MockDataController.cs

using Microsoft.AspNetCore.Mvc;
using System.Text.Json;
using static HTEX.Test.Controllers.LessonRecordController;
using TEAMModelOS.SDK.Extension;
using TEAMModelOS.SDK.Models;
using System;
using OfficeOpenXml;
using System.Reflection;
using System.Xml;
using System.Text.RegularExpressions;

namespace HTEX.Test.Controllers
{
    [ApiController]
    [Route("mock-data")]
    public class MockDataController : ControllerBase
    {
        private readonly  ILogger<MockDataController> _logger;
        public MockDataController(ILogger<MockDataController> logger)
        {
            _logger = logger;   
        }

        [HttpPost("student-lesson")]
        public async Task<IActionResult> StudentLesson(JsonElement json) 
        {
            #region 数据模拟
            //学生人数
            int scount = Random.Shared.Next(40, 45);
            //评测次数
            int ecount = Random.Shared.Next(0, 3);
            //题目个数
            int qcount = Random.Shared.Next(8, 15);
            //互动次数
            int icount = Random.Shared.Next(3, 12);
            //任务次数
            int tcount = Random.Shared.Next(1, 3);
            //评价次数
            int pcount = Random.Shared.Next(1, 4);
            //协作次数
            int xcount = Random.Shared.Next(1, 3);
            List<StudentLessonData> students = new List<StudentLessonData>();
            //个人计分，小组计分
            List<WeightedItem> gpitems = new List<WeightedItem>
            {
                new WeightedItem { Value = 0, Weight = 0.3 },
                new WeightedItem { Value = 2, Weight = 0.1 },
                new WeightedItem { Value = 5, Weight = 0.2 },
                new WeightedItem { Value = 8, Weight = 0.1 },
                new WeightedItem { Value = 3, Weight = 0.05 },
                new WeightedItem { Value = 4, Weight = 0.02 },
                new WeightedItem { Value = 6, Weight = 0.03 },
                new WeightedItem { Value = 7, Weight = 0.2 }
            };
            //个人计分，小组计分
            List<WeightedItem> titems = new List<WeightedItem>
            {
                new WeightedItem { Value = 0, Weight = 0.4 },
                new WeightedItem { Value = 25, Weight = 0.1 },
                new WeightedItem { Value = 15, Weight = 0.1 },
                new WeightedItem { Value = 10, Weight = 0.05 },
                new WeightedItem { Value = 30, Weight = 0.05 },
                new WeightedItem { Value = 20, Weight = 0.02 },
                new WeightedItem { Value = 40, Weight = 0.03 },
                new WeightedItem { Value = 50, Weight = 0.05 },
                new WeightedItem { Value = 5, Weight = 0.05 },
                new WeightedItem { Value = 35, Weight = 0.05 },
                new WeightedItem { Value = 45, Weight = 0.05 },
                new WeightedItem { Value = 55, Weight = 0.05 }
            };
            //for (var i = 0; i<100; i++)
            //{
            //    int randomValue = GetRandomValueByWeight(items);
            //    Console.WriteLine(randomValue);
            //}
            //被评价的目标索引
            List<List<int>> cworkDist = new List<List<int>>(xcount);
            //被评价目标的次数或分数
            //  List<List<int>> cworkCount = new List<List<int>>(xcount);
            for (int i = 0; i < xcount; i++)
            {
                //乱序取10-20人作为评价目标
                var vt = Enumerable.Range(0, scount).OrderBy(x => Random.Shared.Next()).Take(Random.Shared.Next(10, 21));
                cworkDist.Add(vt.ToList());
                //var counts = new List<int>();
                //foreach (var v in vt)
                //{
                //    counts.Add(0);
                //}
                //cworkCount.Add(counts);
            }

            //被评价的目标索引
            List<List<int>> rateDist = new List<List<int>>(pcount);
            //被评价目标的次数或分数
            //List<List<int>> rateCount = new List<List<int>>(pcount);
            List<string> types = new List<string>();
            for (int i = 0; i < pcount; i++)
            {
                //乱序取10-20人作为评价目标
                var vt = Enumerable.Range(0, scount).OrderBy(x => Random.Shared.Next()).Take(Random.Shared.Next(10, 21));
                rateDist.Add(vt.ToList());
                // var counts  = new List<int>();
                //foreach (var v in vt) 
                //{
                //    counts.Add(0);
                //}
                //rateCount.Add(counts);


                var t = Random.Shared.Next(0, 1);
                switch (true)
                {
                    case bool when i==0:
                        types.Add("Voting");
                        break;
                    case bool when i==1:
                        types.Add("GrandRating"); 
                        break;
                    case bool when i==2:
                        types.Add("PeerAssessment");
                        break;
                }
            }
            for (var s = 0; s<scount; s++)
            {
                StudentLessonData student = new StudentLessonData()
                {
                    index=s,
                    seatID=$"{s+1}",
                    id=$"2024{(s+1).ToString("D3")}",
                    groupId=$"{Random.Shared.Next(1, 5)}",
                    attend=1,
                    gscore= GetRandomValueByWeight(gpitems),
                    pscore= GetRandomValueByWeight(gpitems),
                    tscore= GetRandomValueByWeight(titems),
                };
                for (var p = 0; p<pcount; p++)
                {
                    student.rateingRecord.itemRecords.Add(new ItemRecord());
                }
                students.Add(student);
            }
            for (var s = 0; s<scount; s++)
            {
                var student = students[s];
                //互动
                for (var i = 0; i<icount; i++)
                {
                    int criterion = 10;
                    var item = new ItemRecord { criterion=criterion };
                    var w = Random.Shared.Next(0, 4);

                    switch (true)
                    {
                        //未参与
                        case bool when w==0:
                            item.resultWeight= InteractWeight.T0;
                            item.resultType= InteractReultType.T0;
                            item.itemScore=0;
                            break;
                        //参与了
                        case bool when w==1:
                            item.resultWeight= InteractWeight.T1;
                            item.resultType= InteractReultType.T1;
                            item.itemScore=0;
                            break;
                        //部分正确
                        case bool when w==2:
                            var score = Random.Shared.Next(1, criterion);
                            item.resultWeight= MinMaxNormalization(1, criterion, score, InteractWeight.T1, InteractWeight.TT);
                            item.resultType= InteractReultType.TP;
                            item.itemScore=0;
                            break;
                        //完全正确
                        case bool when w==3:
                            item.resultWeight= InteractWeight.TT;
                            item.resultType= InteractReultType.TT;
                            item.itemScore=criterion;
                            break;
                    }
                    student.interactRecord.interactRecords.Add(item);
                }
                //任务
                for (var t = 0; t<tcount; t++)
                {
                    var w = Random.Shared.Next(0, 2);
                    var item = new ItemRecord { };
                    switch (true)
                    {
                        //未参与
                        case bool when w==0:
                            item.resultWeight= InteractWeight.T0;
                            item.resultType= InteractReultType.T0;
                            item.itemScore=0;
                            break;
                        //参加
                        case bool when w==1:
                            item.resultWeight= InteractWeight.TT;
                            item.resultType= InteractReultType.TT;
                            item.itemScore=10;
                            break;
                    }
                    student.taskRecord.taskRate= student.taskRecord.itemRecords.Where(x => x.resultWeight>0).Count()*1.0/tcount;
                    student.taskRecord.itemRecords.Add(item);
                }
                //评价
                for (var p = 0; p<pcount; p++)
                {
                    var item = student.rateingRecord.itemRecords[p];
                    var subtype = string.Empty;
                    item.itemType=types[p];
                    if (types[p].Equals("PeerAssessment"))
                    {
                        var sub = Random.Shared.Next(0, 3);
                        subtype=  sub==0 ? "ALL" : sub==1 ? "Two" : "Self";
                    }
                    var w = Random.Shared.Next(0, 3);
                    switch (true)
                    {
                        //未参与
                        case bool when w==0:
                            item.resultWeight= InteractWeight.T0;
                            item.resultType= InteractReultType.T0;
                            item.itemScore=0;
                            break;
                        //参与
                        case bool when w==1||w==2:
                            item.resultWeight= InteractWeight.T1;
                            item.resultType= InteractReultType.T1;

                            if (item.itemType!.Equals("Voting"))
                            {
                                var index = Random.Shared.Next(0, rateDist[p].Count);
                                //rateCount[p][index]+=1;
                                students[rateDist[p][index]].rateingRecord.itemRecords[p].itemScore+=1;
                            }
                            else
                            {
                                if (item.itemType.Equals("PeerAssessment"))
                                {
                                    var index = Random.Shared.Next(0, rateDist[p].Count);
                                    //操作次数
                                    int opt_count = Random.Shared.Next(1, 2);
                                    for (var count = 0; count<opt_count; count++)
                                    {
                                        var score = Random.Shared.Next(3, 10);
                                        // rateCount[p][index]+=score;
                                        students[rateDist[p][index]].rateingRecord.itemRecords[p].itemScore+=score;
                                        item.optCount+= 1;
                                    }
                                }
                                else
                                {
                                    var index = Random.Shared.Next(0, rateDist[p].Count);
                                    var score = Random.Shared.Next(3, 10);
                                    // rateCount[p][index]+=score;
                                    students[rateDist[p][index]].rateingRecord.itemRecords[p].itemScore+=score;
                                }
                            }
                            break;
                    }
                    // student.rateingRecord.itemRecords.Add(item);
                }


                //协作
                for (var x = 0; x<xcount; x++)
                {
                    int[] r = new int[] { 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1 };
                    var w = r[Random.Shared.Next(0, r.Length)];
                    var item = new ItemRecord { };
                    switch (true)
                    {
                        //未参与
                        case bool when w==0:
                            item.resultWeight= InteractWeight.T0;
                            item.resultType= InteractReultType.T0;
                            item.itemScore=0;
                            break;
                        //
                        case bool when w==1:
                            item.resultWeight= InteractWeight.TP;
                            item.resultType= InteractReultType.TP;
                            int[] q = new int[] { 10, 5, 5, 20, 30, 10, 25, 10, 15, 15, 30, 5, 10, 20, 15, 25, 10, 5, 15, 20, 20, 25, 5, 5 };
                            item.itemScore=q[Random.Shared.Next(0, q.Count())];
                            break;
                    }
                    student.coworkRecord.itemRecords.Add(item);
                }
                //评测
                for (var e = 0; e<ecount; e++)
                {
                    StudentExamRecord examRecord = new();
                    double allocation = 0;
                    for (var q = 0; q<qcount; q++)
                    {
                        var criterion = Random.Shared.Next(5, 10);
                        allocation+=criterion;
                        var item = new ItemRecord { criterion =criterion };
                        var w = Random.Shared.Next(0, 4);
                        switch (true)
                        {
                            //未作答
                            case bool when w==0:
                                item.resultWeight= InteractWeight.T0;
                                item.resultType= InteractReultType.T0;
                                item.itemScore=0;
                                break;
                            //作答错误
                            case bool when w==1:
                                item.resultWeight= InteractWeight.T1;
                                item.resultType= InteractReultType.T1;
                                item.itemScore=0;
                                break;
                            //部分正确
                            case bool when w==2:
                                var score = Random.Shared.Next(1, criterion);
                                item.resultWeight= MinMaxNormalization(1, criterion, score, InteractWeight.T1, InteractWeight.TT); // score * 1.0  / criterion* (InteractWeight.TT-InteractWeight.T1);
                                item.resultType= InteractReultType.TP;
                                item.itemScore=score;
                                break;
                            //完全正确
                            case bool when w==3:
                                item.resultWeight= InteractWeight.TT;
                                item.resultType= InteractReultType.TT;
                                item.itemScore=criterion;
                                break;
                        }
                        examRecord.itemRecords.Add(item);
                    }
                    examRecord.qcount=qcount;
                    examRecord.workCount= examRecord.itemRecords.Where(x => x.resultWeight>0).Count();
                    examRecord.allocation=allocation;
                    examRecord.score= examRecord.itemRecords.Where(x => x.itemScore>=0).Select(x => x.itemScore).Sum();//得分
                    examRecord.scoreRate =  Math.Round(examRecord.score * 1.0 / allocation, 4);//得分率
                    examRecord.answerRate= Math.Round(examRecord.itemRecords.Where(x => x.resultWeight>0).Count()*1.0/qcount, 4);//作答率
                    student.examRecords.Add(examRecord);
                }
            }
            for (var p = 0; p<pcount; p++)
            {
                var order = students.OrderByDescending(x => x.rateingRecord.itemRecords[p].itemScore);
                var maxItems = students.FindAll(x => x.rateingRecord.itemRecords[p].itemScore==order.First().rateingRecord.itemRecords[p].itemScore);
                var max = students.FindAll(x => x.rateingRecord.itemRecords[p].itemScore==order.First().rateingRecord.itemRecords[p].itemScore).First().rateingRecord.itemRecords[p].itemScore;
                var min = students.FindAll(x => x.rateingRecord.itemRecords[p].itemScore==order.Last().rateingRecord.itemRecords[p].itemScore).First().rateingRecord.itemRecords[p].itemScore;
                var sum = students.Sum(x => x.rateingRecord.itemRecords[p].itemScore);
                foreach (var student in students)
                {
                    if (student.rateingRecord.itemRecords[p].itemScore>0  && student.rateingRecord.itemRecords[p].optCount>0)
                    {
                        student.rateingRecord.itemRecords[p].resultType=InteractReultType.TP;
                        var data = MinMaxNormalization(min, max, student.rateingRecord.itemRecords[p].itemScore);
                        student.rateingRecord.itemRecords[p].resultWeight=Math.Round(InteractWeight.T1+  data * 1.0  / 100 * (InteractWeight.TT-InteractWeight.T1), 4);
                        if (maxItems.Select(x => x.seatID).Contains(student.seatID))
                        {
                            student.rateingRecord.itemRecords[p].resultType= InteractReultType.TT;
                            student.rateingRecord.itemRecords[p].resultWeight= InteractWeight.TT;
                        }
                    }
                }
            }
            for (var p = 0; p<xcount; p++)
            {
                var order = students.OrderByDescending(x => x.coworkRecord.itemRecords[p].itemScore);
                var maxItems = students.FindAll(x => x.coworkRecord.itemRecords[p].itemScore==order.First().coworkRecord.itemRecords[p].itemScore);
                var max = students.FindAll(x => x.coworkRecord.itemRecords[p].itemScore==order.First().coworkRecord.itemRecords[p].itemScore).First().coworkRecord.itemRecords[p].itemScore;
                var min = students.FindAll(x => x.coworkRecord.itemRecords[p].itemScore==order.Last().coworkRecord.itemRecords[p].itemScore).First().coworkRecord.itemRecords[p].itemScore;
                var sum = students.Sum(x => x.coworkRecord.itemRecords[p].itemScore);
                foreach (var student in students)
                {
                    if (student.coworkRecord.itemRecords[p].itemScore>0)
                    {
                        student.coworkRecord.itemRecords[p].resultType=InteractReultType.TP;
                        var data = MinMaxNormalization(min, max, student.coworkRecord.itemRecords[p].itemScore);
                        student.coworkRecord.itemRecords[p].resultWeight=Math.Round(InteractWeight.T1+  data * 1.0  / 100 * (InteractWeight.TT-InteractWeight.T1), 4);
                        if (maxItems.Select(x => x.seatID).Contains(student.seatID))
                        {
                            student.coworkRecord.itemRecords[p].resultType= InteractReultType.TT;
                            student.coworkRecord.itemRecords[p].resultWeight= InteractWeight.TT;
                        }
                    }
                }
            }
            #endregion 数据模拟
            string jsons = await System.IO.File.ReadAllTextAsync("F:\\lesson-local\\analysis.json");
            long time = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
            LessonDataAnalysis lessonDataAnalysis = jsons.ToObject<LessonDataAnalysis>();
            ProcessStudentData(students, lessonDataAnalysis, scount, ecount, qcount, icount, tcount, pcount, xcount, time );
            try {
                await System.IO.File.WriteAllTextAsync($"F:\\mock-data\\{time}.json", new { scount, ecount, qcount, icount, tcount, pcount, xcount, students }.ToJsonString());
            } catch (Exception ex) {
                Console.WriteLine(scount);
            }
            return Ok(new { scount, ecount, qcount, icount, tcount, pcount, xcount, students });
        }

        

        private  void ProcessStudentData(List<StudentLessonData> studentLessonDatas, LessonDataAnalysis lessonDataAnalysis, int scount, int ecount, int qcount, int icount, int tcount, int pcount, int xcount,long time )
        {
            //历史记录的个人计分集合，通过“2倍标准差规则”移除异常值后得到的集合
            var max_q = lessonDataAnalysis.pscore.Max();
            //历史记录的互动计分集合，通过“2倍标准差规则”移除异常值后得到的集合
            var max_t = lessonDataAnalysis.tscore.Max();
            //历史记录的小组计分集合，通过“2倍标准差规则”移除异常值后得到的集合
            var max_h = lessonDataAnalysis.gscore.Max();
            var j = InteractWeight.T1;
            double t = InteractWeight.TT;
            List<StudentLessonItem> lessonItems= new List<StudentLessonItem>();
            foreach (var studentLessonData in studentLessonDatas)
            {
                StudentLessonItem lessonItem = new StudentLessonItem() { studentId= studentLessonData.id! };
                double u =  0.0;
                if (studentLessonData.attend==1) 
                {
                    u=100.0;
                }
                //c个人计分指数，d互动计分指数，e小组计分指数
                double c = 0, d = 0, e = 0;
                {
                    //互动相关的计分
                    //课例互动次数
                    double n = studentLessonData.interactRecord.interactRecords.Count()*1.0;
                    if (n>0) 
                    {
                        //是IES大陆正式站历史课例数据，自2024-03-01至2024-10-08日，互动指数或学法指数黄灯或绿灯，不包含醍摩豆学校及测试学校，课例时长超过5分钟的有效课例(10,680笔数据) 的IRS互动+抢权+挑人的次数集合，
                        //通过“2倍标准差规则” 移除异常值后得到的集合，再通过K-Means聚类算法得到高低位阶互动频次两个集合，并根据当前课例互动次数位阶的集合的质心值，该值定为m值
                        var m = n<=lessonDataAnalysis.clustersInteract.First().Value.Max() ? lessonDataAnalysis.clustersInteract.First().Key*1.0 : lessonDataAnalysis.clustersInteract.Last().Key *1.0;
                        //学生作答次数
                        var w = studentLessonData.interactRecord.interactRecords.Where(x => x.resultWeight>=InteractWeight.T1).Count()*1.0;
                        //作答正确数（包括部分正确）
                        var r = studentLessonData.interactRecord.interactRecords.Where(x => x.resultWeight>InteractWeight.T1).Count()*1.0;
                        //有参与的权重集合60≤k(x)≤100
                        var kw = studentLessonData.interactRecord.interactRecords.Where(x => x.resultWeight>=InteractWeight.T1).Sum(x => x.resultWeight*1.0);
                        //有得分的权重集合60<e(x)≤100
                        var er = studentLessonData.interactRecord.interactRecords.Where(x => x.resultWeight>InteractWeight.T1).Sum(x => x.resultWeight*1.0);
                        //本节课的所有互动计分
                        var i = studentLessonData.interactRecord.interactRecords.Sum(x => x.itemScore*1.0);
                        //本节课教师手动给学生的个人计分
                        var s = studentLessonData.pscore;
                        //个人计分指数
                        c =  GetPersent(lessonDataAnalysis.pscore,s)/100;// s*1.0/max_q;
                        //互动计分指数
                        d =  GetPersent(lessonDataAnalysis.tscore, i)/100; //i*1.0/max_t;
                        //互动成效指数
                        var a = (d+w*kw/(j*m)+r*er/(j*m))*1.0/n;
                        //互动参与指数
                        var b = ((w*w)/m+(r*r)/m)*1.0/n;
                        //c+a= 个人计分指数+ 个人互动成效指数
                        //学习成效
                        var f1 = Math.Round(190*1.0/(1+Math.Exp(-(c+a)))-95, 4);
                        lessonItem.hd_cx=f1;
                        var f2 = Math.Round(200*1.0/(1+Math.Exp(-(b+u/100)))-100, 4);
                        lessonItem.hd_cy=f2;
                        lessonItem.hd_cyc=w;
                        lessonItem.hd_fqc=n;
                        lessonItem.hd_zqc=r;
                        lessonItem.gr_jf=s;
                    }
                    //studentLessonData.achieve=f1;
                    //studentLessonData.attitude=f2;
                    // _logger.LogInformation($"{studentLessonData.id}=>学习成效：{f1}\t学习态度：{f2}\t互动次数：{n}\t参与次数：{w}\t正确次数：{r}\t个人计分：{s}\t{Math.Round(c, 2)}\t互动计分：{i}\t{Math.Round(d, 2)}"); 
                }
                {
                    //评测相关指数
                    double n = studentLessonData.examRecords.Count()*1.0;
                    if (n>0) 
                    {
                        //题目数量
                        double nq = studentLessonData.examRecords.Sum(x => x.qcount)*1.0;
                       // double max_e = lessonDataAnalysis.exam.Max();
                        //得分率
                        double sum_s = studentLessonData.examRecords.Sum(x => x.scoreRate);
                        //作答率
                        double sum_a = studentLessonData.examRecords.Sum(x => x.answerRate);
                        double f8 = Math.Round(sum_s/n*100, 4);
                        double f9 = Math.Round(sum_a/n*100, 4);
                        lessonItem.pc_df=f8;
                        lessonItem.pc_zd=f9;
                    }
                 //   _logger.LogInformation($"{studentLessonData.id}=>评测指数：{f8}\t得分率：{Math.Round(sum_s/n,4)}\t参与指数：{f9}\t作答率：{Math.Round(sum_a/n,4)}");
                }
                { 
                    //小组相关指数
                }
                { 
                    //任务相关指数
                    double n = studentLessonData.taskRecord.itemRecords.Count()*1.0;
                    if (n>0) 
                    {
                        double max_m = lessonDataAnalysis.task.Max();
                        double w = studentLessonData.taskRecord.itemRecords.Where(x => x.resultWeight>0).Count()*1.0;
                        double y = (10 *w/n+(j/t) *w)/max_m;
                        double l = max_m*(w*w/n+(j/t) * w)/n;
                        double f4 = Math.Round(190*1.0/(1+Math.Exp(-(y)))-95, 4);
                        double f5 = Math.Round(200*1.0/(1+Math.Exp(-(l)))-100, 4);
                        lessonItem.rw_fqc =n;
                        lessonItem.rw_cyc =w;
                        lessonItem.rw_cx =f4;
                        lessonItem.rw_cy =f5;
                    }
                   // _logger.LogInformation($"{studentLessonData.id}=>任务指数：{f4}\t参与指数：{f5}\t任务次数：{n}\t参与次数：{w}\t");

                }
                {
                    //评价相关指数
                    
                    double n = studentLessonData.rateingRecord.itemRecords.Count()*1.0;
                    if (n>0) 
                    {
                        var v = studentLessonData.rateingRecord.itemRecords.Where(x => x.itemType.Equals("Voting"));
                        double vc = v.Count()*1.0;
                        var g = studentLessonData.rateingRecord.itemRecords.Where(x => x.itemType.Equals("GrandRating"));
                        double gc = g.Count()*1.0;
                        var p = studentLessonData.rateingRecord.itemRecords.Where(x => x.itemType.Equals("PeerAssessment"));
                        double pc = p.Count()*1.0;

                        var vg = v.Sum(x => x.itemScore);
                        var vo = v.Sum(x => x.optCount);
                        double vs = vc/n* (vg+ vo);

                        var gg = g.Sum(x => x.itemScore);
                        var go = g.Sum(x => x.optCount);
                        double gs = gc/n* (gg+ go);

                        var pg = p.Sum(x => x.itemScore);
                        var po = p.Sum(x => x.optCount);
                        double ps = pc/n* (pg+ po);
                        double h = vs+ps+gs;
                        double f3 = Math.Round(190*1.0/(1+Math.Exp(-(h)))-95, 4);
                        studentLessonData.appraise=f3;
                        // _logger.LogInformation($"{studentLessonData.id}=>评价能力：{f3}\t评价次数：{n}\t投票次数：{vc}-{vg}-{vo}\t星光次数：{gc}-{gg}-{go}\t互评次数：{pc}-{pg}-{po}");

                        lessonItem.pj_nl =f3;
                        lessonItem.pj_cs =n;
                        lessonItem.pj_vc =vc;
                        lessonItem.pj_vg =vg;
                        lessonItem.pj_vo =vo;
                        lessonItem.pj_gc =gc;
                        lessonItem.pj_gg =gg;
                        lessonItem.pj_go =go;
                        lessonItem.pj_pc =pc;
                        lessonItem.pj_pg =pg;
                        lessonItem.pj_po =po;
                    }
                }
                {
                    //协作相关指数
                    var n= studentLessonData.coworkRecord.itemRecords.Count()*1.0;
                   
                    if (n>0 ) 
                    {
                       
                        //总的协作成果数
                      
                        var w = studentLessonData.coworkRecord.itemRecords.Where(x => x.resultWeight>0);
                        double ss = w.Sum(x => x.itemScore)*1.0;
                        double sw = w.Sum(x => x.resultWeight)*1.0;
                        double wc = w.Count()*1.0;
                        double x= 0.0;
                        if (wc>0) {
                            x=sw/(j *wc);
                        }
                        double max_xzcg = 40;
                        double k = (wc*wc/n+x)/n+ wc*(ss/max_xzcg)* (wc/n);
                        double f6 = Math.Round(190*1.0/(1+Math.Exp(-(k)))-95, 4);
                        double f7 = Math.Round(200*1.0/(1+Math.Exp(-(k)))-100, 4);
                        lessonItem.xz_fqc =n;
                        lessonItem.xz_cyc =wc;
                        lessonItem.xz_cgf =ss;
                        lessonItem.xz_cx =f6;
                        lessonItem.xz_cy =f7;
                    }
                    //_logger.LogInformation($"{studentLessonData.id}=>协作指数：{f6}\t参与指数：{f7}\t协作次数：{n}\t参与次数：{wc}\t协作成果分数：{ss}\t{k}");
                }
                
                double xx_cx =0,xx_cy=0;
                int avg_cx = 0, avg_cy=0; 
                if (lessonItem.xz_cx>0) 
                {
                    avg_cx+=1;
                }
                if (lessonItem.pj_nl>0)
                {
                    avg_cx+=1;
                }
                if (lessonItem.rw_cx>0)
                {
                    avg_cx+=1;
                }
                if (lessonItem.pc_df>0)
                {
                    avg_cx+=1;

                }
                if (lessonItem.hd_cx>0)
                {
                    avg_cx+=1;
                }
                xx_cx+=lessonItem.hd_cx * 1.0/avg_cx+ lessonItem.pc_df* 1.0/avg_cx+ lessonItem.rw_cx* 1.0/avg_cx+ lessonItem.pj_nl* 1.0/avg_cx+ lessonItem.xz_cx* 1.0/avg_cx;

                if (lessonItem.xz_cy>0)
                {
                    avg_cy+=1;
                }
                if (lessonItem.pj_nl>0)
                {
                    avg_cy+=1;
                }
                if (lessonItem.rw_cy>0)
                {
                    avg_cy+=1;
                }
                if (lessonItem.pc_zd>0)
                {
                    avg_cy+=1;
                }
                if (lessonItem.hd_cy>0)
                {
                    avg_cy+=1;
                }
                xx_cy+=lessonItem.hd_cy * 1.0/avg_cy+ lessonItem.pc_zd* 1.0/avg_cy+ lessonItem.rw_cy* 1.0/avg_cy+ lessonItem.pj_nl* 1.0/avg_cy+ lessonItem.xz_cy* 1.0/avg_cy;
                lessonItem.xx_cx=xx_cx;
                lessonItem.xx_cy=xx_cy;
                lessonItems.Add(lessonItem);
            }
            ExportToExcel(lessonItems, $"F:\\mock-data\\{time}.xlsx");
        }

        private static  void ExportToExcel(List<StudentLessonItem> items, string filePath)
        {
            ExcelPackage.LicenseContext = OfficeOpenXml.LicenseContext.NonCommercial;
            using (ExcelPackage package = new ExcelPackage())
            {
                ExcelWorksheet worksheet = package.Workbook.Worksheets.Add("学生课中数据");

                // 获取类的属性
                PropertyInfo[] properties = typeof(StudentLessonItem).GetProperties();

                // 添加表头
                int currentRow = 1;
                for (int i = 0; i < properties.Length; i++)
                {

                    string summary = Regex.Replace(GetPropertySummary(properties[i]), @"\s+", "") ;
                    worksheet.Cells[currentRow, i + 1].Value = summary;
                }

                // 填充数据
                currentRow = 2;
                foreach (var item in items)
                {
                    for (int i = 0; i < properties.Length; i++)
                    {
                        worksheet.Cells[currentRow, i + 1].Value = properties[i].GetValue(item);
                    }
                    currentRow++;
                }

                // 设置表格样式
                worksheet.Cells[worksheet.Dimension.Address].Style.HorizontalAlignment = OfficeOpenXml.Style.ExcelHorizontalAlignment.Left;
                worksheet.Cells[worksheet.Dimension.Address].Style.VerticalAlignment = OfficeOpenXml.Style.ExcelVerticalAlignment.Top;

                // 保存到文件
                FileInfo fileInfo = new System.IO.FileInfo(filePath);
                package.SaveAs(fileInfo);
            }
        }
        private static string GetPropertySummary(PropertyInfo property)
        {
            var xmlDocumentationFile = "./x.xml"; // XML注释文件路径
            if (System.IO. File.Exists(xmlDocumentationFile))
            {
                XmlDocument xmlDocument = new XmlDocument();
                xmlDocument.Load(xmlDocumentationFile);

                XmlNodeList xmlNodeList = xmlDocument.DocumentElement.SelectNodes("//member[@name='P:" + property.DeclaringType.FullName + "." + property.Name + "']");

                if (xmlNodeList.Count > 0)
                {
                    XmlNode xmlNode = xmlNodeList[0];
                    if (xmlNode != null && xmlNode.FirstChild != null)
                    {
                        return xmlNode.FirstChild.InnerText;
                    }
                }
            }
            return property.Name;
        }
        private static int GetRandomValueByWeight(List<WeightedItem> items)
        {
            Random random = new Random();
            double randomWeight = random.NextDouble();
            double cumulativeWeight = 0.0;

            foreach (var item in items)
            {
                cumulativeWeight += item.Weight;
                if (randomWeight <= cumulativeWeight)
                {
                    return item.Value;
                }
            }

            // This should not happen if all weights sum up to 1
            return items[items.Count - 1].Value;
        }
        private static double MinMaxNormalization(double min, double max, double x, double minRank = 1, double maxRank = 100)
        {
            //排名指数计算=( 当前值分数- 298) / (9992 - 298) * (99 - 60) + 60
            //将每个人的积分转化为60-100
            //排名 = (积分 - 最低积分) / (最高积分 - 最低积分) * (最大排名 - 最小排名) + 最小排名
            return Math.Round(x==0 ? 0 : max-min!=0 ? (x - min)*1.0 / (max - min) * (maxRank - minRank) + minRank : (x)*1.0 / (max) * (maxRank - minRank) + minRank,4);
        }
        /// <summary>
        /// 计算当前元素在集合中超过了多少百分比的值
        /// </summary>
        /// <param name="nums"></param>
        /// <param name="curr"></param>
        /// <returns></returns>
        public static double GetPersent(IEnumerable<double> nums, double curr)
        {
            int count = 0;
            foreach (var op in nums.OrderBy(x => x))
            {
                if (op < curr)
                {
                    count++;
                }
                else if (op == curr)
                {
                    count++;
                }
                else
                {
                    break;
                }
            }
            return count *1.0/ nums.Count() * 100;
        }
    }
    class WeightedItem
    {
        public int Value { get; set; }
        public double Weight { get; set; }
    }
    class StudentLessonItem
    {
        /// <summary>
        /// 学生id
        /// </summary>
        public string studentId { get; set; }
      
        /// <summary>
        /// 互动发起次数
        /// </summary>
        public double hd_fqc { get; set; } = 0;
        /// <summary>
        /// 互动参与次数
        /// </summary>
        public double hd_cyc { get; set; } = 0;
        /// <summary>
        /// 互动正确次数
        /// </summary>
        public double hd_zqc { get; set; } = 0;
        /// <summary>
        /// 个人计分
        /// </summary>
        public double gr_jf { get; set; } = 0;
        /// <summary>
        /// 互动成效指数
        /// </summary>
        public double hd_cx { get; set; } = 0;
        /// <summary>
        /// 互动参与指数
        /// </summary>
        public double hd_cy { get; set; } = 0;
        /// <summary>
        /// 评测得分率
        /// </summary>
        public double pc_df { get; set; } = 0;
        /// <summary>
        /// 评测作答率
        /// </summary>
        public double pc_zd { get; set; } = 0;
        /// <summary>
        /// 任务发起次数
        /// </summary>
        public double rw_fqc { get; set; } = 0;
        /// <summary>
        /// 任务参与次数
        /// </summary>
        public double rw_cyc { get; set; } = 0;
        /// <summary>
        /// 任务成效指数
        /// </summary>
        public double rw_cx { get; set; } = 0;
        /// <summary>
        /// 任务参与指数
        /// </summary>
        public double rw_cy { get; set; } = 0; 
      
        /// <summary>
        /// 评价发起次数
        /// </summary>
        public double pj_cs { get; set; } = 0;
        /// <summary>
        /// 投票发起次数
        /// </summary>
        public double pj_vc { get; set; } = 0;
        /// <summary>
        /// 投票得票数
        /// </summary>
        public double pj_vg { get; set; } = 0;
        /// <summary>
        /// 投票次数
        /// </summary>
        public double pj_vo { get; set; } = 0;
        /// <summary>
        /// 星光发起次数
        /// </summary>
        public double pj_gc { get; set; } = 0;
        /// <summary>
        /// 星光得分数
        /// </summary>
        public double pj_gg { get; set; } = 0;
        /// <summary>
        /// 星光评分次数
        /// </summary>
        public double pj_go { get; set; } = 0;
        /// <summary>
        /// 互评发起次数
        /// </summary>
        public double pj_pc { get; set; } = 0;
        /// <summary>
        /// 互评得分数
        /// </summary>
        public double pj_pg { get; set; } = 0;
        /// <summary>
        /// 互评评分次数
        /// </summary>
        public double pj_po { get; set; } = 0;
        /// <summary>
        /// 评价能力
        /// </summary>
        public double pj_nl { get; set; } = 0;
        /// <summary>
        /// 协作发起次数
        /// </summary>
        public double xz_fqc { get; set; } = 0;
        /// <summary>
        /// 协作参与次数
        /// </summary>
        public double xz_cyc { get; set; } = 0;
        /// <summary>
        /// 协作成果分数
        /// </summary>
        public double xz_cgf { get; set; } = 0;
        /// <summary>
        /// 协作能力指数
        /// </summary>
        public double xz_cx { get; set; } = 0;
        /// <summary>
        /// 协作参与指数
        /// </summary>
        public double xz_cy { get; set; } = 0;
        /// <summary>
        /// 学习成效
        /// </summary>
        public double xx_cx { get; set; } = 0;
        /// <summary>
        /// 学习参与
        /// </summary>
        public double xx_cy { get; set; } = 0;
    }
}