using Google.Protobuf.WellKnownTypes;
using Grpc.Core;
using ChatRoomContract.Protocol;

namespace ChatRoom;

public class ChatRoomService : ChatRoomContract.Protocol.ChatRoom.ChatRoomBase
{
    //NOTE: instance-per-request service would need logic to be static or injected from a singleton instance
    private readonly ChatRoomLogic logic = new ChatRoomLogic();

    /// <summary>
    /// Register client with a name
    /// </summary>
    /// <param name="input">Name of client.</param>
	/// <param name="context">Call context.</param>
    /// <returns>Client ID</returns>
    public override Task<ClientId> RegisterClient(RegisterClientRequest request, ServerCallContext context)
    {
        var result = new ClientId { Id = logic.RegisterClient(request.Name) };
        return Task.FromResult(result);
    }

    /// <summary>
    /// Get number of strikes a participant has
    /// </summary>
    /// <param name="input">Client ID</param>
	/// <param name="context">Call context.</param>
    /// <returns>Number of strikes</returns>
    public override Task<Srikes> GetStrikes(ClientId request, ServerCallContext context)
    {
        var result = new Srikes { Strikes = logic.GetStrikes(request.Id) };
        return Task.FromResult(result);
    }

    /// <summary>
    /// Get timestamp until when the client is blocked
    /// </summary>
    /// <param name="input">Client ID</param>
	/// <param name="context">Call context.</param>
    /// <returns>Optional datetime object</returns>
    public override Task<BlockedUntil> GetBlockedUntil(ClientId request, ServerCallContext context)
    {
        var timestamp = logic.GetBlockedUntil(request.Id);
        var result = new BlockedUntil { HasTimestamp = false };
        if (timestamp != null)
        {
            result.HasTimestamp = true;
            result.Timestamp = Timestamp.FromDateTime(timestamp.Value);
        }
        return Task.FromResult(result);
    }

    /// <summary>
    /// Send a message, will be given to a moderator to be approved
    /// </summary>
    /// <param name="input">Message details</param>
	/// <param name="context">Call context.</param>
    /// <returns>Was sending successful, can fail if user is blocked</returns>
    public override Task<BoolResponse> SendMessage(UserMessageRequest request, ServerCallContext context)
    {
        var success = logic.SendMessage(request.ClientId, request.Contents, request.NeedsToBeCensored);
        var result = new BoolResponse { Success = success };
        return Task.FromResult(result);
    }

    /// <summary>
    /// Get the next message which hasn't been approved or rejected
    /// </summary>
    /// <param name="input">Empty</param>
	/// <param name="context">Call context.</param>
    /// <returns>Message object. Returns null if there is no message</returns>
    public override Task<NewUserMessage> GetNewMessage(Empty request, ServerCallContext context)
    {
        var message = logic.GetNewMessage();
        var result = new NewUserMessage { HasMessage = false, Message = new UserMessage() };
        if (message != null)
        {
            result.HasMessage = true;
            result.Message.Id = message.id;
            result.Message.Contents = message.contents;
            result.Message.NeedsToBeCensored = message.needsToBeCensored;
        }
        return Task.FromResult(result);
    }

    /// <summary>
    /// Reject a message
    /// </summary>
    /// <param name="input">Message ID</param>
	/// <param name="context">Call context.</param>
    /// <returns>Empty</returns>
    public override Task<Empty> ApproveMessage(MessageId request, ServerCallContext context)
    {
        logic.ApproveMessage(request.Id);
        return Task.FromResult(new Empty());
    }

    /// <summary>
    /// Approve a message
    /// </summary>
    /// <param name="input">Message ID</param>
	/// <param name="context">Call context.</param>
    /// <returns>Empty</returns>
    public override Task<Empty> RejectMessage(MessageId request, ServerCallContext context)
    {
        logic.RejectMessage(request.Id);
        return Task.FromResult(new Empty());
    }
}