wizard-utils.ts

import type { DataAnswerSource, DataQuestionSource, FileOutputConfig, WizardAnswer, WizardStep } from "@/types/wizard"

const buildFileSlug = (filename?: string, fallback?: string) => {
    const base = filename ?? fallback ?? ""
    const trimmed = base.trim()

    if (!trimmed) {
        return (fallback ?? "file").toLowerCase()
    }

    const withoutLeadingDot = trimmed.replace(/^\./, "")
    const noExtension = withoutLeadingDot.replace(/\.[^./]+$/, "")
    const normalizedSeparators = noExtension.replace(/[\\/]+/g, "-")
    const collapsed = normalizedSeparators.replace(/[^a-zA-Z0-9]+/g, "-")
    const hyphenReduced = collapsed.replace(/-+/g, "-")
    const trimmedHyphen = hyphenReduced.replace(/^-|-$/g, "")

    const slug = trimmedHyphen.toLowerCase()
    if (slug.length === 0) {
        return (fallback ?? "file").toLowerCase()
    }

    return slug
}

/**
 * Maps a data answer source to a wizard answer format
 */
export const mapAnswerSourceToWizard = (answer: DataAnswerSource): WizardAnswer => {
    const infoLines: string[] = []

    if (answer.pros && answer.pros.length > 0) {
        infoLines.push(`Pros: ${answer.pros.join(", ")}`)
    }

    if (answer.cons && answer.cons.length > 0) {
        infoLines.push(`Cons: ${answer.cons.join(", ")}`)
    }

    const isDisabled = answer.disabled ?? (answer.enabled === false)
    const disabledLabel = answer.disabledLabel ?? (answer.enabled === false ? "Soon" : undefined)

    return {
        value: answer.value,
        label: answer.label,
        icon: answer.icon,
        example: answer.example,
        infoLines: infoLines.length > 0 ? infoLines : undefined,
        docs: answer.docs,
        tags: answer.tags,
        isDefault: answer.isDefault,
        disabled: isDisabled,
        disabledLabel,
        filename: answer.filename,
        format: answer.format,
        enabled: answer.enabled,
    }
}

/**
 * Builds a wizard step from a question set
 */
export const buildStepFromQuestionSet = (
    id: string,
    title: string,
    questions: DataQuestionSource[]
): WizardStep => ({
    id,
    title,
    questions: questions.map((question) => ({
        id: question.id,
        question: question.question,
        allowMultiple: question.allowMultiple,
        responseKey: question.responseKey,
        isReadOnlyOnSummary: question.isReadOnlyOnSummary,
        enableFilter: question.enableFilter,
        answers: question.answers.map(mapAnswerSourceToWizard),
        freeText: question.freeText,
    })),
})

export const buildFileOptionsFromQuestion = (
    question?: DataQuestionSource | null
): FileOutputConfig[] => {
    if (!question) {
        return []
    }

    return question.answers
        .filter((answer) => answer.enabled !== false)
        .map((answer) => ({
            id: answer.value,
            label: answer.label,
            filename: answer.filename ?? answer.label,
            format: answer.format ?? "markdown",
            slug: buildFileSlug(answer.filename, answer.value ?? answer.label),
            enabled: answer.enabled,
            icon: answer.icon,
            docs: answer.docs,
            isDefault: answer.isDefault,
            isLegacy: answer.isLegacy,
        }))
}

const formatLabelMap: Record<string, string> = {
    markdown: "Markdown",
    json: "JSON",
    "cursor-rules-json": "JSON",
    zip: "ZIP Archive",
}

const formatMimeTypeMap: Record<string, string> = {
    markdown: "text/markdown",
    json: "application/json",
    "cursor-rules-json": "application/json",
    zip: "application/zip",
}

/**
 * Converts a stored format identifier into a human-friendly label
 */
export const getFormatLabel = (format?: string) => {
    if (!format) {
        return null
    }

    return formatLabelMap[format] ?? format
}

/**
 * Returns the browser mime-type associated with a stored format identifier
 */
export const getMimeTypeForFormat = (format?: string) => {
    if (!format) {
        return "text/plain"
    }

    return formatMimeTypeMap[format] ?? "text/plain"
}