using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Text.Json;

#nullable enable

namespace Adaptation.FileHandlers.Priority;

public class WeightedShortestJobFirstHub : Microsoft.AspNet.SignalR.Hub
{

    // public async Task Send(int n)
    // {
    //     await Clients.All.send(n);
    // }

    private string? GetRemoteIpAddress() =>
        Context?.Headers?.Get("X-Real-IP");

    public void Send(string name, string message)
    {
        Console.WriteLine($"{name}:{message};");
        // FileRead.Logger.LogWarning($"{name}:{message};");
        // FileRead.Log?.Info($"{name}:{message};");
        Console.WriteLine(Context?.ConnectionId);
        // FileRead.Logger.LogWarning(Context?.ConnectionId);
        // FileRead.Log?.Info(Context?.ConnectionId);
        string? remoteIpAddress = GetRemoteIpAddress();
        Console.WriteLine(remoteIpAddress);
        // FileRead.Logger.LogWarning(remoteIpAddress);
        // FileRead.Log?.Info(remoteIpAddress);
        Clients.All.addMessage(name, message);
    }

    private static void FileWriteAllText(Settings settings, Notification n)
    {
        string json = JsonSerializer.Serialize(n, NotificationSourceGenerationContext.Default.Notification);
        string directory = Path.Combine(settings.SourceFileLocation, n.Page, n.Id.ToString());
        if (!Directory.Exists(directory))
            _ = Directory.CreateDirectory(directory);
        string checkFile = Path.Combine(directory, $"{n.Time}.json");
        File.WriteAllText(checkFile, json);
    }

    internal static void WriteJson(string json)
    {
        string jsonFile = Path.Combine(FileRead.Settings.ParentDirectory, "{}.json");
        string jsonFileWith = Path.Combine(FileRead.Settings.ParentDirectory, "{[]}.json");
        string jsonOld = File.Exists(jsonFileWith) ? File.ReadAllText(jsonFileWith) : string.Empty;
        if (json != jsonOld)
        {
            File.WriteAllText(jsonFileWith, json);
            Dictionary<int, WorkItem> w = JsonSerializer.Deserialize(json.Replace($"\"{nameof(Aggregation.Notifications)}\":", "\"ignore\":"), WorkItemDictionarySourceGenerationContext.Default.DictionaryInt32WorkItem) ?? throw new Exception();
            json = JsonSerializer.Serialize(w, WorkItemDictionarySourceGenerationContext.Default.DictionaryInt32WorkItem);
            File.WriteAllText(jsonFile, json);
        }
    }

    internal static string? PopulatedWorkItemsAndGetJson(Settings settings)
    {
        string? result = null;
        ReadOnlyDictionary<int, WorkItem?> workItems = WorkItem.GetKeyValuePairs(settings);
        int useCount = (from l in workItems where l.Value.CostOfDelay is not null select true).Count();
        double prioritySize = useCount / settings.Priorities;
        double priorityGroupSize = useCount / settings.PriorityGroups;
        WorkItem[] sorted = (from l in workItems
                             where l.Value is not null
                             orderby l.Value.Site is not null,
                                     l.Value.Site descending,
                                     l.Value.CostOfDelay is not null,
                                     l.Value.CostOfDelay descending,
                                     l.Value.BusinessValue?.FibonacciAverage is not null,
                                     l.Value.BusinessValue?.FibonacciAverage descending,
                                     l.Key
                             select l.Value).ToArray();
        lock (FileRead.WorkItems)
        {
            int j = 0;
            WorkItem w;
            double value;
            int lastId = -1;
            int? sortBeforeId;
            WorkItem workItem;
            int? sortPriority;
            int? sortPriorityGroup;
            FileRead.WorkItems.Clear();
            for (int i = 0; i < sorted.Length; i++)
            {
                w = sorted[i];
                if (w.CostOfDelay is null)
                {
                    sortBeforeId = null;
                    sortPriority = null;
                    sortPriorityGroup = null;
                }
                else
                {
                    j += 1;
                    sortBeforeId = lastId;
                    value = (j / prioritySize) + 1;
                    sortPriority = (int)Math.Floor(value);
                    if (sortPriority > settings.Priorities)
                        sortPriority = settings.Priorities;
                    value = (j / priorityGroupSize) + 1;
                    sortPriorityGroup = (int)Math.Floor(value);
                    if (sortPriorityGroup > settings.PriorityGroups)
                        sortPriorityGroup = settings.PriorityGroups;
                }
                workItem = WorkItem.GetWorkItem(w, i, sortBeforeId, sortPriority, sortPriorityGroup);
                FileRead.WorkItems.Add(workItem.Id, workItem);
                lastId = w.Id;
            }
            result = JsonSerializer.Serialize(FileRead.WorkItems, WorkItemDictionarySourceGenerationContext.Default.DictionaryInt32WorkItem);
        }
        return result;
    }

    private static WorkItem GetWorkItem(Notification notification)
    {
        WorkItem? result;
        lock (FileRead.WorkItems)
        {
            if (!FileRead.WorkItems.TryGetValue(notification.Id, out result))
                throw new Exception();
        }
        return result;
    }

    public void NotifyAll(Notification notification)
    {
        try
        {
            string? json = null;
            string? remoteIpAddress = GetRemoteIpAddress();
            Notification n = Notification.GetNotification(notification, remoteIpAddress, Context?.ConnectionId);
            Console.WriteLine(n.ToString());
            // FileRead.Logger.LogWarning(n.ToString());
            // FileRead.Log?.Info(n.ToString());
            FileWriteAllText(FileRead.Settings, n);
            json = PopulatedWorkItemsAndGetJson(FileRead.Settings);
            if (!string.IsNullOrEmpty(json))
                WriteJson(json);
            if (!string.IsNullOrEmpty(n.RemoteIpAddress))
            {
                WorkItem workItem = GetWorkItem(n);
                Clients.All.updateWorkItem(n.Page, workItem);
            }
        }
        catch (Exception ex)
        { Console.WriteLine($"{ex.Message}{Environment.NewLine}{ex.StackTrace}"); }
        // { FileRead.Logger.LogError(ex, "Error!"); }
        // { FileRead.Log?.Error("Error!", ex); }
    }

}