import { describe, it, expect } from 'vitest';
import {
  PLAN_LIMITS,
  ADDON_PRICING,
  resolvePlanKey,
  getPortalSeatLimit,
  getStorageQuotaBytes,
  GB,
} from './plan-limits';

describe('plan-limits', () => {
  it('GB constant equals 1024^3 bytes', () => {
    expect(GB).toBe(1024 * 1024 * 1024);
  });

  it('Pro plan: 100 portal seats, 100 GB storage', () => {
    expect(PLAN_LIMITS.pro.portalSeats).toBe(100);
    expect(PLAN_LIMITS.pro.storageBytes).toBe(100 * GB);
  });

  it('Pro+ plan: 250 portal seats, 250 GB storage', () => {
    expect(PLAN_LIMITS.proPlus.portalSeats).toBe(250);
    expect(PLAN_LIMITS.proPlus.storageBytes).toBe(250 * GB);
  });

  it('Enterprise plan: null caps (custom)', () => {
    expect(PLAN_LIMITS.enterprise.portalSeats).toBeNull();
    expect(PLAN_LIMITS.enterprise.storageBytes).toBeNull();
  });

  it('addon pricing: four storage tiers at fixed monthly prices', () => {
    expect(ADDON_PRICING.storageTiers[50]).toBe(1499);
    expect(ADDON_PRICING.storageTiers[200]).toBe(4999);
    expect(ADDON_PRICING.storageTiers[500]).toBe(9999);
    expect(ADDON_PRICING.storageTiers[1000]).toBe(14999);
  });

  it('addon pricing: portal 3-pack is PKR 999 Pro, PKR 699 Pro+', () => {
    expect(ADDON_PRICING.portalSeats3PackPkr.pro).toBe(999);
    expect(ADDON_PRICING.portalSeats3PackPkr.proPlus).toBe(699);
  });

  it('resolvePlanKey normalizes plan name/tier variants', () => {
    expect(resolvePlanKey({ planName: 'Pro', planTier: null })).toBe('pro');
    expect(resolvePlanKey({ planName: 'pro+', planTier: null })).toBe('proPlus');
    expect(resolvePlanKey({ planName: 'Pro Plus', planTier: null })).toBe('proPlus');
    expect(resolvePlanKey({ planName: null, planTier: 'pro_plus' })).toBe('proPlus');
    expect(resolvePlanKey({ planName: null, planTier: 'enterprise' })).toBe('enterprise');
    expect(resolvePlanKey({ planName: 'unknown', planTier: null })).toBe('pro');
  });

  it('getPortalSeatLimit handles base + addon, returns null for enterprise', () => {
    expect(getPortalSeatLimit('pro', 6)).toBe(106);
    expect(getPortalSeatLimit('proPlus', 0)).toBe(250);
    expect(getPortalSeatLimit('enterprise', 50)).toBeNull();
  });

  it('getStorageQuotaBytes handles base + addon, returns null for enterprise', () => {
    expect(getStorageQuotaBytes('pro', 5 * GB)).toBe(105 * GB);
    expect(getStorageQuotaBytes('enterprise', 0)).toBeNull();
  });
});

export const GB = 1024 * 1024 * 1024;

export type PlanKey = 'pro' | 'proPlus' | 'enterprise';

export const PLAN_LIMITS = {
  pro: {
    portalSeats: 100,
    storageBytes: 100 * GB,
    doctors: 3,
    receptionists: 1,
    admins: 1,
  },
  proPlus: {
    portalSeats: 250,
    storageBytes: 250 * GB,
    doctors: 6,
    receptionists: 2,
    admins: 2,
  },
  enterprise: {
    portalSeats: null as number | null,
    storageBytes: null as number | null,
    doctors: 999,
    receptionists: 999,
    admins: 999,
  },
} as const;

export type StorageTierGb = 50 | 200 | 500 | 1000;

export const ADDON_PRICING = {
  storageTiers: {
    50: 1499,
    200: 4999,
    500: 9999,
    1000: 14999,
  } as Record<StorageTierGb, number>,
  portalSeats3PackPkr: {
    pro: 999,
    proPlus: 699,
  },
} as const;

export const STORAGE_TIER_LABELS: Record<StorageTierGb, string> = {
  50: '50 GB',
  200: '200 GB',
  500: '500 GB',
  1000: '1 TB',
};

export const STORAGE_TIER_DESCRIPTIONS: Record<StorageTierGb, string> = {
  50: 'Secure business storage inside your app — customer files, uploads, access control, backups, sharing, support, no technical setup.',
  200: 'Growing imaging library, mid-size clinic. Everything in 50 GB tier plus headroom for daily X-rays and treatment photos.',
  500: 'Multi-doctor clinic with heavy DICOM. Full audit trail, automatic backups, instant sharing — no IT involvement needed.',
  1000: 'Multi-branch or archive-heavy workloads. Enterprise-grade redundancy, fastest restore tier, priority support.',
};

const norm = (v?: string | null) => (v || '').trim().toLowerCase();

export function resolvePlanKey(input: { planName?: string | null; planTier?: string | null }): PlanKey {
  const name = norm(input.planName);
  const tier = norm(input.planTier);
  if (name.includes('enterprise') || tier.includes('enterprise')) return 'enterprise';
  if (
    name === 'pro+' ||
    name === 'pro plus' ||
    name === 'proplus' ||
    name.startsWith('pro+ ') ||
    tier === 'pro_plus' ||
    tier === 'pro-plus' ||
    tier === 'proplus' ||
    tier.startsWith('pro_plus')
  ) return 'proPlus';
  if (name.startsWith('pro') || tier.startsWith('pro')) return 'pro';
  return 'pro'; // safe default
}

export function getPortalSeatLimit(plan: PlanKey, addon: number): number | null {
  const base = PLAN_LIMITS[plan].portalSeats;
  if (base === null) return null;
  return base + Math.max(0, addon);
}

export function getStorageQuotaBytes(plan: PlanKey, addonBytes: number): number | null {
  const base = PLAN_LIMITS[plan].storageBytes;
  if (base === null) return null;
  return base + Math.max(0, addonBytes);
}

git add server/src/lib/plan-limits.ts server/src/lib/plan-limits.test.ts
git commit -m "feat(billing): centralized plan limits + addon pricing config"

-- Phase 1: Portal seat caps + storage caps + addon ledger
-- Spec: docs/superpowers/specs/2026-05-13-portal-seats-storage-addons.md

-- ============================================================
-- 1) Extend clinics with quota + usage counters
-- ============================================================
ALTER TABLE app.clinics
  ADD COLUMN IF NOT EXISTS portal_seat_limit INTEGER,
  ADD COLUMN IF NOT EXISTS portal_seat_addon INTEGER NOT NULL DEFAULT 0,
  ADD COLUMN IF NOT EXISTS storage_quota_bytes BIGINT,
  ADD COLUMN IF NOT EXISTS storage_addon_bytes BIGINT NOT NULL DEFAULT 0,
  ADD COLUMN IF NOT EXISTS storage_used_bytes BIGINT NOT NULL DEFAULT 0;

-- Sanity guards: addon and usage cannot be negative
ALTER TABLE app.clinics
  ADD CONSTRAINT clinics_portal_seat_addon_nonneg CHECK (portal_seat_addon >= 0),
  ADD CONSTRAINT clinics_storage_addon_bytes_nonneg CHECK (storage_addon_bytes >= 0),
  ADD CONSTRAINT clinics_storage_used_bytes_nonneg CHECK (storage_used_bytes >= 0);

-- ============================================================
-- 2) patients.portal_access flag (backfilled below)
-- ============================================================
ALTER TABLE app.patients
  ADD COLUMN IF NOT EXISTS portal_access BOOLEAN NOT NULL DEFAULT false;

-- Backfill: existing patients with user_id (and not soft-deleted) are portal users
UPDATE app.patients
   SET portal_access = true
 WHERE user_id IS NOT NULL
   AND deleted_at IS NULL;

-- Enforce 1:1 between portal patients and user accounts
CREATE UNIQUE INDEX IF NOT EXISTS patients_user_id_unique
  ON app.patients(user_id)
  WHERE user_id IS NOT NULL;

-- Fast seat-count query (used on every toggle/check)
CREATE INDEX IF NOT EXISTS patients_clinic_portal_active_idx
  ON app.patients(clinic_id, portal_access)
  WHERE deleted_at IS NULL;

-- ============================================================
-- 3) addon_requests ledger
-- ============================================================
DO $$ BEGIN
  CREATE TYPE app.addon_type AS ENUM ('storage', 'portal_seats');
EXCEPTION WHEN duplicate_object THEN NULL; END $$;

DO $$ BEGIN
  CREATE TYPE app.addon_request_status AS ENUM ('pending', 'approved', 'rejected', 'cancelled');
EXCEPTION WHEN duplicate_object THEN NULL; END $$;

CREATE TABLE IF NOT EXISTS app.addon_requests (
  id              TEXT PRIMARY KEY,
  clinic_id       TEXT NOT NULL REFERENCES app.clinics(id) ON DELETE CASCADE,
  requested_by    TEXT NOT NULL,
  addon_type      app.addon_type NOT NULL,
  quantity        INTEGER NOT NULL CHECK (quantity > 0),
  unit_price_pkr  INTEGER NOT NULL CHECK (unit_price_pkr >= 0),
  total_price_pkr INTEGER NOT NULL CHECK (total_price_pkr >= 0),
  status          app.addon_request_status NOT NULL DEFAULT 'pending',
  approved_by     TEXT,
  approved_at     TIMESTAMP,
  cancelled_at    TIMESTAMP,
  cancelled_by    TEXT,
  rejected_reason TEXT,
  notes           TEXT,
  created_at      TIMESTAMP NOT NULL DEFAULT NOW(),
  updated_at      TIMESTAMP NOT NULL DEFAULT NOW()
);

CREATE INDEX IF NOT EXISTS addon_requests_clinic_status_idx
  ON app.addon_requests(clinic_id, status);

CREATE INDEX IF NOT EXISTS addon_requests_status_created_idx
  ON app.addon_requests(status, created_at DESC);

-- Active-addons partial index for fast quota arithmetic & superadmin views
CREATE INDEX IF NOT EXISTS addon_requests_active_idx
  ON app.addon_requests(clinic_id, addon_type)
  WHERE status = 'approved' AND cancelled_at IS NULL;

cd server && npm run db:migrate

cd server && npx tsx -e "
import { getReadDb } from './src/lib/db';
const db = getReadDb({} as any);
const r = await db.execute(\`SELECT column_name FROM information_schema.columns WHERE table_schema='app' AND table_name='clinics' AND column_name LIKE '%portal%' OR column_name LIKE '%storage%';\`);
console.log(r);
"

git add server/drizzle/0033_portal_seats_storage_addons.sql
git commit -m "feat(db): migration 0033 — portal seat caps, storage caps, addon ledger"

-- ============================================================
-- 4) Addon pricing config (superadmin-editable, single-row)
-- ============================================================
CREATE TABLE IF NOT EXISTS app.addon_pricing (
  id                              TEXT PRIMARY KEY,
  storage_50gb_pkr                INTEGER NOT NULL CHECK (storage_50gb_pkr >= 0),
  storage_200gb_pkr               INTEGER NOT NULL CHECK (storage_200gb_pkr >= 0),
  storage_500gb_pkr               INTEGER NOT NULL CHECK (storage_500gb_pkr >= 0),
  storage_1tb_pkr                 INTEGER NOT NULL CHECK (storage_1tb_pkr >= 0),
  portal_seats_3pack_pro_pkr      INTEGER NOT NULL CHECK (portal_seats_3pack_pro_pkr >= 0),
  portal_seats_3pack_pro_plus_pkr INTEGER NOT NULL CHECK (portal_seats_3pack_pro_plus_pkr >= 0),
  updated_at                      TIMESTAMP NOT NULL DEFAULT NOW(),
  updated_by                      TEXT
);

-- Seed with launch defaults (idempotent)
INSERT INTO app.addon_pricing (id, storage_50gb_pkr, storage_200gb_pkr, storage_500gb_pkr, storage_1tb_pkr, portal_seats_3pack_pro_pkr, portal_seats_3pack_pro_plus_pkr)
VALUES ('current', 1499, 4999, 9999, 14999, 999, 699)
ON CONFLICT (id) DO NOTHING;

-- Audit table for pricing history
CREATE TABLE IF NOT EXISTS app.addon_pricing_history (
  id              TEXT PRIMARY KEY,
  changed_at      TIMESTAMP NOT NULL DEFAULT NOW(),
  changed_by      TEXT,
  before_values   JSONB NOT NULL,
  after_values    JSONB NOT NULL
);

CREATE INDEX IF NOT EXISTS addon_pricing_history_changed_at_idx
  ON app.addon_pricing_history(changed_at DESC);

cd server && npm run db:migrate

git add server/drizzle/0033_portal_seats_storage_addons.sql
git commit --amend --no-edit

import { pgTable, text, timestamp, varchar, pgEnum, boolean, jsonb, numeric, integer, bigint } from 'drizzle-orm/pg-core';

  // Portal-seat and storage quotas (set on plan activation; null → derive from plan)
  portalSeatLimit: integer('portal_seat_limit'),
  portalSeatAddon: integer('portal_seat_addon').default(0).notNull(),
  storageQuotaBytes: bigint('storage_quota_bytes', { mode: 'number' }),
  storageAddonBytes: bigint('storage_addon_bytes', { mode: 'number' }).default(0).notNull(),
  storageUsedBytes: bigint('storage_used_bytes', { mode: 'number' }).default(0).notNull(),

import { pgTable, text, timestamp, pgEnum, boolean, index } from 'drizzle-orm/pg-core';

  portalAccess: boolean('portal_access').default(false).notNull(),

    clinicPortalActiveIdx: index('patients_clinic_portal_active_idx').on(table.clinicId, table.portalAccess),

import { text, timestamp, integer, pgEnum, index } from 'drizzle-orm/pg-core';
import { appSchema } from './base';

export const addonTypeEnum = pgEnum('addon_type', ['storage', 'portal_seats']);
export const addonRequestStatusEnum = pgEnum('addon_request_status', ['pending', 'approved', 'rejected', 'cancelled']);

export const addonRequests = appSchema.table('addon_requests', {
  id: text('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
  clinicId: text('clinic_id').notNull(),         // FK to clinics.id (enforced in SQL)
  requestedBy: text('requested_by').notNull(),    // users.id
  addonType: addonTypeEnum('addon_type').notNull(),
  quantity: integer('quantity').notNull(),        // GB for storage, seats for portal
  unitPricePkr: integer('unit_price_pkr').notNull(),
  totalPricePkr: integer('total_price_pkr').notNull(),
  status: addonRequestStatusEnum('status').default('pending').notNull(),
  approvedBy: text('approved_by'),                // users.id (superadmin)
  approvedAt: timestamp('approved_at'),
  cancelledAt: timestamp('cancelled_at'),
  cancelledBy: text('cancelled_by'),
  rejectedReason: text('rejected_reason'),
  notes: text('notes'),
  createdAt: timestamp('created_at').defaultNow().notNull(),
  updatedAt: timestamp('updated_at').defaultNow().notNull(),
}, (table) => ({
  clinicStatusIdx: index('addon_requests_clinic_status_idx').on(table.clinicId, table.status),
  statusCreatedIdx: index('addon_requests_status_created_idx').on(table.status, table.createdAt),
}));

export type AddonRequest = typeof addonRequests.$inferSelect;
export type NewAddonRequest = typeof addonRequests.$inferInsert;

// Addon Requests (storage + portal seat addons)
export * from './addon_requests';
// Addon Pricing (superadmin-editable)
export * from './addon_pricing';

import { text, timestamp, integer, jsonb, index } from 'drizzle-orm/pg-core';
import { appSchema } from './base';

export const addonPricing = appSchema.table('addon_pricing', {
  id: text('id').primaryKey(),  // always 'current' for the live row
  storage50GbPkr: integer('storage_50gb_pkr').notNull(),
  storage200GbPkr: integer('storage_200gb_pkr').notNull(),
  storage500GbPkr: integer('storage_500gb_pkr').notNull(),
  storage1TbPkr: integer('storage_1tb_pkr').notNull(),
  portalSeats3PackProPkr: integer('portal_seats_3pack_pro_pkr').notNull(),
  portalSeats3PackProPlusPkr: integer('portal_seats_3pack_pro_plus_pkr').notNull(),
  updatedAt: timestamp('updated_at').defaultNow().notNull(),
  updatedBy: text('updated_by'),
});

export const addonPricingHistory = appSchema.table('addon_pricing_history', {
  id: text('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
  changedAt: timestamp('changed_at').defaultNow().notNull(),
  changedBy: text('changed_by'),
  beforeValues: jsonb('before_values').notNull(),
  afterValues: jsonb('after_values').notNull(),
}, (table) => ({
  changedAtIdx: index('addon_pricing_history_changed_at_idx').on(table.changedAt),
}));

export type AddonPricing = typeof addonPricing.$inferSelect;

cd server && npx tsc --noEmit

git add server/src/schema/clinics.ts server/src/schema/patients.ts server/src/schema/addon_requests.ts server/src/schema/index.ts
git commit -m "feat(db): Drizzle schema for portal/storage quotas + addon_requests"

import { describe, it, expect, beforeEach, vi } from 'vitest';
import { checkUploadAllowed, recordUpload, recordDelete, getEffectiveStorageQuota } from './storage-tracker';

const mockDb = {
  select: vi.fn(),
  update: vi.fn(),
  execute: vi.fn(),
};

describe('storage-tracker', () => {
  beforeEach(() => vi.clearAllMocks());

  it('checkUploadAllowed returns allowed:true under quota', async () => {
    mockDb.select.mockReturnValue({
      from: () => ({ where: () => ({ limit: () => Promise.resolve([
        { storageUsedBytes: 1024, storageQuotaBytes: null, storageAddonBytes: 0, subscriptionStatus: 'active', subscriptionPlanId: 'pro' },
      ]) }) }),
    });
    const result = await checkUploadAllowed(mockDb as any, 'c1', 2048, { isTrial: false, planKey: 'pro' });
    expect(result.allowed).toBe(true);
  });

  it('checkUploadAllowed returns allowed:false over quota', async () => {
    const GB = 1024 * 1024 * 1024;
    mockDb.select.mockReturnValue({
      from: () => ({ where: () => ({ limit: () => Promise.resolve([
        { storageUsedBytes: 100 * GB, storageQuotaBytes: null, storageAddonBytes: 0, subscriptionStatus: 'active', subscriptionPlanId: 'pro' },
      ]) }) }),
    });
    const result = await checkUploadAllowed(mockDb as any, 'c1', 1024, { isTrial: false, planKey: 'pro' });
    expect(result.allowed).toBe(false);
    expect(result.reason).toContain('storage');
  });

  it('checkUploadAllowed bypasses cap during trial', async () => {
    const GB = 1024 * 1024 * 1024;
    mockDb.select.mockReturnValue({
      from: () => ({ where: () => ({ limit: () => Promise.resolve([
        { storageUsedBytes: 9999 * GB, storageQuotaBytes: null, storageAddonBytes: 0, subscriptionStatus: 'trial', subscriptionPlanId: 'pro' },
      ]) }) }),
    });
    const result = await checkUploadAllowed(mockDb as any, 'c1', 1024, { isTrial: true, planKey: 'pro' });
    expect(result.allowed).toBe(true);
  });

  it('getEffectiveStorageQuota uses override when set, else plan + addon', async () => {
    const GB = 1024 * 1024 * 1024;
    expect(getEffectiveStorageQuota({ storageQuotaBytes: 500 * GB, storageAddonBytes: 0, planKey: 'pro' })).toBe(500 * GB);
    expect(getEffectiveStorageQuota({ storageQuotaBytes: null, storageAddonBytes: 10 * GB, planKey: 'pro' })).toBe(110 * GB);
    expect(getEffectiveStorageQuota({ storageQuotaBytes: null, storageAddonBytes: 0, planKey: 'enterprise' })).toBeNull();
  });

  it('recordUpload increments atomically', async () => {
    const updateMock = vi.fn().mockReturnValue({ set: () => ({ where: () => Promise.resolve() }) });
    mockDb.update.mockImplementation(updateMock);
    await recordUpload(mockDb as any, 'c1', 4096);
    expect(updateMock).toHaveBeenCalled();
  });
});

import { eq, sql } from 'drizzle-orm';
import { clinics } from '../schema';
import { PLAN_LIMITS, type PlanKey } from './plan-limits';

export interface UploadCheckOptions {
  isTrial: boolean;
  planKey: PlanKey;
}

export interface UploadCheck {
  allowed: boolean;
  reason?: string;
  usedBytes?: number;
  quotaBytes?: number | null;
}

/**
 * Compute effective storage quota for a clinic. Order of precedence:
 *   1. Direct override on clinics.storage_quota_bytes (Enterprise tier)
 *   2. Plan base (from PLAN_LIMITS) + addons
 *   3. null → unlimited (Enterprise)
 */
export function getEffectiveStorageQuota(opts: {
  storageQuotaBytes: number | null;
  storageAddonBytes: number;
  planKey: PlanKey;
}): number | null {
  if (opts.storageQuotaBytes !== null && opts.storageQuotaBytes !== undefined) {
    return opts.storageQuotaBytes + (opts.storageAddonBytes || 0);
  }
  const base = PLAN_LIMITS[opts.planKey].storageBytes;
  if (base === null) return null;
  return base + (opts.storageAddonBytes || 0);
}

export async function checkUploadAllowed(
  db: any,
  clinicId: string,
  fileSize: number,
  opts: UploadCheckOptions,
): Promise<UploadCheck> {
  const [row] = await db
    .select({
      storageUsedBytes: clinics.storageUsedBytes,
      storageQuotaBytes: clinics.storageQuotaBytes,
      storageAddonBytes: clinics.storageAddonBytes,
    })
    .from(clinics)
    .where(eq(clinics.id, clinicId))
    .limit(1);

  if (!row) return { allowed: false, reason: 'clinic not found' };
  if (opts.isTrial) return { allowed: true, usedBytes: row.storageUsedBytes ?? 0 };

  const quota = getEffectiveStorageQuota({
    storageQuotaBytes: row.storageQuotaBytes ?? null,
    storageAddonBytes: row.storageAddonBytes ?? 0,
    planKey: opts.planKey,
  });

  const used = row.storageUsedBytes ?? 0;
  if (quota === null) return { allowed: true, usedBytes: used, quotaBytes: null };

  if (used + fileSize > quota) {
    return {
      allowed: false,
      reason: 'storage quota exceeded',
      usedBytes: used,
      quotaBytes: quota,
    };
  }
  return { allowed: true, usedBytes: used, quotaBytes: quota };
}

export async function recordUpload(db: any, clinicId: string, delta: number): Promise<void> {
  if (delta <= 0) return;
  await db
    .update(clinics)
    .set({ storageUsedBytes: sql`${clinics.storageUsedBytes} + ${delta}` })
    .where(eq(clinics.id, clinicId));
}

export async function recordDelete(db: any, clinicId: string, delta: number): Promise<void> {
  if (delta <= 0) return;
  await db
    .update(clinics)
    .set({ storageUsedBytes: sql`GREATEST(0, ${clinics.storageUsedBytes} - ${delta})` })
    .where(eq(clinics.id, clinicId));
}

/**
 * Source-of-truth recomputation. Sums sizes across every file table.
 * Called from nightly cron and superadmin "Recompute storage" button.
 */
export async function recomputeUsage(db: any, clinicId: string): Promise<number> {
  const result = await db.execute(sql`
    SELECT
      COALESCE((SELECT SUM(size) FROM app.patient_files WHERE clinic_id = ${clinicId} AND deleted_at IS NULL), 0)
      AS total
  `);
  const total = Number((result as any).rows?.[0]?.total ?? (result as any)[0]?.total ?? 0);
  await db
    .update(clinics)
    .set({ storageUsedBytes: total })
    .where(eq(clinics.id, clinicId));
  return total;
}

git add server/src/lib/storage-tracker.ts server/src/lib/storage-tracker.test.ts
git commit -m "feat(storage): storage-tracker module with atomic upload/delete + quota check"

import { describe, it, expect } from 'vitest';
import { isClinicOnTrial } from './trial-status';

describe('trial-status', () => {
  it('returns true when subscriptionStatus is trial and trial not yet ended', () => {
    const tomorrow = new Date(Date.now() + 86400000);
    expect(isClinicOnTrial({ subscriptionStatus: 'trial', trialEndDate: tomorrow })).toBe(true);
  });

  it('returns false when subscriptionStatus is trial but trial has expired', () => {
    const yesterday = new Date(Date.now() - 86400000);
    expect(isClinicOnTrial({ subscriptionStatus: 'trial', trialEndDate: yesterday })).toBe(false);
  });

  it('returns false when subscriptionStatus is active', () => {
    const tomorrow = new Date(Date.now() + 86400000);
    expect(isClinicOnTrial({ subscriptionStatus: 'active', trialEndDate: tomorrow })).toBe(false);
  });

  it('returns false when trialEndDate is null', () => {
    expect(isClinicOnTrial({ subscriptionStatus: 'trial', trialEndDate: null })).toBe(false);
  });
});

export function isClinicOnTrial(clinic: {
  subscriptionStatus?: string | null;
  trialEndDate?: Date | string | null;
}): boolean {
  if (clinic.subscriptionStatus !== 'trial') return false;
  if (!clinic.trialEndDate) return false;
  const end = clinic.trialEndDate instanceof Date ? clinic.trialEndDate : new Date(clinic.trialEndDate);
  return end.getTime() > Date.now();
}

cd server && npx vitest run src/lib/trial-status.test.ts
git add server/src/lib/trial-status.ts server/src/lib/trial-status.test.ts
git commit -m "feat(billing): isClinicOnTrial helper for cap-enforcement bypass"

cd server && grep -rn "uploadFile\|r2.put\|R2Service" src/routes --include="*.ts" -l

import { checkUploadAllowed, recordUpload } from '../lib/storage-tracker';
import { isClinicOnTrial } from '../lib/trial-status';
import { resolvePlanKey } from '../lib/plan-limits';

// At top of the handler, after clinic loaded:
const planKey = resolvePlanKey({ planName: clinic.subscriptionPlanName, planTier: clinic.subscriptionPlanTier });
const check = await checkUploadAllowed(db, clinicId, fileSize, {
  isTrial: isClinicOnTrial(clinic),
  planKey,
});
if (!check.allowed) {
  return c.json({
    error: 'STORAGE_QUOTA_EXCEEDED',
    message: 'Your clinic has reached its storage limit. Request more storage to keep uploading.',
    usedBytes: check.usedBytes,
    quotaBytes: check.quotaBytes,
  }, 413);
}

await recordUpload(db, clinicId, result.size);

import { recordDelete } from '../lib/storage-tracker';
// after successful r2.deleteFile:
await recordDelete(db, clinicId, deletedRow.size);

git add server/src/routes/
git commit -m "feat(storage): gate every R2 upload route on per-clinic quota"

import { and, eq, isNull, sql } from 'drizzle-orm';
import { clinics, patients } from '../schema';
import { PLAN_LIMITS, type PlanKey, getPortalSeatLimit } from './plan-limits';

export async function countActivePortalSeats(db: any, clinicId: string): Promise<number> {
  const [row] = await db
    .select({ n: sql<number>`count(*)::int` })
    .from(patients)
    .where(and(eq(patients.clinicId, clinicId), eq(patients.portalAccess, true), isNull(patients.deletedAt)));
  return Number(row?.n ?? 0);
}

export function getEffectivePortalSeatLimit(opts: {
  portalSeatLimit: number | null;
  portalSeatAddon: number;
  planKey: PlanKey;
}): number | null {
  if (opts.portalSeatLimit !== null && opts.portalSeatLimit !== undefined) {
    return opts.portalSeatLimit + (opts.portalSeatAddon || 0);
  }
  return getPortalSeatLimit(opts.planKey, opts.portalSeatAddon || 0);
}

import { describe, it, expect } from 'vitest';
import { getEffectivePortalSeatLimit } from './portal-seats';

describe('portal-seats', () => {
  it('uses override when set', () => {
    expect(getEffectivePortalSeatLimit({ portalSeatLimit: 500, portalSeatAddon: 0, planKey: 'pro' })).toBe(500);
    expect(getEffectivePortalSeatLimit({ portalSeatLimit: 500, portalSeatAddon: 6, planKey: 'pro' })).toBe(506);
  });

  it('falls back to plan + addon', () => {
    expect(getEffectivePortalSeatLimit({ portalSeatLimit: null, portalSeatAddon: 3, planKey: 'pro' })).toBe(103);
    expect(getEffectivePortalSeatLimit({ portalSeatLimit: null, portalSeatAddon: 9, planKey: 'proPlus' })).toBe(259);
  });

  it('returns null for enterprise with no override', () => {
    expect(getEffectivePortalSeatLimit({ portalSeatLimit: null, portalSeatAddon: 0, planKey: 'enterprise' })).toBeNull();
  });
});

import { countActivePortalSeats, getEffectivePortalSeatLimit } from '../lib/portal-seats';
import { resolvePlanKey } from '../lib/plan-limits';
import { isClinicOnTrial } from '../lib/trial-status';
import { recordAuditLog } from '../lib/audit-helper';

patientsRoute.patch('/:id/portal-access', requirePermission('patients.edit'), async (c) => {
  const db = getReadDb(c.env);
  const writeDb = getWriteDb(c.env);
  const patientId = c.req.param('id');
  const body = await c.req.json();
  const enabled = !!body.enabled;
  const clinicId = c.get('clinicId') as string;
  const userId = c.get('userId') as string;

  const [patient] = await db.select().from(patients).where(and(eq(patients.id, patientId), eq(patients.clinicId, clinicId))).limit(1);
  if (!patient) return c.json({ error: 'not found' }, 404);

  if (enabled && !patient.portalAccess) {
    // Check seat cap
    const [clinic] = await db.select({
      clinic: clinics,
      planName: subscriptionPlans.planName,
      planTier: subscriptionPlans.planTier,
    }).from(clinics).leftJoin(subscriptionPlans, eq(clinics.subscriptionPlanId, subscriptionPlans.id)).where(eq(clinics.id, clinicId)).limit(1);

    if (!isClinicOnTrial(clinic.clinic)) {
      const planKey = resolvePlanKey({ planName: clinic.planName, planTier: clinic.planTier });
      const limit = getEffectivePortalSeatLimit({
        portalSeatLimit: clinic.clinic.portalSeatLimit,
        portalSeatAddon: clinic.clinic.portalSeatAddon ?? 0,
        planKey,
      });
      const used = await countActivePortalSeats(db, clinicId);
      if (limit !== null && used >= limit) {
        return c.json({
          error: 'PORTAL_SEAT_LIMIT_REACHED',
          message: `You've reached your ${limit}-seat portal limit. Request more seats to enroll this patient.`,
          used, limit,
        }, 409);
      }
    }

    // If no user exists yet, the caller should hit the existing "create patient user" endpoint first.
    // Here we only flip the flag; user-row provisioning lives in patient-create handler.
  }

  await writeDb.update(patients).set({ portalAccess: enabled, updatedAt: new Date() }).where(eq(patients.id, patientId));

  await recordAuditLog(writeDb, {
    clinicId,
    userId,
    action: enabled ? 'portal_access.granted' : 'portal_access.revoked',
    entityType: 'patient',
    entityId: patientId,
    changes: { portalAccess: { from: patient.portalAccess, to: enabled } },
  });

  return c.json({ ok: true, portalAccess: enabled });
});

cd server && npx tsc --noEmit
git add server/src/routes/patients.ts server/src/lib/portal-seats.ts server/src/lib/portal-seats.test.ts
git commit -m "feat(patients): portal-access toggle endpoint with seat-cap enforcement"

import { describe, it, expect } from 'vitest';
import { calculateAddonPrice, type LivePricing } from './addon-pricing';

const PRICING: LivePricing = {
  storage50GbPkr: 1499,
  storage200GbPkr: 4999,
  storage500GbPkr: 9999,
  storage1TbPkr: 14999,
  portalSeats3PackProPkr: 999,
  portalSeats3PackProPlusPkr: 699,
};

describe('calculateAddonPrice', () => {
  it('storage uses the requested tier price', () => {
    expect(calculateAddonPrice({ addonType: 'storage', tier: 50, planKey: 'pro', pricing: PRICING })).toEqual({ unitPrice: 1499, totalPrice: 1499, gbAllocated: 50 });
    expect(calculateAddonPrice({ addonType: 'storage', tier: 200, planKey: 'pro', pricing: PRICING })).toEqual({ unitPrice: 4999, totalPrice: 4999, gbAllocated: 200 });
    expect(calculateAddonPrice({ addonType: 'storage', tier: 500, planKey: 'proPlus', pricing: PRICING })).toEqual({ unitPrice: 9999, totalPrice: 9999, gbAllocated: 500 });
    expect(calculateAddonPrice({ addonType: 'storage', tier: 1000, planKey: 'proPlus', pricing: PRICING })).toEqual({ unitPrice: 14999, totalPrice: 14999, gbAllocated: 1000 });
  });

  it('throws on unknown storage tier', () => {
    expect(() => calculateAddonPrice({ addonType: 'storage', tier: 75 as any, planKey: 'pro', pricing: PRICING })).toThrow();
  });

  it('portal_seats 3-pack pricing depends on plan', () => {
    expect(calculateAddonPrice({ addonType: 'portal_seats', quantity: 3, planKey: 'pro', pricing: PRICING })).toEqual({ unitPrice: 999, totalPrice: 999 });
    expect(calculateAddonPrice({ addonType: 'portal_seats', quantity: 6, planKey: 'pro', pricing: PRICING })).toEqual({ unitPrice: 999, totalPrice: 1998 });
    expect(calculateAddonPrice({ addonType: 'portal_seats', quantity: 3, planKey: 'proPlus', pricing: PRICING })).toEqual({ unitPrice: 699, totalPrice: 699 });
    expect(calculateAddonPrice({ addonType: 'portal_seats', quantity: 9, planKey: 'proPlus', pricing: PRICING })).toEqual({ unitPrice: 699, totalPrice: 2097 });
  });

  it('throws on non-multiple-of-3 portal_seats', () => {
    expect(() => calculateAddonPrice({ addonType: 'portal_seats', quantity: 4, planKey: 'pro', pricing: PRICING })).toThrow();
  });

  it('honors live pricing override (e.g. superadmin raises 50GB tier)', () => {
    const raised = { ...PRICING, storage50GbPkr: 1999 };
    expect(calculateAddonPrice({ addonType: 'storage', tier: 50, planKey: 'pro', pricing: raised })).toEqual({ unitPrice: 1999, totalPrice: 1999, gbAllocated: 50 });
  });
});

import { eq } from 'drizzle-orm';
import { ADDON_PRICING, type PlanKey, type StorageTierGb } from './plan-limits';
import { addonPricing } from '../schema';

export type AddonType = 'storage' | 'portal_seats';

export type AddonPriceInput =
  | { addonType: 'storage'; tier: StorageTierGb; planKey: PlanKey; pricing: LivePricing }
  | { addonType: 'portal_seats'; quantity: number; planKey: PlanKey; pricing: LivePricing };

export interface AddonPriceResult {
  unitPrice: number;
  totalPrice: number;
  gbAllocated?: number;  // populated for storage addons
}

export interface LivePricing {
  storage50GbPkr: number;
  storage200GbPkr: number;
  storage500GbPkr: number;
  storage1TbPkr: number;
  portalSeats3PackProPkr: number;
  portalSeats3PackProPlusPkr: number;
}

let pricingCache: { value: LivePricing; expires: number } | null = null;
const CACHE_MS = 60_000;

export async function getLivePricing(db: any): Promise<LivePricing> {
  const now = Date.now();
  if (pricingCache && pricingCache.expires > now) return pricingCache.value;
  try {
    const [row] = await db.select().from(addonPricing).where(eq(addonPricing.id, 'current')).limit(1);
    if (row) {
      const value: LivePricing = {
        storage50GbPkr: row.storage50GbPkr,
        storage200GbPkr: row.storage200GbPkr,
        storage500GbPkr: row.storage500GbPkr,
        storage1TbPkr: row.storage1TbPkr,
        portalSeats3PackProPkr: row.portalSeats3PackProPkr,
        portalSeats3PackProPlusPkr: row.portalSeats3PackProPlusPkr,
      };
      pricingCache = { value, expires: now + CACHE_MS };
      return value;
    }
  } catch {
    // fall through to defaults
  }
  return {
    storage50GbPkr: ADDON_PRICING.storageTiers[50],
    storage200GbPkr: ADDON_PRICING.storageTiers[200],
    storage500GbPkr: ADDON_PRICING.storageTiers[500],
    storage1TbPkr: ADDON_PRICING.storageTiers[1000],
    portalSeats3PackProPkr: ADDON_PRICING.portalSeats3PackPkr.pro,
    portalSeats3PackProPlusPkr: ADDON_PRICING.portalSeats3PackPkr.proPlus,
  };
}

export function invalidatePricingCache() {
  pricingCache = null;
}

function storageTierPrice(p: LivePricing, tier: StorageTierGb): number {
  switch (tier) {
    case 50: return p.storage50GbPkr;
    case 200: return p.storage200GbPkr;
    case 500: return p.storage500GbPkr;
    case 1000: return p.storage1TbPkr;
    default: throw new Error(`unknown storage tier ${tier}`);
  }
}

export function calculateAddonPrice(input: AddonPriceInput): AddonPriceResult {
  const p = input.pricing;

  if (input.addonType === 'storage') {
    if (![50, 200, 500, 1000].includes(input.tier)) {
      throw new Error(`storage tier must be 50, 200, 500, or 1000 GB`);
    }
    const price = storageTierPrice(p, input.tier);
    return { unitPrice: price, totalPrice: price, gbAllocated: input.tier };
  }

  if (!Number.isInteger(input.quantity) || input.quantity <= 0 || input.quantity % 3 !== 0) {
    throw new Error('portal_seats addons must be a positive multiple of 3');
  }
  if (input.planKey === 'enterprise') {
    throw new Error('enterprise tier does not use addons; set quota directly');
  }
  const packs = input.quantity / 3;
  const perPack = input.planKey === 'proPlus' ? p.portalSeats3PackProPlusPkr : p.portalSeats3PackProPkr;
  return { unitPrice: perPack, totalPrice: perPack * packs };
}

// Convenience wrapper that loads pricing from DB
export async function calculateAddonPriceFromDb(db: any, input: Omit<AddonPriceInput, 'pricing'>): Promise<AddonPriceResult> {
  const pricing = await getLivePricing(db);
  return calculateAddonPrice({ ...input, pricing } as AddonPriceInput);
}

cd server && npx vitest run src/lib/addon-pricing.test.ts
git add server/src/lib/addon-pricing.ts server/src/lib/addon-pricing.test.ts
git commit -m "feat(billing): addon pricing calculator (storage + portal seats)"

import { Hono } from 'hono';
import { and, desc, eq } from 'drizzle-orm';
import { getReadDb, getWriteDb } from '../lib/db';
import { addonRequests, clinics, subscriptionPlans } from '../schema';
import { calculateAddonPriceFromDb, type AddonType } from '../lib/addon-pricing';
import { resolvePlanKey } from '../lib/plan-limits';
import { requirePermission } from '../middleware/permissions';
import { recordAuditLog } from '../lib/audit-helper';
import { alertNewAddonRequest } from '../lib/superadmin-alerts';

const route = new Hono();

route.post('/', requirePermission('billing.request_addon'), async (c) => {
  const db = getReadDb(c.env);
  const writeDb = getWriteDb(c.env);
  const clinicId = c.get('clinicId') as string;
  const userId = c.get('userId') as string;
  const body = await c.req.json();
  const addonType = body.addonType as AddonType;
  const notes = typeof body.notes === 'string' ? body.notes.slice(0, 1000) : null;

  if (!['storage', 'portal_seats'].includes(addonType)) {
    return c.json({ error: 'invalid addonType' }, 400);
  }

  const [clinic] = await db.select({
    clinic: clinics,
    planName: subscriptionPlans.planName,
    planTier: subscriptionPlans.planTier,
  }).from(clinics).leftJoin(subscriptionPlans, eq(clinics.subscriptionPlanId, subscriptionPlans.id)).where(eq(clinics.id, clinicId)).limit(1);
  if (!clinic) return c.json({ error: 'clinic not found' }, 404);

  const planKey = resolvePlanKey({ planName: clinic.planName, planTier: clinic.planTier });
  let priced;
  let quantity: number;  // GB for storage, seats for portal_seats — what gets stored
  try {
    if (addonType === 'storage') {
      const tier = Number(body.tier);
      priced = await calculateAddonPriceFromDb(db, { addonType: 'storage', tier: tier as any, planKey });
      quantity = priced.gbAllocated!;
    } else {
      quantity = Number(body.quantity);
      priced = await calculateAddonPriceFromDb(db, { addonType: 'portal_seats', quantity, planKey });
    }
  } catch (e: any) {
    return c.json({ error: e.message }, 400);
  }

  const [inserted] = await writeDb.insert(addonRequests).values({
    id: crypto.randomUUID(),
    clinicId,
    requestedBy: userId,
    addonType,
    quantity,
    unitPricePkr: priced.unitPrice,
    totalPricePkr: priced.totalPrice,
    notes,
  }).returning();

  await recordAuditLog(writeDb, {
    clinicId,
    userId,
    action: 'addon_request.created',
    entityType: 'addon_request',
    entityId: inserted.id,
    changes: { addonType, quantity, totalPricePkr: priced.totalPrice },
  });

  await alertNewAddonRequest({ env: c.env, clinicId, requestId: inserted.id, addonType, quantity, totalPricePkr: priced.totalPrice });

  return c.json(inserted, 201);
});

route.get('/', requirePermission('billing.invoices.view'), async (c) => {
  const db = getReadDb(c.env);
  const clinicId = c.get('clinicId') as string;
  const rows = await db.select().from(addonRequests).where(eq(addonRequests.clinicId, clinicId)).orderBy(desc(addonRequests.createdAt));
  return c.json(rows);
});

route.delete('/:id', requirePermission('billing.request_addon'), async (c) => {
  const writeDb = getWriteDb(c.env);
  const clinicId = c.get('clinicId') as string;
  const userId = c.get('userId') as string;
  const id = c.req.param('id');
  const [row] = await writeDb.select().from(addonRequests).where(and(eq(addonRequests.id, id), eq(addonRequests.clinicId, clinicId))).limit(1);
  if (!row) return c.json({ error: 'not found' }, 404);
  if (row.status !== 'pending') return c.json({ error: 'only pending requests can be cancelled' }, 409);
  await writeDb.update(addonRequests).set({ status: 'cancelled', cancelledAt: new Date(), cancelledBy: userId, updatedAt: new Date() }).where(eq(addonRequests.id, id));
  await recordAuditLog(writeDb, { clinicId, userId, action: 'addon_request.cancelled', entityType: 'addon_request', entityId: id });
  return c.json({ ok: true });
});

export default route;

export async function alertNewAddonRequest(opts: {
  env: any;
  clinicId: string;
  requestId: string;
  addonType: 'storage' | 'portal_seats';
  quantity: number;
  totalPricePkr: number;
}) {
  // Reuses existing superadmin notification plumbing. Follow the pattern in alertUpgradeRequest.
  // If alertUpgradeRequest is unsuitable, write a new row to superadmin_alerts with kind='addon_request'.
}

import addonRequestsRoute from './routes/addon-requests';
// ...
protectedRoutes.route('/billing/addon-requests', addonRequestsRoute);