import { workflow } from "@novu/framework";

workflow(workflowId, handler, options);

preferences: {
  all: { enabled: true, readOnly: false },
  channels: {
    email: { enabled: true },
    sms: { enabled: false },
    push: { enabled: true },
    chat: { enabled: false },
    inApp: { enabled: true },
  },
}

await step.<channel>(stepId, resolver, options?);

await step.email("welcome", async (controls) => ({
  subject: "Welcome to Acme",
  body: "<p>Hello!</p>",
  attachments: [{ filename: "guide.pdf", content: pdfBuffer }],
  from: "[email protected]",
  replyTo: "[email protected]",
}));

await step.sms("verification", async () => ({
  body: `Your code is ${payload.code}`,
}));

await step.push("new-message", async () => ({
  title: "New Message",
  body: "You received a new message from John",
  data: { messageId: "123", senderId: "456" },
  image: "https://acme.com/notification.png",
  icon: "https://acme.com/icon.png",
}));

await step.chat("notify", async () => ({
  body: "A new post has been created",
}));

const { seen, read, lastSeenDate, lastReadDate } = await step.inApp("inbox", async () => ({
  subject: "Welcome to Acme!",
  body: "We are excited to have you on board.",
  avatar: "https://acme.com/avatar.png",
  redirect: { url: "/welcome", target: "_self" },
  primaryAction: {
    label: "Get Started",
    redirect: { url: "/get-started", target: "_self" },
  },
  secondaryAction: {
    label: "Learn More",
    redirect: { url: "/learn-more", target: "_self" },
  },
  data: { entityType: "user", entityId: payload.userId },
}));

await step.delay("wait", async () => ({
  unit: "days",
  amount: 1,
}));

const { events } = await step.digest("daily", async () => ({
  unit: "days",
  amount: 1,
  digestKey: payload.projectId, // optional — group by custom key
}));

const result = await step.custom("fetch", async () => {
  const r = await fetch("https://api.example.com/users/123");

  return await r.json();
}, {
  outputSchema: {
    type: "object",
    properties: {
      name: { type: "string" },
      email: { type: "string" },
    },
    required: ["name", "email"],
  } as const,
});

const plan = await step.http("fetch-plan", async () => ({
  method: "GET",
  url: `https://api.example.com/users/${payload.userId}/plan`,
  headers: [{ key: "Authorization", value: "Bearer xxxxx" }],
  responseBodySchema: {
    type: "object",
    properties: {
      planName: { type: "string" },
      renewalDate: { type: "string" },
    },
    required: ["planName", "renewalDate"],
  } as const,
}));

await step.email("notify", async () => ({
  subject: `Your ${plan.planName} plan`,
  body: `Your plan renews on ${plan.renewalDate}.`,
}));

await step.http("webhook", async () => ({
  method: "POST",
  url: payload.webhookUrl,
  headers: [{ key: "Content-Type", value: "application/json" }],
  body: [
    { key: "event", value: "payment_failed" },
    { key: "subscriberId", value: subscriber.subscriberId },
  ],
  continueOnFailure: true,
}));

await step.<channel>(stepId, resolver, {
  controlSchema,
  skip,
  providers,
  disableOutputSanitization,
});

await step.email("welcome", async (controls) => ({
  subject: controls.subject,
  body: render(<Email hideBanner={controls.hideBanner} />),
}), {
  controlSchema: z.object({
    hideBanner: z.boolean().default(false),
    subject: z.string().default("Hi {{subscriber.firstName | capitalize}}"),
  }),
});

await step.email("follow-up", resolver, {
  skip: () => inAppNotification.read === true,
});

// Or based on subscriber data
await step.email("upsell", resolver, {
  skip: () => subscriber.data?.tier === "enterprise",
});

await step.chat("notify", resolver, {
  providers: {
    slack: ({ controls, outputs }) => ({
      text: outputs.body,
      blocks: [
        {
          type: "section",
          text: { type: "mrkdwn", text: `*New post:* ${outputs.body}` },
        },
      ],
    }),
  },
});

await step.email("alert", resolver, {
  providers: {
    sendgrid: ({ controls, outputs }) => ({
      from: "[email protected]",
      cc: ["[email protected]"],
      _passthrough: {
        body: { ip_pool_name: "transactional" },
        headers: { "X-Custom": "value" },
        query: { foo: "bar" },
      },
    }),
  },
});

await step.inApp("link", async () => ({
  body: "Check it out",
  data: { link: "/p/123?active=true&env=prod" }, // & gets escaped by default
}), { disableOutputSanitization: true });

const inAppNotification = await step.inApp("inbox", async () => ({
  subject: "Task reminder!",
  body: "Task is not yet complete.",
}));

await step.delay("wait-6h", async () => ({ unit: "hours", amount: 6 }));

await step.email("email-fallback", async () => ({
  subject: "Task reminder!",
  body: "Task is not yet complete.",
}), {
  skip: () => inAppNotification.read === true,
});

await step.delay("wait", async () => ({ unit: "hours", amount: 24 }), {
  skip: async () => subscriber.data?.tier === "premium",
});

const task = await step.custom("fetch-task", async () => {
  const t = await db.fetchTask(payload.taskId);

  return { id: t.id, complete: t.complete, title: t.title };
}, {
  outputSchema: {
    type: "object",
    properties: {
      id: { type: "string" },
      complete: { type: "boolean" },
      title: { type: "string" },
    },
    required: ["id", "complete"],
  } as const,
});

await step.email("reminder", async () => ({
  subject: `Reminder: ${task.title}`,
  body: "Please complete your task.",
}), {
  skip: () => task.complete,
});

workflow("typed", async ({ step, payload }) => {
  // payload.userId is `string` (inferred from Zod schema below)
  await step.email("greet", async (controls) => ({
    // controls.subject is `string` (inferred from Zod schema below)
    subject: controls.subject,
    body: `Hi ${payload.firstName}`,
  }), {
    controlSchema: z.object({ subject: z.string().default("Hi") }),
  });
}, {
  payloadSchema: z.object({
    userId: z.string(),
    firstName: z.string(),
  }),
});