private StatisticalBalancer<MMUnit> GetBalancer(Guid slotId)
{
StatisticalBalancer<MMUnit> balancer;
if (BalancerPerBalancerId.TryGetValue(slotId, out balancer))
return balancer;
var scheduledPageGroups = CurrentRingMetaData.ScheduledPageGroups
.Where(x => x.StartTime.TimeOfDay < CurrentReferenceTime.TimeOfDay)
.Where(x => x.SlotId == slotId);
Dictionary<PageGroup, int> occurances = new Dictionary<PageGroup, int>();
foreach (ScheduledPageGroup scheduledPageGroup in scheduledPageGroups)
{
int occurance = 0;
if (!occurances.TryGetValue(scheduledPageGroup.PageGroup, out occurance))
{
occurances.Add(scheduledPageGroup.PageGroup, 0);
occurance = 0;
}
occurances[scheduledPageGroup.PageGroup] = occurance + 1;
}
balancer = new StatisticalBalancer<MMUnit>();
BalancerPerBalancerId.Add(slotId, balancer);
foreach (var occurance in occurances)
{
MMUnit mmUnit = MultimediaDb.MMUnits.Find(occurance.Key.Id);
balancer.Add(mmUnit, TimeSpan.FromSeconds(mmUnit.PlayingDurationSum), 1, occurance.Value);
}
StoreBalancerToDatabase(balancer);
return balancer;
}
void ActualizeBalancers(StatisticalBalancer<MMUnit> balancer,
MMUnit[] involvedMMUnitsShouldBeInBalancer)
{
foreach (MMUnit mmUnit in involvedMMUnitsShouldBeInBalancer)
{
if (balancer.Entries.ContainsKey(mmUnit))
continue;
int importance = 1;
balancer.Add(mmUnit, TimeSpan.FromSeconds(mmUnit.PlayingDurationSum), importance);
}
foreach (MMUnit entriesKey in balancer.Entries.Keys)
{
if (involvedMMUnitsShouldBeInBalancer.Contains(entriesKey))
continue;
balancer.Remove(entriesKey);
}
}
private Dictionary<MMSlot, StatisticalBalancer<MMUnit>> LoadActuallBalancers
(MMSender mmSender, DateTime dateTimeToCheck)
{
Dictionary<MMSlot, StatisticalBalancer<MMUnit>> entriesActuallInBalancer
= new Dictionary<MMSlot, StatisticalBalancer<MMUnit>>();
List<MMSlot> balancedMMSlotsToCheck = new List<MMSlot>();
foreach (MMProgrammBlock programmBlock in mmSender.Get_OrderedProgrammBloecke)
{
foreach (MMProgrammBlockToMMSlot mmProgrammBlockToMMSlot in programmBlock.Get_MMSlotsZuMMProgrammBlockOrdered
.Where(whe => whe.MMProgrammBlockToMMSlotsPlayingTyp.Id == Guid.Parse("F173BC3B-F8B4-407D-90B5-1B717219C444")))
if (!balancedMMSlotsToCheck.Contains(mmProgrammBlockToMMSlot.MMSlot))
balancedMMSlotsToCheck.Add(mmProgrammBlockToMMSlot.MMSlot);
}
foreach (MMSlot mmSlot in balancedMMSlotsToCheck)
{
if (!entriesActuallInBalancer.Keys.Contains(mmSlot))
{
if (dateTimeToCheck.Date == TodaysDate.Date)
{
/*
//TODO
PlayerDb.SetHasBeenLoaded();
RingUpdater ringUpdater = new RingUpdater(mmSender, Ring, Ring.TargetDate);
ringUpdater.Load();
if (ringUpdater.BalancerPerBalancerId.ContainsKey(mmSlot.Id))
entriesActuallInBalancer[mmSlot]
= ringUpdater.BalancerPerBalancerId[mmSlot.Id];
else
*/
entriesActuallInBalancer[mmSlot]
= new StatisticalBalancer<MMUnit>();
}
else
{
entriesActuallInBalancer[mmSlot]
= new StatisticalBalancer<MMUnit>();
}
}
//TODO Actualice the balancer content
//Debug.WriteLine($"Vor dem Ergänzen der Balancer - {dateTimeToCheck} für den Sender {mmSender.NameId}");
//Debug.WriteLine($"\tSlot = {mmSlot.NameId}");
//foreach (MMUnit mmUnit in TodayActiveMMUnitsPerMMSlot[mmSlot].Keys)
// {
// Debug.WriteLine($"\t\t{mmUnit.NameId} - {((IContainTimingAttributes)mmUnit.MMUnitTimings.FirstOrDefault()).FreiText}");
//
ActualizeBalancers(entriesActuallInBalancer[mmSlot],
TodaysActiveMMUnitsPerMMSlot[mmSlot].Keys.ToArray());
//Debug.WriteLine($"Actuelle Entries in Balancer nach dem Aktualisieren");
//foreach (MMUnit entriesKey in entriesActuallInBalancer[mmSlot].Entries.Keys)
// {
// Debug.WriteLine($"\t{entriesKey.NameId}");
// }
}
return entriesActuallInBalancer;
}
private void LoadStoredBalancers()
{
//Letzter Stand der Balancers für jeden Block
IGrouping<Guid, LastGeneratedBalancerState>[] balancerStatesForBlockSlots
= Player.LastGeneratedBalancerStates
.GroupBy(x => (Guid)x.SlotId).ToArray();
foreach (IGrouping<Guid, LastGeneratedBalancerState> balancerStatesForBlockSlot in balancerStatesForBlockSlots)
{
Guid currentBlockSlotId = balancerStatesForBlockSlot.Key;
//Ein Balancer für jeden BlockSlot
StatisticalBalancer<MMUnit> balancerForBlockToSlot = new StatisticalBalancer<MMUnit>();
balancerForBlockToSlot.Tag = currentBlockSlotId;
BalancerPerBalancerId.Add(currentBlockSlotId, balancerForBlockToSlot);
//Befüllen des Balancers mit dem Stand der letzten generierung
foreach (LastGeneratedBalancerState balancerEntry in balancerStatesForBlockSlot)
{
MMUnit mmUnitToAdd = MultimediaDb.MMUnits.Find(balancerEntry.PageGroupId);
int importance = 1;
var useCount = (int)Math.Round(balancerForBlockToSlot.AverageWeightedCount * importance * (decimal)balancerEntry.PercentageToAverageLine, 0);
balancerForBlockToSlot.Add(mmUnitToAdd, TimeSpan.FromSeconds(mmUnitToAdd.PlayingDurationSum), importance, useCount);
}
}
}
private void StoreBalancerToDatabase(StatisticalBalancer<MMUnit> balancer)
{
foreach (StatisticalBalancer<MMUnit>.IStatisticalEntry<MMUnit> statisticalEntry in balancer.Entries.Select(x => x.Value))
{
LastGeneratedBalancerState newStateRow = CurrentRingMetaData.DataSet.LastGeneratedBalancerStates.NewRow();
newStateRow.PageGroupId = statisticalEntry.IData.Id;
newStateRow.SlotId = (Guid)balancer.Tag;
newStateRow.PercentageToAverageLine = (double)(statisticalEntry.IWeightedUseCount / balancer.AverageWeightedCount);
newStateRow.Table.Add(newStateRow);
}
}
public void TestStatisticalBalancer()
{
StatisticalBalancer<String> balancer = new StatisticalBalancer<string>();
int Wertigkeit = 0;
foreach (string s in TestDaten.Keys)
{
balancer.Add(s, TimeSpan.FromSeconds(20), (Wertigkeit%10)+1, 0);
Wertigkeit++;
}
int counter = 0;
while (counter < 10000)
{
String Result = balancer.GetNextItem(TimeSpan.FromSeconds(20));
TestDaten[Result]++;
counter++;
if ((counter % 100) == 1)
DisplayResult(counter);
}
DisplayResult(counter);
}
