import type {
    NotificationChannel,
    NotificationContext,
    NotificationPackage,
} from "@visulima/vis/release/plugin-sdk";

interface NotificationChannel {
    /** Stable id used in log messages: `"slack"`, `"discord"`, `"teams"`, …. */
    readonly id: string;

    /**
     * Send the notification. Throw on hard failure (HTTP non-2xx,
     * network error). The dispatcher catches and logs as a warn-level
     * message; it does NOT propagate.
     */
    send(context: NotificationContext): Promise<void>;
}

interface NotificationContext {
    /** Active channel name (`main`, `alpha`, …). */
    channel?: string;
    /** ISO-8601 wave-completion timestamp. */
    completedAt: string;
    /** Workspace name pulled from root `package.json#name`. */
    monorepoName?: string;
    /** Packages that successfully published in this wave. */
    published: ReadonlyArray<NotificationPackage>;
    /** Repo slug (`owner/name`). */
    repo?: string;
    /** Packages skipped at the publish gate. */
    skipped: ReadonlyArray<{ name: string; reason: string }>;
}

interface NotificationPackage {
    name: string;
    version: string;
    /** Release URL when known (`undefined` for packages with no canonical URL). */
    url?: string;
    /** dist-tag / channel name (`latest`, `alpha`, …). */
    tag?: string;
}

// vis.config.ts
export default {
    release: {
        notifications: {
            plugins: [
                "./.vis/release/teams-channel.ts",
                // Or with options (factory form):
                ["./.vis/release/incident-channel.ts", { severity: "info" }],
            ],
        },
    },
};

// .vis/release/teams-channel.ts
import {
    defineNotificationChannel,
    type NotificationChannel,
    type NotificationContext,
} from "@visulima/vis/release/plugin-sdk";

export interface TeamsChannelOptions {
    /** Microsoft Graph endpoint — your tenant + chat id baked in. */
    endpoint: string;
    /** OAuth bearer token (env-substituted in vis.config.ts). */
    token: string;
    /** Optional title template. Defaults to "Released {count} packages". */
    titleTemplate?: string;
}

/**
 * Factory form — receives the options object from the
 * `["./teams-channel.ts", { ...options }]` config tuple.
 */
export default (options: TeamsChannelOptions): NotificationChannel => defineNotificationChannel({
    id: "teams",

    async send(context: NotificationContext) {
        const title = (options.titleTemplate ?? "Released {count} packages")
            .replaceAll("{count}", String(context.published.length))
            .replaceAll("{repo}", context.repo ?? "")
            .replaceAll("{channel}", context.channel ?? "");

        const packageList = context.published
            .map((p) => p.url ? `<li><a href="${p.url}">${p.name}@${p.version}</a></li>` : `<li>${p.name}@${p.version}</li>`)
            .join("");

        const body = {
            body: {
                contentType: "html",
                content: `<h2>${title}</h2><ul>${packageList}</ul>`,
            },
        };

        let response: Response;

        try {
            response = await fetch(options.endpoint, {
                method: "POST",
                headers: {
                    "Authorization": `Bearer ${options.token}`,
                    "Content-Type": "application/json",
                },
                body: JSON.stringify(body),
            });
        } catch (error) {
            // Wrap the underlying error so neither the token (in
            // Authorization) nor any URL fragments leak into the log line.
            const reason = error instanceof Error ? error.name : "NetworkError";

            throw new Error(`Teams channel fetch failed (${reason})`);
        }

        if (!response.ok) {
            const errorBody = await response.text().catch(() => "");

            throw new Error(`Teams channel returned ${response.status} ${response.statusText}${errorBody ? `: ${errorBody.slice(0, 200)}` : ""}`);
        }
    },
});

// vis.config.ts
export default {
    release: {
        notifications: {
            plugins: [
                ["./.vis/release/teams-channel.ts", {
                    endpoint: "https://graph.microsoft.com/v1.0/chats/19:.../messages",
                    token: "${TEAMS_BOT_TOKEN}",
                    titleTemplate: "🚀 {repo} shipped {count} packages",
                }],
            ],
        },
    },
};

import {
    VersionActions,
    type PublishContext,
    type PublishResult,
} from "@visulima/vis/release/plugin-sdk";

abstract class VersionActions {
    /** Stable id (`"npm"`, `"cargo"`, `"shell"`, or a path for custom). */
    public abstract readonly id: string;

    /**
     * Read the current published version of this package from the registry.
     * Returns `undefined` for packages never published / not yet live.
     */
    public abstract readPublishedVersion(context: {
        pkg: WorkspacePackage;
        pm: PackageManagerAdapter;
    }): Promise<string | undefined>;

    /**
     * Publish this package. Responsible for: protocol resolution, catalog
     * rewriting, clean-package-json, pack-then-publish via the adapter.
     */
    public abstract publish(context: PublishContext): Promise<PublishResult>;
}

// vis.config.ts
export default {
    release: {
        packages: {
            "@scope/internal-package": {
                versionActions: "./.vis/release/verdaccio-actions.ts",
                // Per-package config your actions can read off
                // PublishContext.perPackageConfig:
                registry: "https://verdaccio.internal.example.com/",
            },
        },
    },
};

// .vis/release/verdaccio-actions.ts
import {
    VersionActions,
    type PublishContext,
    type PublishResult,
} from "@visulima/vis/release/plugin-sdk";

export default class VerdaccioVersionActions extends VersionActions {
    public readonly id = "verdaccio" as const;

    /**
     * Query the Verdaccio HTTP API directly. Cheaper than `npm view`
     * (no subprocess), and lets us distinguish "404 / never published"
     * from "503 / registry unreachable" without parsing npm CLI output.
     */
    public async readPublishedVersion(context: Parameters<VersionActions["readPublishedVersion"]>[0]): Promise<string | undefined> {
        const registry = process.env.VERDACCIO_URL ?? "https://verdaccio.internal.example.com/";
        const url = `${registry.replace(/\/$/, "")}/${encodeURIComponent(context.pkg.name)}`;

        let response: Response;

        try {
            response = await fetch(url, {
                headers: { Authorization: `Bearer ${process.env.VERDACCIO_TOKEN ?? ""}` },
            });
        } catch {
            // Network failure — treat as "unknown" so the orchestrator
            // falls back to the manifest version. Do not throw —
            // readPublishedVersion is a probe, not a gate.
            return undefined;
        }

        if (response.status === 404) {
            return undefined; // package not in registry yet
        }

        if (!response.ok) {
            return undefined; // soft-fail; orchestrator handles fallback
        }

        const body = await response.json() as { "dist-tags"?: Record<string, string> };

        return body["dist-tags"]?.latest;
    }

    /**
     * Pack + publish to Verdaccio. Reuses the active adapter for the
     * pack step (so workspace: protocols resolve correctly) and shells
     * out for the upload (Verdaccio accepts the npm publish protocol).
     */
    public async publish(context: PublishContext): Promise<PublishResult> {
        const registry = context.registry ?? process.env.VERDACCIO_URL ?? "https://verdaccio.internal.example.com/";

        if (context.dryRun) {
            return {
                output: `[verdaccio:dry-run] would publish ${context.pkg.name}@${context.release.newVersion} to ${registry}`,
                published: false,
            };
        }

        // 1. Pack via the active adapter — npm/pnpm/yarn/bun all work.
        const packResult = await context.pm.pack(context.pkg.dir, {
            registry,
            tag: context.tag,
        });

        // 2. Push the tarball. `npm publish <tarball> --registry=...` works
        //    against any npm-protocol-compatible registry, Verdaccio included.
        const publishResult = await context.pm.runner.run(
            "npm",
            [
                "publish",
                packResult.tarballPath,
                `--registry=${registry}`,
                `--tag=${context.tag ?? "latest"}`,
            ],
            { cwd: context.pkg.dir, silent: false },
        );

        if (publishResult.exitCode !== 0) {
            throw new Error(`Verdaccio publish for ${context.pkg.name} failed (exit ${publishResult.exitCode}): ${publishResult.stderr.slice(0, 200)}`);
        }

        return {
            output: publishResult.stdout,
            published: true,
        };
    }
}

// vis.config.ts
export default {
    release: {
        packages: {
            "@scope/internal-tools": {
                versionActions: "./.vis/release/verdaccio-actions.ts",
            },
            "@scope/internal-cli": {
                versionActions: "./.vis/release/verdaccio-actions.ts",
            },
        },
    },
};

import {
    defineChangelogFormatter,
    type ChangelogContext,
    type ChangelogFormatter,
    type ChangelogTarget,
} from "@visulima/vis/release/plugin-sdk";

type ChangelogTarget = "changelog" | "github-release";

interface ChangelogContext {
    /** All change files contributing to this release (may be empty for pure dep bumps). */
    changeFiles: ChangeFile[];
    /** ISO date string `YYYY-MM-DD`. */
    date: string;
    /** The release entry being rendered. */
    release: PlannedRelease;
    /** Where the rendered output is going. */
    target: ChangelogTarget;
}

type ChangelogFormatter = (context: ChangelogContext) => string | Promise<string>;

// vis.config.ts
export default {
    release: {
        // Built-in id — `"default"`, `"github"`, or `"keep-a-changelog"`:
        changelog: "github",
        // Or false — no-op formatter (writes nothing):
        // changelog: false,
        // Or string path to a custom module:
        // changelog: "./.vis/release/my-formatter.ts",
        // Or tuple — path + options for a factory:
        // changelog: ["./.vis/release/my-formatter.ts", { authorCredit: true }],
    },
};

import { defineChangelogFormatter } from "@visulima/vis/release/plugin-sdk";

export default defineChangelogFormatter((context) => {
    return `## ${context.release.newVersion}\n…`;
});

// .vis/release/emoji-keep-a-changelog.ts
import {
    defineChangelogFormatter,
    type ChangelogContext,
    type ChangelogFormatter,
} from "@visulima/vis/release/plugin-sdk";

export interface EmojiFormatterOptions {
    /** Owner/repo for the trailing comparison link. */
    repo?: string;
    /** Section-emoji overrides. Defaults below. */
    emoji?: Partial<Record<Section, string>>;
}

type Section = "Added" | "Changed" | "Deprecated" | "Removed" | "Fixed" | "Security";

const SECTIONS_IN_ORDER: ReadonlyArray<Section> = ["Added", "Changed", "Deprecated", "Removed", "Fixed", "Security"];

const DEFAULT_EMOJI: Record<Section, string> = {
    Added: "✨",
    Changed: "🔧",
    Deprecated: "⚠️",
    Removed: "🗑️",
    Fixed: "🐛",
    Security: "🔒",
};

const PREFIX_MAP: Record<string, Section> = {
    feat: "Added",
    feature: "Added",
    fix: "Fixed",
    bugfix: "Fixed",
    perf: "Changed",
    refactor: "Changed",
    chore: "Changed",
    deprecate: "Deprecated",
    deprecated: "Deprecated",
    remove: "Removed",
    removed: "Removed",
    security: "Security",
    sec: "Security",
};

const CONVENTIONAL_RE = /^([a-z]+)(?:\([^)]+\))?!?:\s+(.*)$/i;

const classify = (line: string, bumpLevel: "major" | "minor" | "patch"): { section: Section; text: string } => {
    const stripped = line.replace(/^[-*]\s+/, "").trim();
    const match = CONVENTIONAL_RE.exec(stripped);

    if (match) {
        const [, type, rest] = match;
        const section = PREFIX_MAP[type!.toLowerCase()];

        if (section) {
            return { section, text: rest! };
        }
    }

    // Fall back to bump level: major → Changed (likely breaking), minor → Added, patch → Fixed.
    const fallback: Section = bumpLevel === "major" ? "Changed" : bumpLevel === "minor" ? "Added" : "Fixed";

    return { section: fallback, text: stripped };
};

/**
 * Default export is a FACTORY. The config tuple `[path, options]` passes
 * the options through. Plain `path` (no tuple) invokes the factory with
 * no arguments — handled by the `?? {}` fallback below.
 */
export default (options: EmojiFormatterOptions = {}): ChangelogFormatter =>
    defineChangelogFormatter((context: ChangelogContext): string => {
        const { changeFiles, date, release, target } = context;
        const buckets: Record<Section, string[]> = {
            Added: [],
            Changed: [],
            Deprecated: [],
            Removed: [],
            Fixed: [],
            Security: [],
        };

        const bumpLevel = release.bumpLevel ?? "patch";

        for (const file of changeFiles) {
            for (const rawLine of file.body.split(/\r?\n/)) {
                const line = rawLine.trim();

                if (!line) {
                    continue;
                }

                const { section, text } = classify(line, bumpLevel as "major" | "minor" | "patch");

                buckets[section].push(`- ${text}`);
            }
        }

        const emoji = { ...DEFAULT_EMOJI, ...(options.emoji ?? {}) };
        const lines: string[] = [];

        // Version heading — only for the CHANGELOG.md target. The github-release
        // target omits it because the release UI already shows the version.
        if (target !== "github-release") {
            lines.push(`## [${release.newVersion}] - ${date}`);
            lines.push("");
        }

        for (const section of SECTIONS_IN_ORDER) {
            if (buckets[section].length === 0) {
                continue;
            }

            lines.push(`### ${emoji[section]} ${section}`);
            lines.push("");
            lines.push(...buckets[section]);
            lines.push("");
        }

        if (release.isCascadeBump || release.isGroupBump) {
            for (const source of release.sources) {
                const verb = release.isCascadeBump ? "Cascade from" : "Group bump with";

                lines.push(`- ${verb} \`${source.name}@${source.newVersion}\``);
            }
        } else if (release.isDependencyBump && changeFiles.length === 0) {
            for (const source of release.sources) {
                lines.push(`- Updated dependency \`${source.name}@${source.newVersion}\``);
            }
        }

        // Optional comparison link footer — Keep-a-Changelog convention.
        if (options.repo && target !== "github-release") {
            lines.push("");
            lines.push(`[${release.newVersion}]: https://github.com/${options.repo}/compare/v${release.oldVersion}...v${release.newVersion}`);
        }

        return lines.join("\n").replace(/\n{3,}/g, "\n\n").trim();
    });

// vis.config.ts
export default {
    release: {
        changelog: ["./.vis/release/emoji-keep-a-changelog.ts", {
            repo: "foo/bar",
            emoji: {
                Added: "🎁",  // override the default ✨
            },
        }],
    },
};