using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using MDP.SID.Scripting.Grpc;
using MDP.SID.Shared.Public.Events;
using Newtonsoft.Json;
using Event = MDP.SID.Scripting.Grpc.Event;
using Timer = System.Timers.Timer;

public class Interval
{
    public TimeSpan Start { get; set; }
    public TimeSpan End { get; set; }
    public string Name { get; set; }
}

private readonly Interval[] _accessIntervals =
{
    // Set schedule range and access level name
    // TimeSpan(hours, minutes, seconds)
    // Name = "Access_level"
    new() {Start = new TimeSpan(16, 23, 0), End = new TimeSpan(16, 24, 0), Name = "Breakfast"},
    new() {Start = new TimeSpan(10, 24, 0), End = new TimeSpan(16, 25, 0), Name = "Everywhere"},
    new() {Start = new TimeSpan(16, 25, 0), End = new TimeSpan(16, 26, 0), Name = "Dinner"}
};

// Set a list of door names that will be monitored
private readonly string[] _canteenDoors =
{
  "Canteen_Door_1", "Canteen_Door_2"
};

/// <summary>
/// True -> remove last access granted user al with door open event
/// False -> remove user al with access granted event
/// </summary>
private const bool RemoveUserAlThenDoorOpened = true;

// Set time when access levels will reset
public readonly TimeSpan AccessLevelsResetTime = new(16, 27, 0);    

private string _path;

private readonly SemaphoreSlim _semaphoreSlim = new(1);

private Timer _timer;

private Timer _lastAccessGrantTimer;

private static readonly ConcurrentDictionary<int, IList<string>> _failedAddOrUpdate = new();

private int? _lastAccessGrantedUserId;

private int? _lastAccessGrantedId; 

private async Task ResetUsersAccessLevelsAsync()
{
    try
    {
        await _semaphoreSlim.WaitAsync();

        if (File.Exists(_path) is false)
        {
            Context.LogError("Users file not found");

            return;
        }

        var alNames = _accessIntervals.Select(a => a.Name);

        var accessLevels = await Context.GetAccessLevelsAsync();

        var updateEntities = accessLevels
            .Where(a => alNames.Contains(a.Name))
            .Select(a => new EntityUpdate { Id = a.Id, Update = true })
            .ToList();

        updateEntities.AddRange(accessLevels
            .Where(a => alNames.Contains(a.Name) is false)
            .Select(a => new EntityUpdate { Id = a.Id}));

        var text = await File.ReadAllTextAsync(_path);

        var users = JsonConvert.DeserializeObject<Dictionary<int, IList<string>>>(text);

        if (users is null || users.Any() is false)
        {
            Context.LogWarning("Users file empty");

            return;
        }

        var userIds = users.Keys.ToArray();

        var configuration = new BulkUpdateUser();

        configuration.AccessLevels.AddRange(updateEntities);

        await Context.BulkUpdateUsersAsync(0, userIds.Length, userIds, configuration);

        File.Delete(_path);

        Context.LogInformation("Users file deleted after bulk update operation");
    }
    catch (Exception ex)
    {
        Context.LogError($"Failed reset users access levels. Exception: {ex.Message}");
    }
    finally
    {
        _semaphoreSlim.Release();
    }
}

private void AddOrUpdateUser(int userId, string accessLevel)
{
    try
    {
        _semaphoreSlim.Wait();

        Dictionary<int, IList<string>> users;

        if (File.Exists(_path) is false)
        {
            users = new Dictionary<int, IList<string>>();
        }
        else
        {
            var text = File.ReadAllText(_path);

            users = JsonConvert.DeserializeObject<Dictionary<int, IList<string>>>(text);

            // no content
            if (users is null)
            {
                users = new Dictionary<int, IList<string>>();
            }
        }

        AddFromFailed(users);

        if (users.TryGetValue(userId, out var accessLevels))
        {
            if (accessLevels.Contains(accessLevel) is false)
            {
                accessLevels.Add(accessLevel);
            }
        }
        else
        {
            users.Add(userId, new List<string> { accessLevel });
        }

        var output = JsonConvert.SerializeObject(users);

        File.WriteAllText(_path, output);

        _failedAddOrUpdate.Clear();
    }
    catch (Exception ex)
    {
        Context.LogError($"Failed add or update user with Id: {userId} al: {accessLevel}. Exception: {ex.Message}");

        AddToFailed(userId, accessLevel);
    }
    finally
    {
        _semaphoreSlim.Release();
    }
}

private void AddToFailed(int userId, string accessLevel)
{
    if (_failedAddOrUpdate.TryGetValue(userId, out var als))
    {
        if (als.Contains(accessLevel)) return;

        var newAls = new List<string>(als) { accessLevel };

        _failedAddOrUpdate.TryUpdate(userId, newAls, als);
    }
    else
    {
        _failedAddOrUpdate.TryAdd(userId, new List<string> { accessLevel });
    }
}

private void AddFromFailed(Dictionary<int, IList<string>> users)
{
    foreach (var user in _failedAddOrUpdate)
    {
        if (users.TryGetValue(user.Key, out var accessLevels))
        {
            foreach (var al in user.Value)
            {
                if (accessLevels.Contains(al)) continue;

                accessLevels.Add(al);
            }
        }
        else
        {
            users.Add(user.Key, user.Value);
        }
    }
}

private async void EventReceived(Event received)
{
	if (_canteenDoors.Contains(received.DoorName) is false) return;

	if (Guid.TryParse(received.TypeUid, out var typeUid) is false) return;

	if (typeUid == EventTypes.AccessGranted)
	{
		if (received.UserId.HasValue is false) return;

        var eventTime = received.Time.ToDateTime().ToLocalTime().TimeOfDay;

        var interval = _accessIntervals.FirstOrDefault(a => a.End >= eventTime && a.Start <= eventTime);

        if (interval is null) return;

		_lastAccessGrantedUserId = received.UserId.Value;

		if (RemoveUserAlThenDoorOpened)
		{
			if (_lastAccessGrantedId.HasValue)
			{
			    await Context.SetEventsDescriptionAsync(new List<int> { (int)_lastAccessGrantedId }, "Ignore");
			}

            _lastAccessGrantedId = received.Id;

            if (_lastAccessGrantTimer is not null && _lastAccessGrantTimer.Enabled) return;

            var timeToIntervalEnd = interval.End - eventTime;

            StartLastAccessGrantTimer(timeToIntervalEnd);
        }
		else
		{
			await RemoveUserAccessLevelAsync(received);
		}
	}
	else if (RemoveUserAlThenDoorOpened && typeUid == EventTypes.DoorOpened)
	{
		await RemoveUserAccessLevelAsync(received);
	}
}

private async Task RemoveUserAccessLevelAsync(Event received)
{
    if (_lastAccessGrantedUserId.HasValue is false) return;

    try
    {
        var eventTime = received.Time.ToDateTime().ToLocalTime().TimeOfDay;

        var interval = _accessIntervals.FirstOrDefault(a => a.End >= eventTime && a.Start <= eventTime);

        if (interval is null) return;

        var userAccessLevels = await Context.GetUserAccessLevelsAsync(_lastAccessGrantedUserId.Value);

        var userAccessLevel = userAccessLevels.FirstOrDefault(a => a.Name == interval.Name);

        if (userAccessLevel is null)
        {
            Context.LogWarning($"Al for user with Id: {_lastAccessGrantedUserId.Value} not found");

            return;
        }

        await Context.DeleteUserAccessLevelAsync(userAccessLevel.Id);

        Context.LogDebug($"Al: {userAccessLevel.Name} removed for user with Id: {_lastAccessGrantedUserId.Value}");

        AddOrUpdateUser(_lastAccessGrantedUserId.Value, userAccessLevel.Name);
    }
    finally
    {
        _lastAccessGrantedUserId = null;

        _lastAccessGrantedId = null;
    }
}

private void StartLastAccessGrantTimer(TimeSpan interval)
{
    Context.LogDebug($"Time until last access grant event hit: {interval}");

    _lastAccessGrantTimer = new Timer(interval.TotalMilliseconds);

    _lastAccessGrantTimer.Elapsed += async (_, _) => await OnLastAccessGrantEvent();

    _lastAccessGrantTimer.AutoReset = false;

    _lastAccessGrantTimer.Start();
}

private async Task OnLastAccessGrantEvent()
{
    if (_lastAccessGrantedId.HasValue)
    {
        await Context.SetEventsDescriptionAsync(new List<int> { (int)_lastAccessGrantedId }, "Ignore");

        _lastAccessGrantedId = null;
    }
}

private async Task OnResetEvent()
{
    _timer.Interval = new TimeSpan(24, 0, 0).TotalMilliseconds;

    _timer.Start();

    Context.LogInformation("Reset users al's event raised");

    await ResetUsersAccessLevelsAsync();
}

Context.OnEventReceived += EventReceived;

var timeToReset = AccessLevelsResetTime - DateTime.Now.TimeOfDay;

if (timeToReset.CompareTo(TimeSpan.Zero) < 0)
{
    timeToReset = new TimeSpan(1, AccessLevelsResetTime.Hours, AccessLevelsResetTime.Minutes, AccessLevelsResetTime.Seconds) - DateTime.Now.TimeOfDay;
}

Context.LogDebug($"Time until al reset first time hit : {timeToReset}");

_timer = new Timer(timeToReset.TotalMilliseconds);
_timer.Elapsed += async (_, _) => await OnResetEvent();
_timer.AutoReset = false;
_timer.Start();

var scriptFilesPath = await Context.GetScriptFilesPathAsync();

_path = Path.Combine(scriptFilesPath, "Canteen.txt");

CancellationToken.WaitHandle.WaitOne();

_timer.Stop();

_timer.Dispose();

if (_lastAccessGrantTimer is not null)
{
    _lastAccessGrantTimer.Stop();

    _lastAccessGrantTimer.Dispose();
}

Context.LogInformation("Script stopped");