// Inngest handles long-running AI generation
inngest.createFunction(
  { id: "generate-lesson-plan" },
  { event: "lesson/generate.requested" },
  async ({ event, step }) => {
    const outline = await step.run("create-outline", () =>
      generateOutlineWithAI(event.data.topic)
    );
    
    const materials = await step.run("generate-materials", () =>
      generateMaterialsWithAI(outline)
    );
    
    await step.run("notify-teacher", () =>
      sendEmail({ to: event.data.teacherEmail, lessonPlan: materials })
    );
  }
);

// Type-safe API with Eden Treaty — same code works on web AND mobile
const { data } = await api.workouts.generate.post({
  fitnessLevel: "intermediate",
  equipment: ["dumbbells", "pull-up-bar"],
  duration: 45,
  focus: "upper-body"
});
// data is fully typed: { workout: Workout, estimatedCalories: number }

╔══════════════════════════════════════════════════════════════════╗
║  📱 CROSS-PLATFORM SYNC: Mobile Implementation Required          ║
╚══════════════════════════════════════════════════════════════════╝
 
Web route modified: src/routes/_authenticated/workouts.tsx
Route: /workouts
 
⚠️  ACTION REQUIRED: Update your todo list with these mobile tasks:
 
  1. Create/update `apps/mobile/src/screens/WorkoutsScreen.tsx`
  2. Wire up navigation to WorkoutsScreen
  3. Ensure API calls use same Eden Treaty client pattern
  4. Match form validation logic from web implementation

// Elysia cron for automated rent reminders
import { cron } from "@elysiajs/cron";
 
app.use(
  cron({
    name: "rent-reminder",
    pattern: "0 9 1 * *", // 9am on the 1st of each month
    async run() {
      const upcomingRent = await db.query.leases.findMany({
        where: (lease, { lte }) => lte(lease.nextDueDate, addDays(new Date(), 7))
      });
      await Promise.all(upcomingRent.map(lease => 
        inngest.send({ name: "rent/reminder", data: lease })
      ));
    }
  })
);

// Schema for construction-specific data
export const projects = pgTable("projects", {
  id: text("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
  name: text("name").notNull(),
  status: text("status", { enum: ["planning", "active", "on-hold", "completed"] }),
  startDate: timestamp("start_date"),
  estimatedCompletion: timestamp("estimated_completion"),
  actualCompletion: timestamp("actual_completion"),
  budget: integer("budget"),
  companyId: text("company_id").references(() => companies.id),
});
 
export const progressReports = pgTable("progress_reports", {
  id: text("id").primaryKey(),
  projectId: text("project_id").references(() => projects.id),
  reportDate: timestamp("report_date").defaultNow(),
  weatherConditions: text("weather_conditions"),
  workersOnSite: integer("workers_on_site"),
  notes: text("notes"),
  photos: jsonb("photos").$type<string[]>(),
  aiAnalysis: jsonb("ai_analysis").$type<AIProgressAnalysis>(),
});

// Inngest processes site photos with AI vision
inngest.createFunction(
  { id: "analyze-site-photos" },
  { event: "construction/photos.uploaded" },
  async ({ event, step }) => {
    const { photos, projectId, reportId } = event.data;
 
    // Analyze each photo for progress indicators
    const analyses = await step.run("analyze-photos", async () => {
      return Promise.all(photos.map(async (photoUrl) => {
        const response = await openai.chat.completions.create({
          model: "gpt-4o",
          messages: [{
            role: "user",
            content: [
              { type: "text", text: "Analyze this construction site photo. Identify: 1) Work completed, 2) Safety concerns, 3) Weather impact, 4) Estimated completion % for visible tasks." },
              { type: "image_url", image_url: { url: photoUrl } }
            ]
          }]
        });
        return response.choices[0].message.content;
      }));
    });
 
    // Generate structured report
    const report = await step.run("generate-report", () =>
      generateStructuredReport(analyses)
    );
 
    // Update database with AI analysis
    await step.run("save-analysis", () =>
      db.update(progressReports)
        .set({ aiAnalysis: report })
        .where(eq(progressReports.id, reportId))
    );
 
    // Alert project manager if safety issues detected
    if (report.safetyIssues.length > 0) {
      await step.run("alert-safety", () =>
        sendSafetyAlert(projectId, report.safetyIssues)
      );
    }
  }
);

// Inngest for scheduled data refresh
inngest.createFunction(
  { id: "refresh-dashboard-data" },
  { cron: "0 */6 * * *" }, // Every 6 hours
  async ({ step }) => {
    const dashboards = await step.run("get-active-dashboards", () =>
      db.query.dashboards.findMany({ where: eq(dashboards.autoRefresh, true) })
    );
 
    await Promise.all(
      dashboards.map(dashboard =>
        step.run(`refresh-${dashboard.id}`, () => refreshDashboardData(dashboard))
      )
    );
  }
);

// Better Auth with role-based access
export const auth = betterAuth({
  database: drizzleAdapter(db),
  plugins: [
    organization({
      roles: ["patient", "nurse", "doctor", "admin"],
      permissions: {
        patient: ["read:own-records", "book:appointments"],
        nurse: ["read:patient-records", "update:vitals"],
        doctor: ["read:patient-records", "write:prescriptions", "write:notes"],
        admin: ["manage:users", "manage:billing"],
      },
    }),
  ],
});

// Time tracking with type-safe schema
export const timeEntries = pgTable("time_entries", {
  id: text("id").primaryKey(),
  caseId: text("case_id").references(() => cases.id),
  attorneyId: text("attorney_id").references(() => users.id),
  description: text("description").notNull(),
  durationMinutes: integer("duration_minutes").notNull(),
  billableRate: integer("billable_rate"), // cents
  billable: boolean("billable").default(true),
  invoiceId: text("invoice_id").references(() => invoices.id),
  createdAt: timestamp("created_at").defaultNow(),
});
 
// Calculate billable amounts type-safely
const unbilledTime = await db
  .select({
    totalMinutes: sql<number>`sum(${timeEntries.durationMinutes})`,
    totalAmount: sql<number>`sum(${timeEntries.durationMinutes} * ${timeEntries.billableRate} / 60)`,
  })
  .from(timeEntries)
  .where(and(
    eq(timeEntries.caseId, caseId),
    isNull(timeEntries.invoiceId)
  ));

// Inngest orchestrates multi-step onboarding
inngest.createFunction(
  { id: "employee-onboarding" },
  { event: "employee/hired" },
  async ({ event, step }) => {
    const { employeeId, startDate } = event.data;
 
    await step.run("create-accounts", () => 
      createGoogleWorkspaceAccount(employeeId)
    );
    
    await step.run("assign-training", () =>
      assignRequiredTraining(employeeId)
    );
    
    await step.sleepUntil("wait-for-start", startDate);
    
    await step.run("send-welcome", () =>
      sendWelcomeEmail(employeeId)
    );
    
    await step.sleep("check-in-delay", "7 days");
    
    await step.run("first-week-checkin", () =>
      sendCheckInSurvey(employeeId)
    );
  }
);

// Webhook handling with durable processing
app.post("/webhooks/shopify", async ({ body }) => {
  // Immediately acknowledge webhook
  await inngest.send({
    name: "shopify/order.created",
    data: body,
  });
  return { received: true };
});
 
// Inngest handles the actual processing with retries
inngest.createFunction(
  { id: "sync-shopify-order", retries: 5 },
  { event: "shopify/order.created" },
  async ({ event, step }) => {
    const order = event.data;
    
    await step.run("update-inventory", () =>
      decrementInventory(order.line_items)
    );
    
    await step.run("sync-to-amazon", () =>
      syncInventoryToAmazon(order.line_items)
    );
  }
);

// Type-safe expense schema with audit trail
export const expenses = pgTable("expenses", {
  id: text("id").primaryKey(),
  userId: text("user_id").references(() => users.id),
  amount: integer("amount").notNull(), // cents
  currency: text("currency").default("USD"),
  category: text("category", { 
    enum: ["travel", "meals", "software", "equipment", "other"] 
  }),
  description: text("description"),
  receiptUrl: text("receipt_url"),
  ocrData: jsonb("ocr_data").$type<OCRResult>(),
  status: text("status", { 
    enum: ["draft", "submitted", "approved", "rejected", "reimbursed"] 
  }).default("draft"),
  submittedAt: timestamp("submitted_at"),
  approvedBy: text("approved_by").references(() => users.id),
  approvedAt: timestamp("approved_at"),
});