using ChatRoomContract.Protocol;
using Google.Protobuf.WellKnownTypes;
using Grpc.Net.Client;

namespace ChatRoomContract;

public class ChatRoomGrpcClient : IChatRoomService
{
    GrpcChannel channel;
    ChatRoom.ChatRoomClient client;

    public ChatRoomGrpcClient(string address)
    {
        channel = GrpcChannel.ForAddress(address);
        client = new ChatRoom.ChatRoomClient(channel);
    }

    /// <summary>
    /// Approve a message
    /// </summary>
    /// <param name="messageId">Message ID</param>
    public void ApproveMessage(int messageId)
    {
        client.ApproveMessage(new MessageId { Id = messageId });
    }

    /// <summary>
    /// Get timestamp until when the client is blocked
    /// </summary>
    /// <param name="clientId">Client ID</param>
    /// <returns>Optional datetime object</returns>
    public DateTime? GetBlockedUntil(int clientId)
    {
        var result = client.GetBlockedUntil(new ClientId { Id = clientId });
        if (result.HasTimestamp)
        {
            return result.Timestamp.ToDateTime();
        }
        else
        {
            return null;
        }
    }

    /// <summary>
    /// Get the next message which hasn't been approved or rejected
    /// </summary>
    /// <returns>Message object. Returns null if there is no message</returns>
    public Message? GetNewMessage()
    {
        var result = client.GetNewMessage(new Empty());
        if (result.HasMessage)
        {
            return new Message
            {
                id = result.Message.Id,
                contents = result.Message.Contents,
                needsToBeCensored = result.Message.NeedsToBeCensored
            };
        }
        else
        {
            return null;
        }
    }

    /// <summary>
    /// Get number of strikes a participant has
    /// </summary>
    /// <param name="clientId">Client ID</param>
    /// <returns>Number of strikes</returns>
    public int GetStrikes(int clientId)
    {
        var result = client.GetStrikes(new ClientId { Id = clientId });
        return result.Strikes;
    }

    /// <summary>
    /// Register client with a name
    /// </summary>
    /// <param name="name">Name of client, can be duplicate between clients</param>
    /// <returns>Client ID</returns>
    public int RegisterClient(string name)
    {
        var result = client.RegisterClient(new RegisterClientRequest { Name = name });
        return result.Id;
    }

    /// <summary>
    /// Reject a message
    /// </summary>
    /// <param name="messageId">Message ID</param>
    public void RejectMessage(int messageId)
    {
        client.RejectMessage(new MessageId { Id = messageId });
    }

    /// <summary>
    /// Send a message, will be given to a moderator to be approved
    /// </summary>
    /// <param name="clientId">Client ID</param>
    /// <param name="contents">Message contents</param>
    /// <param name="needsToBeCensored">Does this message need to be censored?</param>
    /// <returns>Was sending successful, can fail if user is blocked</returns>
    public bool SendMessage(int clientId, string contents, bool needsToBeCensored)
    {
        var result = client.SendMessage(new UserMessageRequest
        {
            ClientId = clientId,
            Contents = contents,
            NeedsToBeCensored = needsToBeCensored
        });
        return result.Success;
    }
}