import type { PluginSDK, SimpleToolDef, PluginManifest } from "@teleton-agent/sdk";

export const manifest: PluginManifest = {
  name: "greeting",
  version: "1.0.0",
  description: "Sends a greeting with the bot's TON balance",
};

export const tools = (sdk: PluginSDK): SimpleToolDef[] => [
  {
    name: "greeting_hello",
    description: "Greet the user and show the bot wallet balance",
    parameters: {
      type: "object",
      properties: {
        name: { type: "string", description: "User's name" },
      },
      required: ["name"],
    },
    async execute(params, context) {
      const balance = await sdk.ton.getBalance();
      const text = `Hello ${params.name}! Bot balance: ${balance?.balance ?? "unknown"} TON`;
      await sdk.telegram.sendMessage(String(context.chatId), text);
      return { success: true, data: { greeting: text } };
    },
  },
];

import type { PluginMessageEvent } from "@teleton-agent/sdk";

export async function onMessage(event: PluginMessageEvent) {
  // Auto-moderation example: delete messages containing banned words
  if (event.isGroup && /spam|scam/i.test(event.text)) {
    console.log(`Flagged message ${event.messageId} from ${event.senderId}`);
  }
}

import type { PluginCallbackEvent } from "@teleton-agent/sdk";

export async function onCallbackQuery(event: PluginCallbackEvent) {
  // Button data format: "myplugin:action:param1:param2"
  if (event.action !== "myplugin") return; // Not for this plugin

  const [subAction, ...args] = event.params;

  if (subAction === "confirm") {
    await event.answer("Confirmed!", false); // Toast notification
    // ... handle the confirmation
  } else {
    await event.answer("Unknown action", true); // Alert popup
  }
}

import { PluginSDKError } from "@teleton-agent/sdk";

type SDKErrorCode =
  | "BRIDGE_NOT_CONNECTED"   // Telegram bridge not ready
  | "WALLET_NOT_INITIALIZED" // TON wallet not configured
  | "INVALID_ADDRESS"        // Malformed TON address
  | "SECRET_NOT_FOUND"       // Required secret not configured
  | "OPERATION_FAILED";      // Generic failure

import { SDK_VERSION } from "@teleton-agent/sdk";
// "1.0.0"

type TransactionType =
  | "ton_received" | "ton_sent"
  | "jetton_received" | "jetton_sent"
  | "nft_received" | "nft_sent"
  | "gas_refund" | "bounce"
  | "contract_call" | "multi_send";

// Get best quote for swapping 10 TON → USDT
const usdt = "EQCxE6mUtQJKFnGfaROTKOt1lZbDiiX1kCixRv7Nw2Id_sDs";
const quote = await sdk.ton.dex.quote({
  fromAsset: "ton",
  toAsset: usdt,
  amount: 10,
  slippage: 0.01, // 1%
});
console.log(`Best: ${quote.recommended} → ${quote.stonfi?.expectedOutput ?? "N/A"} USDT`);

// Execute the swap
const result = await sdk.ton.dex.swap({ fromAsset: "ton", toAsset: usdt, amount: 10 });

// Check if a domain is available
const info = await sdk.ton.dns.check("mybot.ton");
if (info.available) {
  const result = await sdk.ton.dns.startAuction("mybot.ton");
  sdk.log.info(`Auction started for ${result.domain}`);
} else {
  sdk.log.info(`Domain owned by ${info.owner}`);
}

// Resolve a domain
const resolved = await sdk.ton.dns.resolve("alice.ton");
if (resolved) {
  await sdk.ton.sendTON(resolved.walletAddress!, 1, "Hello from plugin");
}

// Set a TON Site ADNL record
await sdk.ton.dns.setSiteRecord("mysite.ton", "aabbccdd...64hex");

// Gift marketplace flow: browse → check value → make offer
const gifts = await sdk.telegram.getMyGifts(10);
for (const gift of gifts) {
  sdk.log.info(`Gift ${gift.id} from user ${gift.fromId}, worth ${gift.starsAmount} stars`);
}

// Check NFT gift value
const value = await sdk.telegram.getUniqueGiftValue("CryptoBot-42");
if (value?.floorPrice) {
  sdk.log.info(`Floor: ${value.floorPrice} ${value.currency}`);
}

// Transfer a collectible
const result = await sdk.telegram.transferCollectible(gift.messageId!, targetUserId);
sdk.log.info(`Transferred to ${result.transferredTo}, paid: ${result.paidTransfer}`);

const apiKey = sdk.secrets.get("api_key");
if (!apiKey) return { success: false, error: "API key not configured" };

// Simple counter
const count = sdk.storage.get<number>("visits") ?? 0;
sdk.storage.set("visits", count + 1);

// Cache with 5-minute TTL
sdk.storage.set("api_result", data, { ttl: 300_000 });

export const manifest: PluginManifest = {
  name: "my-inline-bot",
  version: "1.0.0",
  bot: {
    inline: true,      // Enable inline query handling
    callbacks: true,    // Enable callback button handling
    rateLimits: {
      inlinePerMinute: 30,   // Default: 30
      callbackPerMinute: 60, // Default: 60
    },
  },
};

sdk.bot.onInlineQuery(async (ctx) => {
  const results = await searchItems(ctx.query);
  return results.map((item) => ({
    id: item.id,
    type: "article",
    title: item.title,
    description: item.description,
    content: { text: item.body, parseMode: "HTML" },
    keyboard: [
      [{ text: "Open", url: item.url }],
      [{ text: "Select", callback: `pick:${item.id}` }],
    ],
  }));
});

sdk.bot.onCallback("pick:*", async (ctx) => {
  const itemId = ctx.match[1]; // Captured from glob
  await ctx.answer(`Selected item ${itemId}`);
  await ctx.editMessage(`You picked: ${itemId}`, {
    keyboard: [[{ text: "Back", callback: "menu" }]],
  });
});

sdk.bot.onChosenResult(async (ctx) => {
  sdk.log.info(`User chose result ${ctx.resultId} for query "${ctx.query}"`);
  // Track analytics, update state, etc.
});

await sdk.bot.editInlineMessage(ctx.inlineMessageId!, "Updated text", {
  keyboard: [
    [{ text: "Confirm", callback: "confirm", style: "success" }],
    [{ text: "Cancel", callback: "cancel", style: "danger" }],
  ],
});

const kb = sdk.bot.keyboard([
  [
    { text: "Buy", callback: "buy:123", style: "success" },
    { text: "Sell", callback: "sell:123", style: "danger" },
  ],
  [{ text: "Details", url: "https://example.com" }],
]);

// Use with GramJS (styled colors)
const tlMarkup = kb.toTL();

// Use with Grammy Bot API (no colors, but wider compatibility)
const grammyKb = kb.toGrammy();

type ButtonStyle = "success" | "danger" | "primary";

type InlineResultContent =
  | { text: string; parseMode?: "HTML" | "Markdown" }
  | { photoUrl: string; thumbUrl?: string; caption?: string }
  | { gifUrl: string; thumbUrl?: string; caption?: string };

import type { PluginSDK, SimpleToolDef, PluginManifest } from "@teleton-agent/sdk";

export const manifest: PluginManifest = {
  name: "price-bot",
  version: "1.0.0",
  description: "Inline token price checker with styled buttons",
  bot: {
    inline: true,
    callbacks: true,
    rateLimits: { inlinePerMinute: 30, callbackPerMinute: 60 },
  },
};

export const tools = (sdk: PluginSDK): SimpleToolDef[] => {
  // Set up inline handlers
  sdk.bot!.onInlineQuery(async (ctx) => {
    const query = ctx.query.trim();
    if (!query) return [];
    const price = await sdk.ton.getJettonPrice(query);
    if (!price) return [];
    return [{
      id: query,
      type: "article",
      title: `${query} Price`,
      description: `$${price.priceUSD ?? "N/A"} | 24h: ${price.change24h ?? "N/A"}`,
      content: { text: `<b>${query}</b>\nUSD: $${price.priceUSD}\n24h: ${price.change24h}`, parseMode: "HTML" },
      keyboard: [[
        { text: "Refresh", callback: `refresh:${query}`, style: "primary" },
        { text: "Buy", callback: `buy:${query}`, style: "success" },
      ]],
    }];
  });

  sdk.bot!.onCallback("refresh:*", async (ctx) => {
    const token = ctx.match[1];
    const price = await sdk.ton.getJettonPrice(token);
    await ctx.editMessage(`<b>${token}</b>\nUSD: $${price?.priceUSD}\n24h: ${price?.change24h}`, {
      keyboard: [[
        { text: "Refresh", callback: `refresh:${token}`, style: "primary" },
        { text: "Buy", callback: `buy:${token}`, style: "success" },
      ]],
    });
    await ctx.answer("Price updated!");
  });

  // Regular tools still work alongside inline mode
  return [{
    name: "price_check",
    description: "Check a token's price",
    parameters: {
      type: "object",
      properties: { token: { type: "string", description: "Jetton address" } },
      required: ["token"],
    },
    async execute(params) {
      const price = await sdk.ton.getJettonPrice(params.token);
      return { success: true, data: price };
    },
  }];
};

type ToolScope = "always" | "dm-only" | "group-only" | "admin-only";

type ToolCategory = "data-bearing" | "action";

import { PluginSDKError } from "@teleton-agent/sdk";

async execute(params, context) {
  try {
    await sdk.ton.sendTON(params.address, params.amount);
    return { success: true };
  } catch (err) {
    if (err instanceof PluginSDKError) {
      switch (err.code) {
        case "WALLET_NOT_INITIALIZED":
          return { success: false, error: "Bot wallet not configured" };
        case "INVALID_ADDRESS":
          return { success: false, error: "Bad address format" };
        default:
          return { success: false, error: err.message };
      }
    }
    throw err; // Re-throw unexpected errors
  }
}