using Azure.Cosmos;
using MathNet.Numerics.LinearAlgebra.Double;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
using TEAMModelOS.SDK.Context.Constant;
using TEAMModelOS.SDK.DI;
using TEAMModelOS.SDK.Extension;
using TEAMModelOS.SDK.Models.Cosmos.BI;

namespace TEAMModelOS.SDK.Models.Service.BI
{
    public static class BIStats
    {
        /// <summary>
        /// 依据类型增/减量统计方法
        /// </summary>
        /// <param name="cosmosClient">连接字符</param>
        /// <param name="scId">学校id</param>
        /// <param name="type">类型：Exam(测验) Survey(问卷调查) Vote(投票) Homework(作业)  Less(课例) Student(学生)  Tchaer(教师) </param>
        /// <param name="count">增减数量 </param>
        /// <param name="careDate">时间</param>
        /// <param name="interaction">互动</param>
        /// <returns></returns>
        public static async Task SetTypeAddStats(CosmosClient cosmosClient,string scId,string type,int count,long careDate = 0,int interaction=0)
        {
            DateTimeOffset dateOff = DateTimeOffset.UtcNow;
            if (careDate == 0)
                careDate = dateOff.ToUnixTimeMilliseconds();

            var (lastDayS, lastDayE) = TimeHelper.GetStartOrEnd(dateOff.AddDays(-1));//昨天开始/结束时间
            var (DayS, DayE) = TimeHelper.GetStartOrEnd(dateOff);      //今天开始时间结束时间
            var (lastWeekS, lastWeekE) = TimeHelper.GetStartOrEnd(dateOff, "lastweek");   //计算上周开始/结束时间
            var (weekS, weekE) = TimeHelper.GetStartOrEnd(dateOff, "week");             //计算本周开始/结束时间
            var (lastMonthS, lastMonthE) = TimeHelper.GetStartOrEnd(dateOff, "lastMonth");   //计算上月开始/结束时间
            var (monthS, monthE) = TimeHelper.GetStartOrEnd(dateOff, "month");             //计算本月开始/结束时间
            var (lastTermS, lastTermE) = TimeHelper.GetStartOrEnd(dateOff, "lastterm");   //计算上学期开始/结束时间
            var (termS, termE) = TimeHelper.GetStartOrEnd(dateOff, "term");   //计算本学期开始/结束时间
            var (lastYearS, lastYearE) = TimeHelper.GetStartOrEnd(dateOff, "lastYear"); //计算去年开始/结束时间
            var (yearS, yearE) = TimeHelper.GetStartOrEnd(dateOff, "year");         //计算今年开始/结束时间

            var (weekDayS, weekDayE) = TimeHelper.GetLongToTime(lastWeekS, lastWeekE);
            var (lTermDayS, lTermDayE) = TimeHelper.GetLongToTime(lastTermS, lastTermE);
            var (termDayS, termDayE) = TimeHelper.GetLongToTime(lastTermS, lastTermE);
            var lastDay = dateOff.AddDays(-1);

            StatsInfo statsInfo = new();
            var resStsInfo = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync($"{dateOff.Year}-{scId}", new PartitionKey("Statistics"));
            if (resStsInfo.Status == 200)
            {
                using var fileJson = await JsonDocument.ParseAsync(resStsInfo.ContentStream);
                statsInfo = fileJson.ToObject<StatsInfo>();
            }
            else
            {
                ScBase scBase = await cosmosClient.GetContainer("TEAMModelOS", "School").ReadItemAsync<ScBase>(scId, new PartitionKey("Base"));

                //var resLastStsInfo = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync($"{dateOff.Year - 1}-{scId}", new PartitionKey("Statistics"));
                //if (resLastStsInfo.Status == 200)
                //{
                //    using var fileJson = await JsonDocument.ParseAsync(resStsInfo.ContentStream);
                //    statsInfo = fileJson.ToObject<StatsInfo>();
                //    statsInfo.id = $"{dateOff.Year}-{scBase.id}";
                //}
                //else 
                //{
                statsInfo.id = $"{dateOff.Year}-{scBase.id}";
                statsInfo.name = scBase.name;
                statsInfo.picture = scBase.picture;
                statsInfo.size = scBase.size;
                statsInfo.scCreateTime = scBase.createTime;
                statsInfo.areaId = scBase.areaId;
                statsInfo.upTime = careDate;
                //}
            }

            switch ($"{type}")
            {
                case "Exam":
                    statsInfo.activity.year[dateOff.DayOfYear] += count;
                    statsInfo.activity.exam += count;
                    statsInfo.activity.lastDay = ((int)statsInfo.activity.year[lastDay.DayOfYear]);
                    statsInfo.activity.dayCnt = ((int)statsInfo.activity.year[dateOff.DayOfYear]);

                    if (lastWeekS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= lastWeekE)
                    {
                        var artWeek = DenseMatrix.OfColumns(new List<List<double>>() { statsInfo.activity.year });
                        statsInfo.activity.lastWeek = ((int)artWeek.SubMatrix(weekDayS.DayOfYear, 7, 0, artWeek.ColumnCount).ColumnSums().Sum());
                        //statsInfo.activity.lastWeek = ((int)statsInfo.activity.year.GetRange(weekDayS.DayOfYear, 7).Sum());
                    }

                    if (weekS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= weekE)
                        statsInfo.activity.week += count;

                    if (lastTermS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= lastTermE)
                    {
                        if (lTermDayS.Year < dateOff.Year)
                        {
                            var lastSts = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync($"{lTermDayS.Year}-{scId}", new PartitionKey("Statistics"));
                            if (lastSts.Status == 200)
                            {
                                using var fileJson = await JsonDocument.ParseAsync(lastSts.ContentStream);
                                var tempSts = fileJson.ToObject<StatsInfo>();
                                var actYer = DenseMatrix.OfColumns(new List<List<double>>() { tempSts.activity.year, statsInfo.activity.year });
                                statsInfo.activity.lastTerm = ((int)actYer.SubMatrix(lTermDayS.DayOfYear, lTermDayE.DayOfYear, 0, 1).ColumnSums().Sum());
                            }
                            else
                                statsInfo.activity.lastTerm = 0;
                        }
                    }

                    if (termS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= termE)
                    {
                        if (termDayS.Year < dateOff.Year)
                        {
                            var lastSts = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync($"{termDayS.Year}-{scId}", new PartitionKey("Statistics"));
                            if (lastSts.Status == 200)
                            {
                                using var fileJson = await JsonDocument.ParseAsync(lastSts.ContentStream);
                                var tempSts = fileJson.ToObject<StatsInfo>();
                                var actYer = DenseMatrix.OfColumns(new List<List<double>>() { tempSts.activity.year, statsInfo.activity.year });
                                statsInfo.activity.term = ((int)actYer.SubMatrix(termDayS.DayOfYear, termDayE.DayOfYear, 0, 1).ColumnSums().Sum());
                            }
                            else
                                statsInfo.activity.term += count;
                        }
                    }

                    statsInfo.activity.upTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
                    statsInfo.activity.all += count;
                    break;
                case "Survey":
                    statsInfo.activity.year[dateOff.DayOfYear] += count;
                    statsInfo.activity.survey += count;
                    statsInfo.activity.lastDay = ((int)statsInfo.activity.year[lastDay.DayOfYear]);
                    statsInfo.activity.dayCnt = ((int)statsInfo.activity.year[dateOff.DayOfYear]);

                    if (lastWeekS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= lastWeekE)
                    {
                        var artWeek = DenseMatrix.OfColumns(new List<List<double>>() { statsInfo.activity.year });
                        statsInfo.activity.lastWeek = ((int)artWeek.SubMatrix(weekDayS.DayOfYear, 7, 0, artWeek.ColumnCount).ColumnSums().Sum());
                        //statsInfo.activity.lastWeek = ((int)statsInfo.activity.year.GetRange(weekDayS.DayOfYear, 7).Sum());
                    }

                    if (weekS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= weekE)
                        statsInfo.activity.week += count;

                    if (lastTermS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= lastTermE)
                    {
                        if (lTermDayS.Year < dateOff.Year)
                        {
                            var lastSts = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync($"{lTermDayS.Year}-{scId}", new PartitionKey("Statistics"));
                            if (lastSts.Status == 200)
                            {
                                using var fileJson = await JsonDocument.ParseAsync(lastSts.ContentStream);
                                var tempSts = fileJson.ToObject<StatsInfo>();
                                var actYer = DenseMatrix.OfColumns(new List<List<double>>() { tempSts.activity.year, statsInfo.activity.year });
                                statsInfo.activity.lastTerm = ((int)actYer.SubMatrix(lTermDayS.DayOfYear, lTermDayE.DayOfYear, 0, 1).ColumnSums().Sum());
                            }
                            else
                                statsInfo.activity.lastTerm = 0;
                        }
                    }

                    if (termS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= termE)
                    {
                        if (termDayS.Year < dateOff.Year)
                        {
                            var lastSts = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync($"{termDayS.Year}-{scId}", new PartitionKey("Statistics"));
                            if (lastSts.Status == 200)
                            {
                                using var fileJson = await JsonDocument.ParseAsync(lastSts.ContentStream);
                                var tempSts = fileJson.ToObject<StatsInfo>();
                                var actYer = DenseMatrix.OfColumns(new List<List<double>>() { tempSts.activity.year, statsInfo.activity.year });
                                statsInfo.activity.term = ((int)actYer.SubMatrix(termDayS.DayOfYear, termDayE.DayOfYear, 0, 1).ColumnSums().Sum());
                            }
                            else
                                statsInfo.activity.term += count;
                        }
                    }

                    statsInfo.activity.upTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
                    statsInfo.activity.all += count;
                    break;
                case "Vote":
                    statsInfo.activity.year[dateOff.DayOfYear] += count;
                    statsInfo.activity.vote += count;
                    statsInfo.activity.lastDay = ((int)statsInfo.activity.year[lastDay.DayOfYear]);
                    statsInfo.activity.dayCnt = ((int)statsInfo.activity.year[dateOff.DayOfYear]);

                    if (lastWeekS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= lastWeekE)
                    {
                        var artWeek = DenseMatrix.OfColumns(new List<List<double>>() { statsInfo.activity.year });
                        statsInfo.activity.lastWeek = ((int)artWeek.SubMatrix(weekDayS.DayOfYear, 7, 0, artWeek.ColumnCount).ColumnSums().Sum());
                        //statsInfo.activity.lastWeek = ((int)statsInfo.activity.year.GetRange(weekDayS.DayOfYear, 7).Sum());
                    }

                    if (weekS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= weekE)
                        statsInfo.activity.week += count;

                    if (lastTermS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= lastTermE)
                    {
                        if (lTermDayS.Year < dateOff.Year)
                        {
                            var lastSts = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync($"{lTermDayS.Year}-{scId}", new PartitionKey("Statistics"));
                            if (lastSts.Status == 200)
                            {
                                using var fileJson = await JsonDocument.ParseAsync(lastSts.ContentStream);
                                var tempSts = fileJson.ToObject<StatsInfo>();
                                var actYer = DenseMatrix.OfColumns(new List<List<double>>() { tempSts.activity.year, statsInfo.activity.year });
                                statsInfo.activity.lastTerm = ((int)actYer.SubMatrix(lTermDayS.DayOfYear, lTermDayE.DayOfYear, 0, 1).ColumnSums().Sum());
                            }
                            else
                                statsInfo.activity.lastTerm = 0;
                        }
                    }

                    if (termS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= termE)
                    {
                        if (termDayS.Year < dateOff.Year)
                        {
                            var lastSts = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync($"{termDayS.Year}-{scId}", new PartitionKey("Statistics"));
                            if (lastSts.Status == 200)
                            {
                                using var fileJson = await JsonDocument.ParseAsync(lastSts.ContentStream);
                                var tempSts = fileJson.ToObject<StatsInfo>();
                                var actYer = DenseMatrix.OfColumns(new List<List<double>>() { tempSts.activity.year, statsInfo.activity.year });
                                statsInfo.activity.term = ((int)actYer.SubMatrix(termDayS.DayOfYear, termDayE.DayOfYear, 0, 1).ColumnSums().Sum());
                            }
                            else
                                statsInfo.activity.term += count;
                        }
                    }

                    statsInfo.activity.upTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
                    statsInfo.activity.all += count;
                    break;
                case "Homework":
                    statsInfo.activity.year[dateOff.DayOfYear] += count;
                    statsInfo.activity.homework += count;
                    statsInfo.activity.lastDay = ((int)statsInfo.activity.year[lastDay.DayOfYear]);
                    statsInfo.activity.dayCnt = ((int)statsInfo.activity.year[dateOff.DayOfYear]);

                    if (lastWeekS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= lastWeekE)
                    {
                        var artWeek = DenseMatrix.OfColumns(new List<List<double>>() { statsInfo.activity.year });
                        statsInfo.activity.lastWeek = ((int)artWeek.SubMatrix(weekDayS.DayOfYear, 7, 0, artWeek.ColumnCount).ColumnSums().Sum());
                        //statsInfo.activity.lastWeek = ((int)statsInfo.activity.year.GetRange(weekDayS.DayOfYear, 7).Sum());
                    }

                    if (weekS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= weekE)
                        statsInfo.activity.week += count;

                    if (lastTermS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= lastTermE)
                    {
                        if (lTermDayS.Year < dateOff.Year)
                        {
                            var lastSts = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync($"{lTermDayS.Year}-{scId}", new PartitionKey("Statistics"));
                            if (lastSts.Status == 200)
                            {
                                using var fileJson = await JsonDocument.ParseAsync(lastSts.ContentStream);
                                var tempSts = fileJson.ToObject<StatsInfo>();
                                var actYer = DenseMatrix.OfColumns(new List<List<double>>() { tempSts.activity.year, statsInfo.activity.year });
                                statsInfo.activity.lastTerm = ((int)actYer.SubMatrix(lTermDayS.DayOfYear, lTermDayE.DayOfYear, 0, 1).ColumnSums().Sum());
                            }
                            else
                                statsInfo.activity.lastTerm = 0;
                        }
                    }

                    if (termS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= termE)
                    {
                        if (termDayS.Year < dateOff.Year)
                        {
                            var lastSts = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync($"{termDayS.Year}-{scId}", new PartitionKey("Statistics"));
                            if (lastSts.Status == 200)
                            {
                                using var fileJson = await JsonDocument.ParseAsync(lastSts.ContentStream);
                                var tempSts = fileJson.ToObject<StatsInfo>();
                                var actYer = DenseMatrix.OfColumns(new List<List<double>>() { tempSts.activity.year, statsInfo.activity.year });
                                statsInfo.activity.term = ((int)actYer.SubMatrix(termDayS.DayOfYear, termDayE.DayOfYear, 0, 1).ColumnSums().Sum());
                            }
                            else
                                statsInfo.activity.term += count;
                        }
                    }

                    statsInfo.activity.upTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
                    statsInfo.activity.all += count;
                    break;
                case "Less":

                    statsInfo.lesson.year[dateOff.DayOfYear] += count;
                    statsInfo.lesson.lastDay = ((int)statsInfo.lesson.year[lastDay.DayOfYear]);
                    statsInfo.lesson.day = ((int)statsInfo.lesson.year[dateOff.DayOfYear]);

                    if (DayS <= statsInfo.lesson.upTime && statsInfo.lesson.upTime <= DayE)
                        statsInfo.lesson.dayInter += interaction;
                    else
                        statsInfo.lesson.dayInter = 0;

                    //if (monthS <= statsInfo.lesson.upTime && statsInfo.lesson.upTime <= monthE)
                    //    statsInfo.lesson.monthInter += interaction;
                    //else
                    //    statsInfo.lesson.monthInter = 0;

                    if (lastWeekS <= statsInfo.activity.upTime && statsInfo.activity.upTime <= lastWeekE)
                    {
                        var artWeek = DenseMatrix.OfColumns(new List<List<double>>() { statsInfo.lesson.year });
                        statsInfo.lesson.lastWeek = ((int)artWeek.SubMatrix(weekDayS.DayOfYear, 7, 0, artWeek.ColumnCount).ColumnSums().Sum());
                        //statsInfo.activity.lastWeek = ((int)statsInfo.activity.year.GetRange(weekDayS.DayOfYear, 7).Sum());
                    }

                    if (weekS <= statsInfo.lesson.upTime && statsInfo.lesson.upTime <= weekE)
                        statsInfo.activity.week += count;

                    if (lastTermS <= statsInfo.lesson.upTime && statsInfo.lesson.upTime <= lastTermE)
                    {
                        if (lTermDayS.Year < dateOff.Year)
                        {
                            var lastSts = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync($"{lTermDayS.Year}-{scId}", new PartitionKey("Statistics"));
                            if (lastSts.Status == 200)
                            {
                                using var fileJson = await JsonDocument.ParseAsync(lastSts.ContentStream);
                                var tempSts = fileJson.ToObject<StatsInfo>();
                                var actYer = DenseMatrix.OfColumns(new List<List<double>>() { tempSts.lesson.year, statsInfo.lesson.year });
                                statsInfo.lesson.lastTerm = ((int)actYer.SubMatrix(lTermDayS.DayOfYear, lTermDayE.DayOfYear, 0, 1).ColumnSums().Sum());
                            }
                            else
                                statsInfo.lesson.lastTerm = 0;
                        }
                    }

                    if (termS <= statsInfo.lesson.upTime && statsInfo.lesson.upTime <= termE)
                    {
                        if (termDayS.Year < dateOff.Year)
                        {
                            var lastSts = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReadItemStreamAsync($"{termDayS.Year}-{scId}", new PartitionKey("Statistics"));
                            if (lastSts.Status == 200)
                            {
                                using var fileJson = await JsonDocument.ParseAsync(lastSts.ContentStream);
                                var tempSts = fileJson.ToObject<StatsInfo>();
                                var actYer = DenseMatrix.OfColumns(new List<List<double>>() { tempSts.lesson.year, statsInfo.lesson.year });
                                statsInfo.lesson.term = ((int)actYer.SubMatrix(termDayS.DayOfYear, termDayE.DayOfYear, 0, 1).ColumnSums().Sum());
                            }
                            else
                                statsInfo.lesson.term += count;
                        }
                    }

                    statsInfo.lesson.upTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
                    statsInfo.lesson.all += count;
                    break;
                case "Student":
                    if (DayS <= statsInfo.stuUpTime && statsInfo.stuUpTime < DayE)
                        statsInfo.dayStu += count;
                    else
                        statsInfo.dayStu = 0;


                    if (weekS <= statsInfo.stuUpTime && statsInfo.stuUpTime < weekE)
                        statsInfo.weekStu += count;
                    else
                        statsInfo.weekStu = 0;

                    if (monthS <= statsInfo.stuUpTime && statsInfo.stuUpTime < monthE)
                        statsInfo.monthStu += count;
                    else
                        statsInfo.monthStu = 0;

                    statsInfo.stuUpTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
                    statsInfo.stu += count;
                    break;
                case "Teacher":
                    if (DayS <= statsInfo.tchUpTime && statsInfo.tchUpTime < DayE)
                        statsInfo.dayTch += count;
                    else
                        statsInfo.dayTch = 0;

                    if (weekS <= statsInfo.tchUpTime && statsInfo.tchUpTime < weekE)
                        statsInfo.weekTch += count;
                    else
                        statsInfo.weekTch = 0;

                    if (monthS <= statsInfo.tchUpTime && statsInfo.tchUpTime < monthE)
                        statsInfo.monthTch += count;
                    else
                        statsInfo.monthTch = 0;

                    statsInfo.tchUpTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
                    statsInfo.tch += count;
                    break;
            }

            if (resStsInfo.Status == 200)
                statsInfo = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").ReplaceItemAsync<StatsInfo>(statsInfo, scId, new PartitionKey("Stats"));
            else
                statsInfo = await cosmosClient.GetContainer(Constant.TEAMModelOS, "School").CreateItemAsync<StatsInfo>(statsInfo, new PartitionKey("Stats"));            
        }
    }
}