// КругСвоих Bot SDK for C#
// https://krugsvoih.ru/bots.html
//
// Requires .NET 6+ (uses HttpClient and System.Text.Json).
// No NuGet packages needed.
//
// Quick start:
//
//   var bot = new KsBot("YOUR_TOKEN");
//
//   bot.OnCommand("start", async (msg) =>
//       await bot.SendMessageAsync(msg.ChatId, "Привет! 👋"));
//
//   await bot.RunPollingAsync(CancellationToken.None);

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Threading;
using System.Threading.Tasks;

namespace KrugsvoihBot;

// ── Types ──────────────────────────────────────────────────────────────────────

public class BotError : Exception
{
    public string Description { get; }
    public BotError(string description) : base(description)
        => Description = description;
}

public record BotInfo(
    string Id,
    string Username,
    string DisplayName,
    string? AvatarUrl,
    bool IsBot
);

public record Message(
    string Id,
    string ChatId,
    string SenderId,
    string SenderUsername,
    string Content,
    DateTime SentAt,
    bool IsEdited
);

public record CallbackQuery(
    string Id,
    string FromUserId,
    string FromUsername,
    string ChatId,
    string MessageId,
    string Data
);

public record Update(
    long UpdateId,
    string Type,
    Message? Message,
    CallbackQuery? CallbackQuery
);

public record ChatInfo(string Id, string Name, string Type);

public record ChatMember(
    string UserId,
    string Username,
    string DisplayName,
    string? AvatarUrl,
    string Role,
    bool IsBot
);

public record WebhookInfo(string? Url, int PendingUpdateCount);

public record BotCommand(string Command, string Description);

public record InlineKeyboardButton(
    string Text,
    string? CallbackData = null,
    string? Url = null
);

public record InlineKeyboardMarkup(IList<IList<InlineKeyboardButton>> InlineKeyboard);

public record SendMessageOptions(
    string? ReplyToMessageId = null,
    InlineKeyboardMarkup? ReplyMarkup = null
);

public record SendMediaOptions(
    string? Caption = null,
    InlineKeyboardMarkup? ReplyMarkup = null
);

// ── Client ─────────────────────────────────────────────────────────────────────

public class KsBot
{
    private const string BaseUrl = "https://v.krugsvoih.ru/bot";

    private readonly string _base;
    private readonly HttpClient _http;
    private long _offset;

    private readonly List<Func<Message, Task>> _messageHandlers = new();
    private readonly Dictionary<string, Func<Message, Task>> _commandHandlers = new();
    private readonly List<Func<CallbackQuery, Task>> _callbackHandlers = new();

    private static readonly JsonSerializerOptions JsonOpts = new()
    {
        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
        DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
    };

    public KsBot(string token)
    {
        _base = $"{BaseUrl}/{token}";
        _http = new HttpClient { Timeout = TimeSpan.FromSeconds(40) };
    }

    // ── Low-level request ──────────────────────────────────────────────────────

    private async Task<T> RequestAsync<T>(string method, object? payload = null,
        CancellationToken ct = default)
    {
        var url = $"{_base}/{method}";
        HttpResponseMessage resp;

        if (payload is null)
        {
            resp = await _http.GetAsync(url, ct);
        }
        else
        {
            var body = new StringContent(
                JsonSerializer.Serialize(payload, JsonOpts),
                Encoding.UTF8, "application/json");
            resp = await _http.PostAsync(url, body, ct);
        }

        var raw = await resp.Content.ReadAsStringAsync(ct);
        using var doc = JsonDocument.Parse(raw);
        var root = doc.RootElement;

        if (!root.GetProperty("ok").GetBoolean())
        {
            var desc = root.TryGetProperty("description", out var d) ? d.GetString()! : "Unknown error";
            throw new BotError(desc);
        }

        return JsonSerializer.Deserialize<T>(
            root.GetProperty("result").GetRawText(), JsonOpts)!;
    }

    // ── Bot info ───────────────────────────────────────────────────────────────

    public Task<BotInfo> GetMeAsync(CancellationToken ct = default)
        => RequestAsync<BotInfo>("getMe", null, ct);

    // ── Sending messages ───────────────────────────────────────────────────────

    public Task<Message> SendMessageAsync(string chatId, string text,
        SendMessageOptions? opts = null, CancellationToken ct = default)
    {
        var payload = new Dictionary<string, object?> { ["chatId"] = chatId, ["text"] = text };
        if (opts?.ReplyToMessageId is not null) payload["replyToMessageId"] = opts.ReplyToMessageId;
        if (opts?.ReplyMarkup is not null) payload["replyMarkup"] = opts.ReplyMarkup;
        return RequestAsync<Message>("sendMessage", payload, ct);
    }

    public Task<Message> SendPhotoAsync(string chatId, string photoUrl,
        SendMediaOptions? opts = null, CancellationToken ct = default)
    {
        var payload = new Dictionary<string, object?> { ["chatId"] = chatId, ["photoUrl"] = photoUrl };
        if (opts?.Caption is not null) payload["caption"] = opts.Caption;
        if (opts?.ReplyMarkup is not null) payload["replyMarkup"] = opts.ReplyMarkup;
        return RequestAsync<Message>("sendPhoto", payload, ct);
    }

    public Task<Message> SendDocumentAsync(string chatId, string documentUrl, string fileName,
        SendMediaOptions? opts = null, CancellationToken ct = default)
    {
        var payload = new Dictionary<string, object?>
        {
            ["chatId"] = chatId,
            ["documentUrl"] = documentUrl,
            ["fileName"] = fileName,
        };
        if (opts?.Caption is not null) payload["caption"] = opts.Caption;
        if (opts?.ReplyMarkup is not null) payload["replyMarkup"] = opts.ReplyMarkup;
        return RequestAsync<Message>("sendDocument", payload, ct);
    }

    public Task<Message> ForwardMessageAsync(string fromChatId, string messageId,
        string toChatId, CancellationToken ct = default)
        => RequestAsync<Message>("forwardMessage", new
        {
            fromChatId, messageId, toChatId
        }, ct);

    // ── Editing and deleting ───────────────────────────────────────────────────

    public Task<Message> EditMessageTextAsync(string chatId, string messageId,
        string sentAt, string text, CancellationToken ct = default)
        => RequestAsync<Message>("editMessageText", new { chatId, messageId, sentAt, text }, ct);

    public async Task DeleteMessageAsync(string chatId, string messageId,
        string sentAt, CancellationToken ct = default)
        => await RequestAsync<bool>("deleteMessage", new { chatId, messageId, sentAt }, ct);

    // ── Chat management ────────────────────────────────────────────────────────

    public Task<ChatInfo> GetChatAsync(string chatId, CancellationToken ct = default)
        => RequestAsync<ChatInfo>("getChat", new { chatId }, ct);

    public Task<List<ChatMember>> GetChatMembersAsync(string chatId, CancellationToken ct = default)
        => RequestAsync<List<ChatMember>>("getChatMembers", new { chatId }, ct);

    public Task<ChatMember> GetChatMemberAsync(string chatId, string userId,
        CancellationToken ct = default)
        => RequestAsync<ChatMember>("getChatMember", new { chatId, userId }, ct);

    public async Task BanChatMemberAsync(string chatId, string userId, CancellationToken ct = default)
        => await RequestAsync<bool>("banChatMember", new { chatId, userId }, ct);

    public async Task UnbanChatMemberAsync(string chatId, string userId, CancellationToken ct = default)
        => await RequestAsync<bool>("unbanChatMember", new { chatId, userId }, ct);

    public async Task LeaveChatAsync(string chatId, CancellationToken ct = default)
        => await RequestAsync<bool>("leaveChat", new { chatId }, ct);

    // ── Pinning messages ───────────────────────────────────────────────────────

    public async Task PinMessageAsync(string chatId, string messageId,
        string sentAt, CancellationToken ct = default)
        => await RequestAsync<bool>("pinChatMessage", new { chatId, messageId, sentAt }, ct);

    public async Task UnpinMessageAsync(string chatId, CancellationToken ct = default)
        => await RequestAsync<bool>("unpinChatMessage", new { chatId }, ct);

    // ── Updates ────────────────────────────────────────────────────────────────

    public Task<List<Update>> GetUpdatesAsync(long offset = 0, int limit = 100,
        int timeout = 0, CancellationToken ct = default)
        => RequestAsync<List<Update>>("getUpdates", new { offset, limit, timeout }, ct);

    // ── Webhooks ───────────────────────────────────────────────────────────────

    public async Task SetWebhookAsync(string url, CancellationToken ct = default)
        => await RequestAsync<bool>("setWebhook", new { url }, ct);

    public async Task DeleteWebhookAsync(CancellationToken ct = default)
        => await RequestAsync<bool>("deleteWebhook", null, ct);

    public Task<WebhookInfo> GetWebhookInfoAsync(CancellationToken ct = default)
        => RequestAsync<WebhookInfo>("getWebhookInfo", null, ct);

    // ── Commands ───────────────────────────────────────────────────────────────

    public async Task SetMyCommandsAsync(IEnumerable<BotCommand> commands,
        CancellationToken ct = default)
        => await RequestAsync<bool>("setMyCommands", new { commands }, ct);

    public Task<List<BotCommand>> GetMyCommandsAsync(CancellationToken ct = default)
        => RequestAsync<List<BotCommand>>("getMyCommands", null, ct);

    // ── Callback queries ───────────────────────────────────────────────────────

    public async Task AnswerCallbackQueryAsync(string callbackQueryId,
        string? text = null, bool showAlert = false, CancellationToken ct = default)
        => await RequestAsync<bool>("answerCallbackQuery",
            new { callbackQueryId, text, showAlert }, ct);

    // ── Handler registration ───────────────────────────────────────────────────

    public KsBot OnMessage(Func<Message, Task> handler)
    {
        _messageHandlers.Add(handler);
        return this;
    }

    public KsBot OnMessage(Action<Message> handler)
        => OnMessage(msg => { handler(msg); return Task.CompletedTask; });

    public KsBot OnCommand(string command, Func<Message, Task> handler)
    {
        _commandHandlers[command.TrimStart('/')] = handler;
        return this;
    }

    public KsBot OnCommand(string command, Action<Message> handler)
        => OnCommand(command, msg => { handler(msg); return Task.CompletedTask; });

    public KsBot OnCallback(Func<CallbackQuery, Task> handler)
    {
        _callbackHandlers.Add(handler);
        return this;
    }

    public KsBot OnCallback(Action<CallbackQuery> handler)
        => OnCallback(cb => { handler(cb); return Task.CompletedTask; });

    // ── Dispatch ───────────────────────────────────────────────────────────────

    private async Task DispatchAsync(Update update)
    {
        if (update.Message is { } msg)
        {
            var text = msg.Content ?? "";
            if (text.StartsWith("/"))
            {
                var cmd = text.Split(' ')[0].TrimStart('/').Split('@')[0].ToLower();
                if (_commandHandlers.TryGetValue(cmd, out var h))
                {
                    await h(msg);
                    return;
                }
            }
            foreach (var h in _messageHandlers)
                await h(msg);
        }

        if (update.CallbackQuery is { } cb)
            foreach (var h in _callbackHandlers)
                await h(cb);
    }

    // ── Polling loop ───────────────────────────────────────────────────────────

    public async Task RunPollingAsync(CancellationToken ct, int pollTimeout = 30)
    {
        var me = await GetMeAsync(ct);
        Console.WriteLine($"Bot @{me.Username} started. Press Ctrl+C to stop.");

        while (!ct.IsCancellationRequested)
        {
            try
            {
                var updates = await GetUpdatesAsync(_offset, 100, pollTimeout, ct);
                foreach (var u in updates)
                {
                    try { await DispatchAsync(u); }
                    catch (Exception ex) { Console.Error.WriteLine($"[handler error] {ex.Message}"); }
                    _offset = u.UpdateId + 1;
                }
            }
            catch (OperationCanceledException) { break; }
            catch (BotError ex)
            {
                Console.Error.WriteLine($"[bot error] {ex.Description}");
                await Task.Delay(5000, ct);
            }
            catch (Exception ex)
            {
                Console.Error.WriteLine($"[error] {ex.Message}");
                await Task.Delay(5000, ct);
            }
        }
    }

    // ── Keyboard helpers ───────────────────────────────────────────────────────

    public static InlineKeyboardMarkup InlineKeyboard(params IList<InlineKeyboardButton>[] rows)
        => new(rows);

    public static InlineKeyboardButton CallbackButton(string text, string callbackData)
        => new(text, CallbackData: callbackData);

    public static InlineKeyboardButton UrlButton(string text, string url)
        => new(text, Url: url);
}