const assert = require("assert");
const placeholders = require("../src/services/placeholders");
const { getSetting, setSetting } = require("../src/services/settings");

const {
  placeholders: placeholderMap,
  fieldPolicies
} = placeholders._internals;

placeholderMap.clear();
fieldPolicies.clear();
placeholders.registerCorePlaceholders();
placeholders.registerFieldPolicy({
  field_id: "okf.markdown",
  label: "OKF Markdown",
  field_type: "okf_markdown",
  output_audience: "user",
  min_editor_role: "user",
  allowed_namespaces: [],
  max_sensitivity: "admin"
});

const user = { id: "user-1", username: "Viewer", isAdmin: false, isMod: false };
const mod = { id: "mod-1", username: "Mod", isAdmin: false, isMod: true };
const admin = { id: "admin-1", username: "Admin", isAdmin: true, isMod: true };

let catalog = placeholders.catalog({
  fieldId: "core.custom_commands.static_response",
  user: mod,
  outputAudience: "user"
});
assert(catalog.placeholders.some((entry) => entry.token === "{{core.main.bot_name}}"));
assert(catalog.placeholders.some((entry) => entry.token === "{{user.public.display_name}}"));

placeholders.registerPlaceholder({
  id: "core.main.admin_note",
  namespace: "core.main",
  label: "Admin note",
  sensitivity: "admin",
  min_editor_role: "admin",
  min_viewer_role: "admin",
  allowed_field_types: ["command_response"],
  resolver: () => "hidden"
});

catalog = placeholders.catalog({
  fieldId: "core.custom_commands.static_response",
  user: admin,
  outputAudience: "user"
});
assert.equal(catalog.placeholders.some((entry) => entry.token === "{{core.main.admin_note}}"), false);

const invalid = placeholders.validateTemplate({
  fieldId: "core.custom_commands.static_response",
  template: "Hello {{core.main.admin_note}}",
  user: admin,
  outputAudience: "user"
});
assert.equal(invalid.ok, false);
assert.equal(invalid.errors[0].reason, "viewer_role_forbidden");

(async () => {
  const rendered = await placeholders.renderTemplate({
    fieldId: "core.custom_commands.static_response",
    template: "Hi {{user.public.display_name}}, prefix is {{core.main.command_prefix}}.",
    user,
    outputAudience: "user",
    runtimeContext: {
      runtime: true,
      user: { displayName: "SammyCat" }
    }
  });
  assert.equal(rendered.ok, true);
  assert.match(rendered.rendered, /^Hi SammyCat, prefix is .+\.$/);

  const previousGuildId = getSetting("discord_guild_id", "");
  try {
    setSetting("discord_guild_id", "guild-1");
    placeholders.registerPlatformPlaceholders({
      discordClient: {
        guilds: {
          cache: new Map([
            ["guild-1", {
              name: "Cozy Carnage",
              memberCount: 42,
              createdAt: new Date("2025-01-01T00:00:00.000Z"),
              channels: { cache: new Map([
                ["text", { type: 0 }],
                ["voice", { type: 2 }]
              ]) },
              roles: { cache: new Map([["role", {}]]) },
              emojis: { cache: new Map([["emoji", {}]]) },
              premiumSubscriptionCount: 3
            }]
          ])
        }
      }
    });
    const platformCatalog = placeholders.catalog({
      fieldId: "okf.markdown",
      user: admin,
      outputAudience: "user"
    });
    assert(platformCatalog.placeholders.some((entry) => entry.token === "{{platform.discord.guild.member_count}}"));

    const platformRendered = await placeholders.renderTemplate({
      fieldId: "okf.markdown",
      template: "Discord has {{platform.discord.guild.member_count}} members.",
      user: admin,
      outputAudience: "user",
      runtimeContext: { runtime: true }
    });
    assert.equal(platformRendered.rendered, "Discord has 42 members.");
  } finally {
    setSetting("discord_guild_id", previousGuildId);
  }

  placeholders.registerPlaceholder({
    id: "okf.admin.secret",
    namespace: "okf.admin",
    label: "Admin secret",
    sensitivity: "admin",
    min_editor_role: "admin",
    min_viewer_role: "admin",
    allowed_field_types: ["okf_markdown"],
    resolver: () => "secret"
  });
  const userVisibleAdminPlaceholder = placeholders.validateTemplate({
    fieldId: "okf.markdown",
    template: "{{okf.admin.secret}}",
    user: admin,
    outputAudience: "user"
  });
  assert.equal(userVisibleAdminPlaceholder.ok, false);
  assert.equal(userVisibleAdminPlaceholder.errors[0].reason, "viewer_role_forbidden");
  console.log("Placeholder verification passed.");
})().catch((error) => {
  console.error(error);
  process.exit(1);
});