import { apiRequest } from './common.ts'
import type { Canvas, CanvasVersion } from './canvas.ts'

// ============================================================================
// Types
// ============================================================================

export type TemplateKind = 'canvas' | 'workflow'

export interface TemplateSlotColumn {
    key: string
    label: string
    placeholder?: string
}

/**
 * Where a list slot's rows are written into the structured output schema.
 *
 * `properties` turns each row into an output field; `enum` turns the rows into the allowed values
 * of one existing property.
 */
export type TemplateSlotSchemaTarget
    = | { mode: 'properties', nameFrom: string, descriptionFrom?: string }
        | { mode: 'enum', property: string, valueFrom: string }

export interface TextTemplateSlot {
    key: string
    type: 'text'
    label: string
    description?: string
    required?: boolean
    multiline?: boolean
    placeholder?: string
}

export interface ListTemplateSlot {
    key: string
    type: 'list'
    label: string
    description?: string
    required?: boolean
    columns: TemplateSlotColumn[]
    schemaTarget?: TemplateSlotSchemaTarget
}

export type TemplateSlot = TextTemplateSlot | ListTemplateSlot

/** A text slot takes a string; a list slot takes rows keyed by column. */
export type TemplateSlotValues = Record<string, string | Array<Record<string, string>>>

export interface Template {
    id: string
    name: string
    description: string | null
    type: TemplateKind
    /** Natural-language phrases describing what the template is for. Match against these. */
    useCases: string[]
    /** Coarse tags such as `legal`, `finance`, `operations`, `customer-support`. */
    industries: string[]
    /** Capability tags such as `pdf-treatment`. */
    utilities: string[]
    /** Visible to every workspace when true. */
    isGlobal: boolean
    slots: TemplateSlot[]
    schema: unknown
    graph: unknown
    variables: unknown
    configuration: unknown
    previewImage: string | null
    promptId: string
    promptVersionId: string
    workspaceId: string
    createdAt: string
    updatedAt: string
}

export interface ListTemplatesOptions {
    limit?: number
    offset?: number
}

export interface TemplateRecommendation {
    template: Template
    /** 0..1. Above ~0.3 is worth showing; below that, say nothing matched. */
    score: number
    /** Why it matched, in words you can show the user. */
    reason: string
}

// ============================================================================
// Discovery
// ============================================================================

/**
 * The template catalog visible to this workspace: its own templates plus every global one.
 */
export async function listTemplates(options?: ListTemplatesOptions): Promise<Template[]> {
    const params = new URLSearchParams()
    if (options?.limit !== undefined) params.set('limit', String(options.limit))
    if (options?.offset !== undefined) params.set('offset', String(options.offset))

    const query = params.toString()
    const { data } = await apiRequest<{ data: Template[] }>(`/templates${query ? `?${query}` : ''}`)

    return data
}

export async function getTemplate(templateId: string): Promise<Template> {
    return apiRequest<Template>(`/templates/${templateId}`)
}

const STOP_WORDS = new Set([
    'a', 'an', 'and', 'as', 'at', 'by', 'for', 'from', 'in', 'of', 'on', 'or', 'the', 'to', 'with',
    'que', 'de', 'da', 'do', 'das', 'dos', 'e', 'em', 'no', 'na', 'os', 'as', 'um', 'uma', 'para',
    'com', 'por', 'quero', 'preciso', 'fazer', 'criar', 'pra', 'sobre', 'meu', 'minha', 'seu',
    'sua', 'esse', 'essa', 'isso', 'tem', 'algum', 'alguma', 'gostaria', 'want', 'need', 'some',
])

function tokenize(text: string): string[] {
    return text
        .toLowerCase()
        .normalize('NFD')
        .replace(/[̀-ͯ]/g, '')
        .split(/[^a-z0-9]+/)
        .filter(word => word.length > 2 && !STOP_WORDS.has(word))
}

/**
 * Rank the catalog against a plain-language description of what the user wants to build.
 *
 * Matching is lexical over `name`, `description`, `useCases`, `industries` and `utilities` — it is a
 * shortlist, not a decision. Show the top match with what it does and let the user choose; never
 * instantiate one without saying which you picked and why.
 *
 * When the best score is low, say nothing matched rather than presenting a weak result as a fit. A
 * template the user did not choose is a prompt they cannot explain.
 */
export async function recommendTemplates(
    description: string,
    options?: { kind?: TemplateKind, limit?: number, templates?: Template[] },
): Promise<TemplateRecommendation[]> {
    const templates = options?.templates ?? await listTemplates({ limit: 200 })
    const wanted = new Set(tokenize(description))

    if (!wanted.size)
        return []

    // A hit inside a use-case phrase is real evidence; a hit on a tag like `pdf` is barely any.
    const WEIGHTS = { useCase: 1, name: 0.8, description: 0.5, tag: 0.25 } as const

    const scored = templates
        .filter(template => !options?.kind || template.type === options.kind)
        .map((template) => {
            const best = new Map<string, number>()
            let matchedUseCase: string | undefined

            const consider = (text: string, weight: number, useCase?: string) => {
                for (const word of tokenize(text)) {
                    if (!wanted.has(word))
                        continue
                    if ((best.get(word) ?? 0) < weight) {
                        best.set(word, weight)
                        if (useCase && !matchedUseCase)
                            matchedUseCase = useCase
                    }
                }
            }

            for (const useCase of template.useCases ?? [])
                consider(useCase, WEIGHTS.useCase, useCase)
            consider(template.name ?? '', WEIGHTS.name)
            consider(template.description ?? '', WEIGHTS.description)
            for (const tag of [...(template.industries ?? []), ...(template.utilities ?? [])])
                consider(tag, WEIGHTS.tag)

            const score = [...best.values()].reduce((total, weight) => total + weight, 0) / wanted.size

            return {
                template,
                score,
                reason: matchedUseCase ?? `matches: ${[...best.keys()].join(', ')}`,
            }
        })
        .filter(entry => entry.score > 0)
        .sort((a, b) => b.score - a.score)

    return scored.slice(0, options?.limit ?? 3)
}

/**
 * True when the top two candidates are close enough that picking one would be a guess.
 *
 * When this is true, show both and ask — do not instantiate.
 */
export function isAmbiguousRecommendation(
    recommendations: TemplateRecommendation[],
    margin = 0.1,
): boolean {
    if (recommendations.length < 2)
        return false

    return recommendations[0]!.score - recommendations[1]!.score < margin
}

// ============================================================================
// Instantiation
// ============================================================================

/**
 * Create a canvas or workflow from a template, filling its slots.
 *
 * The server interpolates `{{slot:key}}` placeholders into the prompt content, merges list slots
 * into the structured output schema where the slot declares a `schemaTarget`, and creates the
 * prompt and its first version in one call. Returns the new prompt with its version attached.
 *
 * The created version is a **draft and is not promoted** — promote it before pointing a Workstation
 * or a production run at it.
 *
 * Read the template's `slots` first — a required slot left empty produces a prompt with an
 * unfilled placeholder rather than an error.
 *
 * **The new prompt is named after the template and cannot be renamed.** The endpoint takes only
 * `projectId` and `slotValues`, and `updateCanvas({ title })` retitles the version rather than the
 * canvas. Tell the user what it will be called before creating it.
 */
export async function instantiateTemplate(
    templateId: string,
    payload: {
        projectId: string
        slotValues?: TemplateSlotValues
    },
): Promise<Canvas & { version?: CanvasVersion }> {
    return apiRequest(`/templates/${templateId}/instantiate`, {
        method: 'POST',
        body: JSON.stringify({
            projectId: payload.projectId,
            slotValues: payload.slotValues ?? {},
        }),
    })
}

/**
 * Describe what a template will ask for, so the user can answer before anything is created.
 */
export function describeTemplateSlots(template: Template): string {
    if (!template.slots?.length)
        return `${template.name} takes no inputs — it can be instantiated as is.`

    const lines = template.slots.map((slot) => {
        const required = slot.required ? 'required' : 'optional'
        const shape = slot.type === 'list'
            ? `list of rows (${slot.columns.map(column => column.key).join(', ')})`
            : slot.multiline ? 'multiline text' : 'text'

        return `- ${slot.key} (${required}, ${shape}): ${slot.label}${slot.description ? ` — ${slot.description}` : ''}`
    })

    return [`${template.name} asks for:`, ...lines].join('\n')
}

// ============================================================================
// Authoring
// ============================================================================

export interface CreateTemplatePayload {
    name: string
    /** Required by the API. */
    description: string
    /** The canvas or workflow this template is captured from. */
    promptId: string
    promptVersionId: string
    /**
     * Required, **at least one**, and the field that makes a template findable. Write the sentences
     * a user would say about their own problem, not a description of the mechanism.
     */
    useCases: string[]
    /** Required, **at least one**. Coarse tags such as `legal`, `finance`, `operations`. */
    industries: string[]
    /** Required by the API, but may be empty. Capability tags such as `pdf-treatment`. */
    utilities: string[]
    slots?: TemplateSlot[]
    /** Publish to every workspace. Defaults to false — a workspace-private template. */
    isGlobal?: boolean
    /**
     * Required by the API and then overwritten server-side with the caller's workspace. Defaults to
     * the source prompt's, so there is normally no reason to pass it.
     */
    workspaceId?: string
    /** Data URI, under ~700KB before base64 inflation. */
    previewImage?: string
}

/**
 * Publish an existing canvas or workflow version as a template.
 *
 * The template captures a snapshot of that version — later edits to the source do not propagate.
 * `type` is derived from whether the version is a workflow; you do not set it.
 *
 * Publishing a **workflow** rewrites its steps: `canvas` steps pointing at plain canvases are
 * inlined as `llm-completion` steps frozen at that canvas's production version, while steps
 * pointing at a workflow, and `template` nodes, stay as live pointers and force the template to be
 * workspace-private. See `templates.md`.
 *
 * Not idempotent — calling twice publishes two templates.
 *
 * `isGlobal` and `workspaceId` are required by the API; both are filled in for you — `isGlobal`
 * defaults to `false`, and the workspace is read from the source prompt.
 *
 * **There is no update endpoint.** Changing anything about a published template, including
 * `isGlobal`, means deleting it and creating a new one pointing at the same version. Only the
 * preview image can be changed in place.
 */
export async function createTemplate(payload: CreateTemplatePayload): Promise<Template> {
    const workspaceId = payload.workspaceId
        ?? (await apiRequest<{ workspaceId: string }>(`/prompt/${payload.promptId}`)).workspaceId

    return apiRequest<Template>('/templates', {
        method: 'POST',
        body: JSON.stringify({
            ...payload,
            workspaceId,
            isGlobal: payload.isGlobal ?? false,
        }),
    })
}

/**
 * Delete a template. A missing template answers **400**, not 404, so a failure does not distinguish
 * a wrong id from a bad call.
 */
export async function deleteTemplate(templateId: string): Promise<void> {
    await apiRequest(`/templates/${templateId}`, { method: 'DELETE' })
}

/**
 * Replace a template's preview card image. Accepts a data URI; the server stores it publicly.
 */
export async function updateTemplatePreviewImage(
    templateId: string,
    previewImage: string,
): Promise<Template> {
    return apiRequest<Template>(`/templates/${templateId}/preview-image`, {
        method: 'PATCH',
        body: JSON.stringify({ previewImage }),
    })
}