import type {RecordAction} from "attio/client"
import {runQuery, showToast, alert} from "attio/client"
import getPersonPhoneNumbersQuery from "./get-person-phone-numbers.graphql"
import sendToAlc from "./send-to-alc.server"

// This must be a named export called "recordAction"
export const recordAction: RecordAction = {
    id: "send-to-alc", // internal unique identifier
    label: "Send to ALC", // user-facing label
    onTrigger: async ({recordId}) => {
        const {hideToast} = await showToast({
            title: "Preparing to send to ALC...",
            variant: "neutral",
        })

        const {person} = await runQuery(getPersonPhoneNumbersQuery, {recordId})
        // `person` is strongly typed here as:
        // {
        //   name: {
        //     full_name: string | null
        //   } | null
        //   phone_numbers: string[]
        // } | null
        // ...so TypeScript will help us know the checks we need to perform.

        if (!person) {
            await hideToast()
            await alert({
                title: "Failed to load person data",
                text: "Please try again.",
            })
            return
        }

        const firstPhoneNumber = person.phone_numbers[0] ?? null
        if (!firstPhoneNumber) {
            await hideToast()
            await alert({
                title: "No phone number found",
                text: "Please add a phone number to the person and try again.",
            })
            return
        }

        try {
            await sendToAlc(recordId, person.name?.full_name ?? "Unknown", firstPhoneNumber)
        } catch {
            await hideToast()
            await alert({
                title: "Failed to send to ALC",
                text: "Please try again.",
            })
            return
        }

        await hideToast()
        await showToast({
            title: "Successfully sent to ALC!",
            variant: "success",
        })
    },
    objects: "person", // only show this action on person records
}

query getPersonPhoneNumbers($recordId: String!) {
    person(id: $recordId) {
        name {
            full_name
        }
        phone_numbers
    }
}

import {attioFetch, getWorkspaceConnection} from "attio/server"

export default async function sendToAlc(recordId: string, name: string, phoneNumber: string) {
    // Get the authorization token from the workspace connection
    // that the user has set up in their Attio account.
    const connection = getWorkspaceConnection()
    const authorizationToken = connection.value

    const response = await fetch("https://api.acmeleadchecker.ai/api/v1/leads", {
        method: "POST",
        headers: {
            "Content-Type": "application/json",
            "Authorization": `Bearer ${authorizationToken}`,
        },
        body: JSON.stringify({recordId, name, phoneNumber}),
    })

    if (!response.ok) {
        throw new Error("Failed to send to ALC")
    }

    const lead = await response.json()

    // Update the person record with the ALC ID
    await attioFetch({
        // call to Attio's REST API
    })

    return lead
}

import {attioFetch} from "attio/server"

export default async function leadProcessedWebhook(req: Request): Promise<Response> {
    const body = await req.json()

    const recordId = body.record_id
    const status = body.status

    await attioFetch({
        // call to Attio's REST API
    })

    return new Response(null, {status: 200})
}

import type {Connection} from "attio/server"
import {createWebhookHandler, updateWebhookHandler} from "attio/server"

export default async function connectionAdded({connection}: {connection: Connection}) {
    // The filename must match the file in src/webhooks, but without the suffix
    const handler = await createWebhookHandler({fileName: "lead-processed"})

    const authorizationToken = connection.value

    const response = await fetch("https://api.acmeleadchecker.ai/api/v1/webhooks", {
        method: "POST",
        headers: {
            "Content-Type": "application/json",
            "Authorization": `Bearer ${authorizationToken}`,
        },
        body: JSON.stringify({
            name: handler.id,
            url: handler.url,
            event: "lead.processed",
        }),
    })

    if (!response.ok) {
        throw new Error(`Failed to register webhook: ${response.statusText}`)
    }

    const webhook = await response.json()

    // Save the external webhook ID so we can delete it when the connection is removed
    await updateWebhookHandler(handler.id, {
        externalWebhookId: webhook.webhook_id,
    })
}

import type {Connection} from "attio/server"
import {deleteWebhookHandler, listWebhookHandlers} from "attio/server"

export default async function connectionRemoved({connection}: {connection: Connection}) {
    try {
        const handlers = await listWebhookHandlers()
        const authorizationToken = connection.value

        // Delete webhooks on ALC
        // There should be only one webhook handler active as we have single workspace connection
        await Promise.all(
            handlers.map(async (handler) => {
                const response = await fetch(
                    `https://api.acmeleadchecker.ai/api/v1/webhooks/${handler.externalWebhookId}`,
                    {
                        method: "DELETE",
                        headers: {
                            Authorization: `Bearer ${authorizationToken}`,
                        },
                    }
                )
                if (!response.ok) {
                    throw new Error(`Failed to delete webhook: ${response.statusText}`)
                }
            })
        )

        // Delete webhooks on Attio
        await Promise.all(
            handlers.map(async (handler) => {
                await deleteWebhookHandler(handler.id)
            })
        )
    } catch (error) {
        console.error(error)
        // don't rethrow the error so the connection is still removed
    }
}