using System;

using System.Collections.Generic;

using System.Net;

namespace MLAPI.Relay

{

public sealed class Room

{

private static ulong _roomIdCounter = 0;

private static readonly Queue<ulong> _releasedRoomIds = new Queue<ulong>();

public bool IsValid { get; private set; } = true;

public ulong GenerateRoomId()

{

if (_releasedRoomIds.Count > 0)

{

return _releasedRoomIds.Dequeue();

}

else

{

ulong newRoomId = _roomIdCounter;

_roomIdCounter++;

return newRoomId;

}

}

public ulong ServerConnectionId { get => IsValid ? Server.ConnectionId : 0UL; }

public ulong RoomId { get; private set; }

public Client Server { get; private set; }

//Key connectionId, value Client

private readonly Dictionary<ulong, Client> connectedClients = new Dictionary<ulong, Client>();

public bool HandleClientDisconnect(ulong connectionId, bool serverDisconnect = false)

{

ValidityCheck();

if (Server.ConnectionId == connectionId)

{

// The server just disconnected, tell all the clients in the room

foreach (Client client in connectedClients.Values)

{

// Disconnects the client

Program.Transport.Disconnect(client.ConnectionId);

}

// Delete the room

Program.Rooms.Remove(this);

foreach (EndPoint key in Program.ServerAddressToRoom.Keys)

{

if (Program.ServerAddressToRoom[key] == this)

{

// Remove ourself from the reverse lookup table

Program.ServerAddressToRoom.Remove(key);

break;

}

}

// Release roomId since the room should be considered useless

_releasedRoomIds.Enqueue(RoomId);

connectedClients.Clear();

IsValid = false;

return true;

}

else if (connectedClients.ContainsKey(connectionId))

{

// A client is attempting to disconnect

Client client = connectedClients[connectionId];

if (serverDisconnect)

{

// The server requested this disconnect. Just throw them out.

Program.Transport.Disconnect(connectionId);

}

else

{

// The client was the one that disconnected. Notify the server!

// Write the connectionId of the client that disconnected at the beginning of the buffer.

for (byte i = 0; i < sizeof(ulong); i++) Program.MESSAGE_BUFFER[i] = ((byte)(connectionId >> (i * 8)));

// Write the message type suffixed

Program.MESSAGE_BUFFER[sizeof(ulong)] = (byte)MessageType.ClientDisconnect;

// Send the message to the server

Program.Transport.Send(new ArraySegment<byte>(Program.MESSAGE_BUFFER, 0, sizeof(ulong) + sizeof(byte)), Program.DEFAULT_CHANNEL_BYTE, Server.ConnectionId);

}

// Remove the disconnected client from the list

connectedClients.Remove(connectionId);

return true;

}

return false;

}

public bool Send(ulong toConnectionId, ulong fromConnectionId, byte channelName, ArraySegment<byte> data)

{

if (Program.Config.BandwidthLimit > 0)

{

// Bandwidth control logic

ulong taxedId = Server.ConnectionId == fromConnectionId ? toConnectionId : fromConnectionId;

if (connectedClients.ContainsKey(taxedId))

{

Client clientToBeTaxed = connectedClients[taxedId];

int bandwidthLimit = clientToBeTaxed.IsInBandwidthGracePeriod ? Program.Config.GracePeriodBandwidthLimit : Program.Config.BandwidthLimit;

if (clientToBeTaxed.OutgoingBytes / (DateTime.UtcNow - clientToBeTaxed.ConnectTime).TotalSeconds > bandwidthLimit)

{

// Client used too much bandwidth. Disconnect them

Console.WriteLine("[INFO] Bandwidth exceeded, client disconnected for overdue. The client is " + (clientToBeTaxed.IsInBandwidthGracePeriod ? "" : "not ") + "on grace period");

HandleClientDisconnect(taxedId, true);

return false;

}

// This includes relay overhead!!

// TODO: Strip overhead

clientToBeTaxed.OutgoingBytes += (ulong)data.Count;

}

}

// Send the data

Program.Transport.Send(data, channelName, toConnectionId);

return true;

}

public void HandleClientConnect(Client client)

{

ValidityCheck();

// Inform server of new connection

// Write the messageType

Program.MESSAGE_BUFFER[0] = (byte)MessageType.ConnectToServer; // Event type to send to both server and client

// Send event to client

Program.Transport.Send(new ArraySegment<byte>(Program.MESSAGE_BUFFER, 0, 1), Program.DEFAULT_CHANNEL_BYTE, client.ConnectionId);

// Write the messageType

Program.MESSAGE_BUFFER[8] = (byte)MessageType.ConnectToServer;

// Write the connectionId

for (byte i = 0; i < sizeof(ulong); i++) Program.MESSAGE_BUFFER[i] = ((byte)(client.ConnectionId >> (i * 8)));

// Send connect to client

Program.Transport.Send(new ArraySegment<byte>(Program.MESSAGE_BUFFER, 0, 9), Program.DEFAULT_CHANNEL_BYTE, Server.ConnectionId);

// Add client to active clients list

connectedClients.Add(client.ConnectionId, client);

}

public bool HasPeer(ulong connectionId, out bool isServer)

{

ValidityCheck();

if (isServer = Server.ConnectionId == connectionId)

{

return true;

}

return connectedClients.ContainsKey(connectionId);

}

private void ValidityCheck()

{

if (!IsValid) throw new ObjectDisposedException("Attempt to use an invalid room!");

}

public Room(Client server)

{

this.Server = server;

RoomId = GenerateRoomId();

}

}

}