// Schedule definition
type AutomationSchedule =
  | { kind: "at"; atMs: number }                                              // One-shot
  | { kind: "interval"; everyMs: number; jitterMs?: number }                  // Fixed interval
  | { kind: "cron"; expression: string; timezone?: string; staggerMs?: number } // Cron expression

// Execution mode
type AutomationExecution =
  | { kind: "isolated"; agentType: string; retentionMs?: number }
  | { kind: "session"; sessionId: string }

// Delivery configuration
type AutomationDelivery =
  | { kind: "inbox"; autoArchiveOnOk?: boolean; okMaxChars?: number }
  | { kind: "session"; sessionId: string }
  | { kind: "both"; sessionId: string; autoArchiveOnOk?: boolean; okMaxChars?: number }
  | { kind: "none" }

// Security profile for the run sandbox
type AutomationSecurityProfile = "restricted" | "networked" | "custom"

// Full automation definition (wire format)
interface AutomationDef {
  name: string
  description?: string
  schedule: AutomationSchedule
  execution: AutomationExecution
  prompt: string
  delivery: AutomationDelivery
  security?: {
    profile: AutomationSecurityProfile
    allowedDomains?: string[]          // Only for "networked" profile
    allowShell?: boolean               // Default: true
    maxEgressBytes?: number
  }
  timeoutMs?: number
  maxCostMicroDollars?: number
}

// Automation (server-managed, includes computed fields)
interface Automation extends AutomationDef {
  id: string
  enabled: boolean
  createdBy: { userId: string; email?: string }
  createdAtMs: number
  updatedAtMs: number
  lastRunAtMs?: number
  nextRunAtMs?: number
  consecutiveFailures: number
}

// Automation run
type RunStatus = "queued" | "running" | "waiting" | "success" | "error" | "skipped" | "canceled"
type InboxState = "unread" | "read" | "archived"

interface AutomationRun {
  id: string
  automationId: string
  status: RunStatus
  inboxState: InboxState
  pinned: boolean
  scheduledForMs: number
  startedAtMs?: number
  finishedAtMs?: number
  attempt: number
  summary?: string
  outputMarkdown?: string
  error?: { code: string; message: string }
  sessionId?: string
  turnId?: string
  triggerKind: "schedule" | "manual" | "catchup" | "wake"
}

// Heartbeat configuration
interface HeartbeatConfig {
  enabled: boolean
  intervalMs: number
  prompt?: string
  activeHours?: {
    start: string  // "HH:MM"
    end: string    // "HH:MM"
    timezone?: string
  }
  autoArchiveOnOk: boolean
  okMaxChars: number
}

CREATE TABLE IF NOT EXISTS automations (
  id TEXT PRIMARY KEY,
  name TEXT NOT NULL,
  description TEXT,
  enabled INTEGER NOT NULL DEFAULT 1 CHECK (enabled IN (0, 1)),

  -- Serialized JSON for flexible schedule/execution/delivery schemas
  schedule_json TEXT NOT NULL,
  execution_json TEXT NOT NULL,
  delivery_json TEXT NOT NULL,
  prompt TEXT NOT NULL,

  -- Security profile (JSON: profile, allowedDomains, allowShell, maxEgressBytes)
  security_json TEXT NOT NULL DEFAULT '{"profile":"restricted"}',

  -- Denormalized for efficient queries
  schedule_kind TEXT NOT NULL CHECK (schedule_kind IN ('at', 'interval', 'cron')),
  automation_kind TEXT NOT NULL DEFAULT 'cron' CHECK (automation_kind IN ('cron', 'heartbeat')),
  target_session_id TEXT,
  agent_type TEXT,

  -- Scheduling state
  next_run_at_ms INTEGER,
  last_run_at_ms INTEGER,
  last_run_status TEXT,
  consecutive_failures INTEGER NOT NULL DEFAULT 0,
  backoff_until_ms INTEGER,

  -- Budget controls
  timeout_ms INTEGER,
  max_cost_micro_dollars INTEGER,

  -- Audit
  created_by_user_id TEXT NOT NULL,
  created_by_email TEXT,
  created_at_ms INTEGER NOT NULL,
  updated_at_ms INTEGER NOT NULL,
  version INTEGER NOT NULL DEFAULT 0
);

-- Index for the scheduler: find due automations efficiently
CREATE INDEX IF NOT EXISTS idx_automations_due
  ON automations(next_run_at_ms)
  WHERE enabled = 1 AND next_run_at_ms IS NOT NULL;

-- Index for session-scoped lookups (heartbeat config, session automations)
CREATE INDEX IF NOT EXISTS idx_automations_session
  ON automations(target_session_id);

-- Enforce at most one active heartbeat per session
CREATE UNIQUE INDEX IF NOT EXISTS idx_heartbeat_unique_session
  ON automations(target_session_id)
  WHERE automation_kind = 'heartbeat' AND enabled = 1;

CREATE TABLE IF NOT EXISTS automation_runs (
  id TEXT PRIMARY KEY,
  automation_id TEXT NOT NULL REFERENCES automations(id) ON DELETE CASCADE,

  trigger_kind TEXT NOT NULL CHECK (trigger_kind IN ('schedule', 'manual', 'catchup', 'wake')),
  status TEXT NOT NULL CHECK (status IN ('queued', 'running', 'waiting', 'success', 'error', 'skipped', 'canceled')),
  attempt INTEGER NOT NULL DEFAULT 1,

  -- Inbox state
  inbox_state TEXT NOT NULL DEFAULT 'archived' CHECK (inbox_state IN ('unread', 'read', 'archived')),
  pinned INTEGER NOT NULL DEFAULT 0 CHECK (pinned IN (0, 1)),

  -- Timing
  scheduled_for_ms INTEGER NOT NULL,
  created_at_ms INTEGER NOT NULL,
  started_at_ms INTEGER,
  finished_at_ms INTEGER,

  -- Output
  summary TEXT,
  output_markdown TEXT,

  -- Error tracking
  error_code TEXT,
  error_message TEXT,

  -- Session correlation
  run_session_id TEXT,
  run_turn_id TEXT,

  -- Metadata (usage, questions, permissions -- serialized JSON)
  metadata_json TEXT,

  UNIQUE (automation_id, scheduled_for_ms, trigger_kind)
);

-- Index for listing runs by automation
CREATE INDEX IF NOT EXISTS idx_runs_by_automation
  ON automation_runs(automation_id, scheduled_for_ms DESC);

-- Index for the triage inbox
CREATE INDEX IF NOT EXISTS idx_runs_inbox
  ON automation_runs(inbox_state, created_at_ms DESC)
  WHERE inbox_state != 'archived';

AppConfigLive
  |
  |---> AutomationStoreLive      (reads/writes automation + run tables)
  |       |
  |---> SessionRuntimeLive       (extracted: start turns without WebSocket client)
  |       |
  └---> AutomationEngineLive     (scheduler fiber, executor, heartbeat runner)
          |
          |-- depends on: AutomationStore
          |-- depends on: SessionRuntime
          |-- depends on: Broadcaster
          └-- depends on: AppConfig

export class AutomationStore extends Context.Tag("AutomationStore")<
  AutomationStore,
  {
    // Automation CRUD
    readonly list: (tenantId: string, includeDisabled?: boolean)
      => Effect.Effect<ReadonlyArray<Automation>, DbError>
    readonly get: (tenantId: string, id: string)
      => Effect.Effect<Automation, DbError | NotFound>
    readonly create: (tenantId: string, def: AutomationDef, createdBy: AuthIdentity)
      => Effect.Effect<Automation, DbError | ValidationError>
    readonly update: (tenantId: string, id: string, patch: Partial<AutomationDef>)
      => Effect.Effect<Automation, DbError | NotFound | ValidationError>
    readonly remove: (tenantId: string, id: string)
      => Effect.Effect<void, DbError | NotFound>
    readonly setEnabled: (tenantId: string, id: string, enabled: boolean)
      => Effect.Effect<Automation, DbError | NotFound>

    // Scheduler queries
    readonly nextDue: (tenantId: string, nowMs: number, limit: number)
      => Effect.Effect<ReadonlyArray<Automation>, DbError>
    readonly claimRun: (tenantId: string, automationId: string, nowMs: number)
      => Effect.Effect<AutomationRun, DbError>
    readonly completeRun: (tenantId: string, runId: string, outcome: RunOutcome)
      => Effect.Effect<void, DbError>
    readonly advanceSchedule: (tenantId: string, automationId: string, nowMs: number)
      => Effect.Effect<void, DbError>

    // Run queries
    readonly listRuns: (tenantId: string, automationId: string, limit: number, cursor?: string)
      => Effect.Effect<ReadonlyArray<AutomationRun>, DbError>

    // Inbox queries
    readonly listInbox: (tenantId: string, filter: InboxFilter, limit: number, cursor?: string)
      => Effect.Effect<ReadonlyArray<AutomationRun>, DbError>
    readonly updateInboxItem: (tenantId: string, runId: string, patch: InboxPatch)
      => Effect.Effect<void, DbError | NotFound>
  }
>() {}

export class SessionRuntime extends Context.Tag("SessionRuntime")<
  SessionRuntime,
  {
    readonly startTurn: (params: {
      sessionId: string
      tenantId: string
      agentType: string
      text: string
      metadata?: Record<string, unknown>
    }) => Effect.Effect<TurnHandle, SessionError | PodiumConnectionError>

    readonly ensureActive: (params: {
      sessionId: string
      tenantId: string
      agentType: string
    }) => Effect.Effect<void, SessionError | PodiumConnectionError>
  }
>() {}

// A turn handle provides a Deferred that resolves on completion
interface TurnHandle {
  readonly turnId: string
  readonly sessionId: string
  readonly completion: Deferred.Deferred<TurnOutcome, never>
}

type TurnOutcome =
  | { kind: "complete"; finalText: string; usage?: UsageRecord }
  | { kind: "error"; code: string; message: string }
  | { kind: "stopped" }

export class AutomationEngine extends Context.Tag("AutomationEngine")<
  AutomationEngine,
  {
    readonly reschedule: (tenantId: string) => Effect.Effect<void>
    readonly runNow: (tenantId: string, automationId: string)
      => Effect.Effect<AutomationRun, EngineError>
    readonly wakeHeartbeat: (tenantId: string, sessionId: string, reason: string)
      => Effect.Effect<void, NotFound>
  }
>() {}

+-- Per-Tenant Scheduler Fiber --------------------------------+
|                                                               |
|  loop:                                                        |
|    1. Query: nextDue(tenantId, now, batchSize)                |
|    2. Compute sleepDuration = min(nextRunAtMs) - now          |
|    3. Race:                                                   |
|       a) Effect.sleep(sleepDuration)                          |
|       b) Queue.take(rescheduleQueue)   <-- wake signal        |
|    4. If woken by (a): claim + execute due automations        |
|       If woken by (b): re-query (schedule changed)            |
|    5. After execution: advanceSchedule, loop                  |
|                                                               |
+---------------------------------------------------------------+

import { Cron } from "effect"

// Validate a cron expression at automation creation time
const validated = Cron.parse("0 9 * * 1-5")  // Either<ParseError, Cron>

// Compute next run time
const nextRun = Cron.next(cron, { after: new Date() })

// Optional deterministic stagger to spread load
const stagger = hash(automationId) % (staggerMs ?? 0)
const nextRunMs = nextRun.getTime() + stagger

// Heartbeat config maps to AutomationDef with constraints:
{
  schedule: { kind: "interval", everyMs: 1_800_000 },  // 30 minutes default
  execution: { kind: "session", sessionId: targetSessionId },
  delivery: { kind: "inbox", autoArchiveOnOk: true, okMaxChars: 300 },
  prompt: "Check if anything needs attention. If not, reply with OK.",
  activeHours: { start: "09:00", end: "22:00", timezone: "America/New_York" }
}

const runRetry = Schedule.exponential("500 millis").pipe(
  Schedule.jittered,
  Schedule.compose(Schedule.recurs(3))
)