#!/usr/bin/env node

import {
    Either,
    getRequiredEnvVars,
    LogTraceable,
    LogMetricTraceable,
    Metric,
    TraceUtil,
} from '@emprespresso/pengueno';
import { Infisical, type SecureNote } from '@emprespresso/ci_worker';
import { CoolifyWebhookJob } from '@emprespresso/ci_model';

const eitherJob = getRequiredEnvVars(['webhookUrl']).mapRight(
    (baseArgs) =>
        <CoolifyWebhookJob>{
            type: 'coolify_webhook.js',
            arguments: baseArgs,
        },
);

const eitherVault = Infisical.getConfigFromEnvironment().mapRight((config) => new Infisical(config));

const webhookMetric = Metric.fromName('coolify_webhook.trigger').asResult();
const _logJob = LogTraceable.of(eitherJob).flatMap(TraceUtil.withTrace('coolify_webhook'));
await LogMetricTraceable.ofLogTraceable(_logJob)
    .flatMap(TraceUtil.withMetricTrace(webhookMetric))
    .peek((tEitherJob) => tEitherJob.trace.trace('starting coolify webhook trigger! (⑅˘꒳˘)'))
    .map((tEitherJob) =>
        tEitherJob.get().flatMapAsync((job) =>
            eitherVault.flatMapAsync(async (vault) => {
                const eitherKey = await vault.unlock(tEitherJob);
                tEitherJob.trace.trace('unlocked vault :3');
                return eitherKey.mapRight((key) => ({ job, key, vault }));
            }),
        ),
    )
    .map(async (tEitherJobVault) =>
        (await tEitherJobVault.get()).flatMapAsync(({ job, key, vault }) =>
            vault
                .fetchSecret<SecureNote>(tEitherJobVault, key, 'coolify')
                .then((e) => e.mapRight(({ notes }) => ({ job, webhookSecret: notes })))
                .finally(() => vault.lock(tEitherJobVault, key)),
        ),
    )
    .map(async (tEitherJobAndSecret) => {
        const eitherJobAndSecret = await tEitherJobAndSecret.get();
        return eitherJobAndSecret.flatMapAsync(async ({ job, webhookSecret }) => {
            tEitherJobAndSecret.trace.trace(`triggering webhook at ${job.arguments.webhookUrl} (◕ᴗ◕✿)`);

            return Either.fromFailableAsync<Error, string>(() =>
                fetch(job.arguments.webhookUrl, {
                    method: 'POST',
                    headers: {
                        'Content-Type': 'application/json',
                        Authorization: `Bearer ${webhookSecret}`,
                    },
                    body: JSON.stringify({}),
                }).then(async (response) => {
                    if (!response.ok) {
                        throw new Error(
                            `webhook request failed with status ${response.status}: ${await response.text()}`,
                        );
                    }
                    return response.text();
                }),
            ).then((e) => {
                e.mapRight((responseText) =>
                    tEitherJobAndSecret.trace.trace(`webhook response: ${responseText}`),
                );
                return e;
            });
        });
    })
    .peek(TraceUtil.promiseify(TraceUtil.traceResultingEither(webhookMetric)))
    .map(async (tEitherJob) => {
        const eitherJob = await tEitherJob.get();
        return eitherJob.fold(
            (e) => Promise.reject(e),
            () => Promise.resolve(0),
        );
    })
    .get();