StudentManager/StudentManager/Common/ErrorSet.cs

using DryIoc.ImTools;
using StudentManager.Data;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace StudentManager.Common
{
	public class QuestionBase
	{
		public int ID { get; set; } = 0;
		public bool Status { get; set; } = false;
	}

	public class ErrorBase
	{
		public QuestionBase QuestionBase { get; set; } = new QuestionBase();
		public int TotalUseCount { get; set; } = 1;
		public int ErrorCount { get; set; } = 1;
		public int CorrectCount { get; set; } = 0;
	}

	public class DetailErrorInfo
	{
		public QuestionData QuestionData { get; set; } = new QuestionData();
		public int TotalUseCount { get; set; } = 1;
		public int ErrorCount { get; set; } = 1;
		public int CorrectCount { get; set; } = 0;
		public bool Status { get; set; } = false;
	}

	public class DetailErrorSetInfo
	{
		public int TotalQuestionsCount { get; set; } = 0;
		public int TotalErrorSetQuestionsCount { get; set; } = 0;
		public int CorrectCount { get; set; } = 0;
		public int ErrorCount { get; set; } = 0;
		public float ErrorRate { get; set; } = 0;
		public float CorrectRate { get; set; } = 0;
	}

	public class ErrorSet
	{
		public int TotalCount { get { return Errores.Count; } }
		public int CorrectCount { get { return CorrectArray.Count; } }
		public int ErrorCount { get { return ErrorArray.Count; } }
		public Dictionary<int, ErrorBase> Errores { get; set; } = new Dictionary<int, ErrorBase>();
		public List<int> ErrorArray { get; set; } = new List<int>();
		public List<int> CorrectArray { get; set; } = new List<int>();
		public int CorrectThresholds { get; set; } = 2;

		public ErrorBase Get(int id)
		{
			return Errores.ContainsKey(id) ? Errores[id] : null;
		}

		public void UpdateErrorSetData()
		{
			foreach (var item in Errores)
			{
				if (item.Value.QuestionBase.Status == true) CorrectArray.Add(item.Value.QuestionBase.ID);
				else ErrorArray.Add(item.Value.QuestionBase.ID);
			}
		}

		public DetailErrorSetInfo GetDetailErrorSetInfo()
		{
			return new DetailErrorSetInfo
			{
				TotalQuestionsCount = QuestionLib.TotalCount,
				TotalErrorSetQuestionsCount = Errores.Count(),
				CorrectCount = CorrectArray.Count(),
				ErrorCount = ErrorArray.Count(),
				ErrorRate = QuestionLib.TotalCount == 0 ? 100 : ErrorArray.Count() / QuestionLib.TotalCount,
				CorrectRate = Errores.Count() == 0 ? 100 : CorrectArray.Count() / Errores.Count()
			};
		}

		public List<int> GetErrorsList()
		{
			return ErrorArray;
		}


		public ObservableCollection<DetailErrorInfo> GetDetailErrorQuestionList()
		{
			ObservableCollection<DetailErrorInfo> list = new ObservableCollection<DetailErrorInfo>();
			foreach (var item in Errores)
			{
				list.Add(new DetailErrorInfo
				{
					QuestionData = QuestionLib.Instance.Get(item.Key),
					CorrectCount = item.Value.CorrectCount,
					ErrorCount = item.Value.ErrorCount,
					TotalUseCount = item.Value.TotalUseCount,
					Status = item.Value.QuestionBase.Status
				});
			}

			return list;
		}

		public void AddQuestion(QuestionBase question)
		{
			if (question.Status)
			{
				AddCorrectQuestion(question);
			}
			else
			{
				AddErrorQuestion(question);
			}
		}


		public void AddErrorQuestion(QuestionBase question)
		{
			if (Errores.ContainsKey(question.ID))
			{
				Errores[question.ID].TotalUseCount++;
				Errores[question.ID].ErrorCount++;

				CompareToErrorArray(Errores[question.ID]);
			}
			else
			{

				Errores.Add(question.ID, new ErrorBase { QuestionBase = { ID = question.ID } });
				ErrorArray.Add(question.ID);
			}
		}


		public void AddCorrectQuestion(QuestionBase id)
		{
			if (Errores.ContainsKey(id.ID))
			{
				Errores[id.ID].CorrectCount++;
				Errores[id.ID].TotalUseCount++;

				CompareToCorrectArray(Errores[id.ID]);
			}
		}

		private void CompareToErrorArray(ErrorBase id)
		{
			if (id.QuestionBase.Status == false || ErrorArray.Contains(id.QuestionBase.ID)) return;


			if ((id.CorrectCount - id.ErrorCount) <= CorrectThresholds)
			{
				id.QuestionBase.Status = false;
				CorrectArray.Remove(id.QuestionBase.ID);
				ErrorArray.Add(id.QuestionBase.ID);
			}
		}

		private void CompareToCorrectArray(ErrorBase id)
		{
			if (id.QuestionBase.Status == true || CorrectArray.Contains(id.QuestionBase.ID)) return;


			if ((id.CorrectCount - id.ErrorCount) > CorrectThresholds)
			{
				id.QuestionBase.Status = true;
				ErrorArray.Remove(id.QuestionBase.ID);
				CorrectArray.Add(id.QuestionBase.ID);
			}
		}

		public void AddCorrectQuestion(QuestionData question)
		{
			AddCorrectQuestion(new QuestionBase { ID = question.Id });
		}

		public void QueryErrorSet(long id)
		{
			Errores.Clear();

			SQLHelper.Instance.Query<UserQuestionData>(id).ForEach(x =>
			{
				Errores.Add(x.PID, new ErrorBase { CorrectCount = x.CorrectCount, ErrorCount = x.ErrorCount, TotalUseCount = x.CorrectCount + x.ErrorCount, QuestionBase = new QuestionBase { ID= x.PID, Status = x.Status } });
			});
		}
	}
}