Stage 4: FORGE -- Final Creative Architecture

-- Replaces is_admin BOOLEAN on fd_profiles
CREATE TYPE fd_role AS ENUM ('host', 'applicant', 'viewer');

ALTER TABLE fd_profiles
  ADD COLUMN role fd_role DEFAULT 'viewer',
  DROP COLUMN is_admin;

-- Backfill: existing admin → host
UPDATE fd_profiles SET role = 'host' WHERE is_admin = true;

// Profile.swift
enum FDRole: String, Codable {
    case host
    case applicant
    case viewer
}

struct Profile: Codable, Identifiable, Equatable {
    // ... existing fields ...
    var role: FDRole  // replaces isAdmin: Bool
    // remove: var isAdmin: Bool
}

// FirstDateApp.swift
var body: some Scene {
    WindowGroup {
        Group {
            if authManager.isLoading {
                SplashView()
            } else if !authManager.isAuthenticated {
                AuthView()
            } else if let profile = profileManager.profile {
                switch profile.role {
                case .host:
                    HostTabView()
                case .applicant:
                    if !profile.onboardingComplete {
                        OnboardingView()
                    } else {
                        ApplicantTabView()
                    }
                case .viewer:
                    if !profile.onboardingComplete {
                        OnboardingView()
                    } else {
                        ViewerTabView()
                    }
                }
            } else {
                OnboardingView()
            }
        }
    }
}

Waitlist (fd_waitlist)
  ↓ referral_code generates position bump
  ↓ waitlist_count auto-injects into pitch templates
Pitch (fd_episodes.pitch_stage)
  ↓ comp_meal → logo_placement → title_sponsor progression
  ↓ deal_value populates fd_ledger_entries on confirmation
Sponsor Content (fd_episodes published + sponsor attribution)
  ↓ view_count / like_count drive CPV in FinancialsView
  ↓ sponsor ROI report auto-generated per episode
Distribution (social sharing cards via ImageRenderer)
  ↓ share card includes waitlist count as social proof
  ↓ referral link embedded in share URL
Referral (fd_waitlist.referred_by)
  ↓ 5-spot bump triggers push notification
  ↓ cycle restarts: larger waitlist → stronger pitches

Date (fd_dates completed)
  ↓ post-date review captures vibe tags, would_meet_again
Review (fd_date_reviews)
  ↓ review data seeds content script Hook/Build/Payoff template
Script (fd_content_scripts)
  ↓ script drives edit, published episode references review moments
Content (fd_episodes published)
  ↓ published episode metadata feeds BehindTheGlass overlay
  ↓ episode reactions (view_count, comment_count) inform icebreaker context
Icebreaker (fd_icebreakers)
  ↓ Gemini Flash generates conversation starters from shared episode reactions
  ↓ icebreakers improve match conversations → more dates
Better Date (fd_dates proposed)
  ↓ cycle restarts: richer conversation history → more interesting dates → better content

PITCH → OUTREACH → NEGOTIATION → CONFIRMED → CASTING → SCHEDULED → FILMED → EDITING → REVIEW → PUBLISHED

-- pitch_stage tracks the deal pipeline BEFORE production begins
CREATE TYPE fd_pitch_stage AS ENUM (
    'identified',    -- restaurant identified as target
    'outreach',      -- initial contact made
    'negotiation',   -- terms being discussed
    'confirmed'      -- deal signed, ready for production
);

-- status tracks the production pipeline AFTER deal is confirmed
-- (existing enum, unchanged)
-- 'planning', 'casting', 'scheduled', 'filmed', 'editing', 'published'

struct ConsentCaptureSheet: View {
    let episode: Episode
    let participant: Profile
    @State private var typedName: String = ""
    @State private var signatureImage: UIImage?
    @State private var consentTextVersion: ConsentTextVersion
    // ... SignatureCanvasView, full text display, submit flow
}

ALTER TABLE fd_episodes ADD COLUMN behind_the_glass_type TEXT
    CHECK (behind_the_glass_type IN ('deal_story', 'casting_decision', 'outfit_cost', 'restaurant_secret', 'consent_moment'));
ALTER TABLE fd_episodes ADD COLUMN behind_the_glass_text TEXT;

-- 1. Consent text versions (legal compliance)
CREATE TABLE fd_consent_text_versions (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    version_hash TEXT UNIQUE NOT NULL,        -- SHA-256 of consent_text
    consent_text TEXT NOT NULL,               -- full legal text
    effective_from TIMESTAMPTZ DEFAULT now(),
    superseded_at TIMESTAMPTZ,                -- NULL = current version
    created_at TIMESTAMPTZ DEFAULT now()
);

-- 2. Content scripts (Hook/Build/Payoff templates)
CREATE TABLE fd_content_scripts (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    episode_id UUID REFERENCES fd_episodes(id) ON DELETE CASCADE,
    platform TEXT NOT NULL CHECK (platform IN ('tiktok', 'instagram', 'youtube')),
    hook_text TEXT,
    build_text TEXT,
    payoff_text TEXT,
    cta_text TEXT,
    generated_by TEXT DEFAULT 'manual' CHECK (generated_by IN ('manual', 'ai')),
    is_final BOOLEAN DEFAULT false,
    created_at TIMESTAMPTZ DEFAULT now(),
    updated_at TIMESTAMPTZ DEFAULT now()
);

-- 3. Icebreakers cache (one-shot per match)
CREATE TABLE fd_icebreakers (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    match_id UUID REFERENCES fd_matches(id) ON DELETE CASCADE UNIQUE,
    icebreakers JSONB NOT NULL,               -- array of 3 strings
    generated_at TIMESTAMPTZ DEFAULT now(),
    model TEXT DEFAULT 'gemini-2.0-flash'
);

-- 4. Rate limits (swipes, super likes)
CREATE TABLE fd_rate_limits (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    profile_id UUID REFERENCES fd_profiles(id) ON DELETE CASCADE,
    action TEXT NOT NULL CHECK (action IN ('swipe', 'super_like')),
    window_start TIMESTAMPTZ NOT NULL,
    count INTEGER DEFAULT 0,
    UNIQUE(profile_id, action, window_start)
);

CREATE TABLE fd_device_tokens (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    profile_id UUID REFERENCES fd_profiles(id) ON DELETE CASCADE,
    token TEXT NOT NULL,
    platform TEXT DEFAULT 'ios',
    is_active BOOLEAN DEFAULT true,
    created_at TIMESTAMPTZ DEFAULT now(),
    updated_at TIMESTAMPTZ DEFAULT now(),
    UNIQUE(profile_id, token)
);

CREATE EXTENSION IF NOT EXISTS postgis;

-- Add geography columns
ALTER TABLE fd_profiles ADD COLUMN location geography(Point, 4326);
ALTER TABLE fd_restaurants ADD COLUMN geolocation geography(Point, 4326);

-- Backfill restaurants from existing lat/lon
UPDATE fd_restaurants
SET geolocation = ST_SetSRID(ST_MakePoint(longitude, latitude), 4326)::geography
WHERE latitude IS NOT NULL AND longitude IS NOT NULL;

-- Discovery feed with distance
CREATE OR REPLACE FUNCTION fd_get_discovery_feed(
    p_user_id UUID,
    p_max_distance_km FLOAT DEFAULT 50,
    p_limit INT DEFAULT 20
) RETURNS TABLE(...) AS $$
    -- existing logic + ST_DWithin filter
    -- fallback: if user.location IS NULL, use neighborhood text match
$$ LANGUAGE plpgsql SECURITY DEFINER;

-- Index for spatial queries
CREATE INDEX idx_fd_profiles_location ON fd_profiles USING gist(location);
CREATE INDEX idx_fd_restaurants_geolocation ON fd_restaurants USING gist(geolocation);

-- fd_consent_records: INSERT only for authenticated, no UPDATE, no DELETE
CREATE POLICY "Insert consent" ON fd_consent_records
    FOR INSERT TO authenticated
    WITH CHECK (true);
-- No UPDATE or DELETE policies. Consent records are immutable.

-- fd_consent_text_versions: read-only for all authenticated
CREATE POLICY "Read consent text" ON fd_consent_text_versions
    FOR SELECT TO authenticated USING (true);
-- Only host can insert new versions (managed via migration, not app)

-- fd_content_scripts: host only
CREATE POLICY "Host manages scripts" ON fd_content_scripts
    FOR ALL TO authenticated
    USING (EXISTS (SELECT 1 FROM fd_profiles WHERE user_id = auth.uid() AND role = 'host'));

-- fd_icebreakers: participants of the match only
CREATE POLICY "Match participants read icebreakers" ON fd_icebreakers
    FOR SELECT TO authenticated
    USING (match_id IN (
        SELECT id FROM fd_matches
        WHERE profile_a IN (SELECT id FROM fd_profiles WHERE user_id = auth.uid())
           OR profile_b IN (SELECT id FROM fd_profiles WHERE user_id = auth.uid())
    ));

-- fd_device_tokens: own tokens only
CREATE POLICY "Own tokens" ON fd_device_tokens
    FOR ALL TO authenticated
    USING (profile_id IN (SELECT id FROM fd_profiles WHERE user_id = auth.uid()))
    WITH CHECK (profile_id IN (SELECT id FROM fd_profiles WHERE user_id = auth.uid()));

@MainActor
final class ExampleManager: ObservableObject {
    static let shared = ExampleManager()

    private let client: SupabaseClient

    // Production init (singleton)
    private init() {
        self.client = SupabaseConfig.client
    }

    // Test init (injected client)
    init(client: SupabaseClient) {
        self.client = client
    }
}

// EpisodeManager -- new methods (absorbed from killed PitchManager)
func updatePitchStage(_ episodeId: String, stage: FDPitchStage) async throws
func advanceToProduction(_ episodeId: String) async throws  // pitch_stage=confirmed → status=casting
func setBehindTheGlass(_ episodeId: String, type: String, text: String) async throws
func loadSeasonEpisodes(season: Int) async

// ConsentManager -- new methods
func captureConsent(episodeId: String, participantId: String, typedName: String, signatureImage: UIImage) async throws
func getCurrentConsentText() async throws -> ConsentTextVersion

// NotificationManager
func registerForPush() async throws
func handleNotification(_ userInfo: [AnyHashable: Any]) -> DeepLink?
enum NotificationCategory: String { case match, message, applicationUpdate, episodePublished }

// WaitlistManager
func joinWaitlist(email: String, referralCode: String?) async throws -> WaitlistEntry
func getPosition(email: String) async throws -> Int
func generateReferralCode() -> String

// ContentScriptManager
func generateScript(episodeId: String, platform: ScriptPlatform) async throws -> ContentScript
func updateScript(_ scriptId: String, section: ScriptSection, text: String) async throws
enum ScriptPlatform: String, Codable { case tiktok, instagram, youtube }
enum ScriptSection { case hook, build, payoff, cta }

HostTabView
  ├── Tab 0: Inbox
  │   └── ApplicationInboxView (filtered pipeline: pending → reviewing → shortlisted → selected → passed)
  │       └── push → ApplicationDetailView
  │           ├── sheet → AssignToEpisodeSheet
  │           └── sheet → VideoPreviewSheet
  │
  ├── Tab 1: Pipeline
  │   └── EpisodePipelineView (Kanban + season selector + 10-week progress bar)
  │       ├── section → DealsSection (pitch_stage pipeline inline, NOT separate tab)
  │       └── push → EpisodeDetailView
  │           ├── sheet → ContentScriptView (per-platform script editor)
  │           ├── sheet → BehindTheGlassEditor
  │           ├── push → ClipTimelineView (hook/conflict/resolution timestamps)
  │           └── push → SponsorReportView (per-episode ROI, CPV)
  │
  ├── Tab 2: Schedule
  │   └── ProductionCalendarView (month view, episode blocks, conflict warnings)
  │       ├── sheet → ScheduleEpisodeSheet (date picker, time slot, restaurant)
  │       └── toolbar → MiamiMapView (episode-colored pins, restaurant detail sheet)
  │
  ├── Tab 3: Ledger
  │   └── FinancialsView (P&L summary, category breakdown, breakeven projection)
  │       ├── section → RevenueSection (income by category, deal pipeline value)
  │       ├── section → ExpenseSection (expenses by category, receipt gallery)
  │       ├── sheet → AddLedgerEntrySheet (type, category, amount, receipt photo, episode link)
  │       ├── push → WardrobeManagerView (grid, add item, sponsor attribution)
  │       └── push → BreakevenProjectionView (chart, assumptions editor)
  │
  └── Tab 4: Studio
      └── StudioView (pre-shoot checklist per episode)
          ├── Checklist: Restaurant confirmed ✓/✗
          ├── Checklist: Talent confirmed ✓/✗
          ├── Checklist: Consent signed ✓/✗ → sheet → ConsentCaptureSheet
          ├── Checklist: Outfit logged ✓/✗ → push → OutfitLogView
          └── Checklist: Equipment packed ✓/✗

ApplicantTabView
  ├── Tab 0: Series
  │   └── SeriesView (published episodes, season selector)
  │       └── push → EpisodePlayerView
  │           └── overlay → BehindTheGlassOverlay (translucent production detail)
  │
  ├── Tab 1: Apply
  │   └── ApplicationWizardView (4-step)
  │       ├── Step 1: AboutYouStep (name, age, bio, neighborhood)
  │       ├── Step 2: StoryStep (why_me, personality quiz)
  │       ├── Step 3: LookStep (photos + video selfie capture)
  │       └── Step 4: ConsentStep (acknowledge terms, submit)
  │       └── [post-submit] → ApplicationConfirmationView
  │
  ├── Tab 2: Spots
  │   └── RestaurantsView (cards, neighborhood filter)
  │       ├── push → RestaurantDetailView
  │       └── toolbar → MiamiMapView
  │
  └── Tab 3: Status
      └── ApplicationStatusView (current stage, timeline, what's next)
          └── [if selected] → push → PreProductionView (consent signing, scheduling)

ViewerTabView
  ├── Tab 0: Series
  │   └── SeriesView (published episodes, season selector)
  │       └── push → EpisodePlayerView
  │           └── overlay → BehindTheGlassOverlay
  │
  ├── Tab 1: Discover
  │   └── DiscoverView (swipe cards, personality quiz framing)
  │       ├── overlay → MatchPopupView (on mutual right-swipe)
  │       └── swipe-up → SuperLikeAnimation (1/day)
  │
  ├── Tab 2: Spots
  │   └── RestaurantsView (cards, neighborhood filter)
  │       ├── push → RestaurantDetailView
  │       └── toolbar → MiamiMapView
  │
  └── Tab 3: Matches
      └── MatchListView (matches with last message preview)
          └── push → ChatView
              ├── Icebreaker injection (if conversation empty, show 3 AI-generated starters)
              └── push → ProposeDateView → DateConfirmationView

   Generate 3 conversation starters for two people who matched on FirstDate,
   a Miami dating show. Profile A: {interests, cuisines}. Profile B: {interests, cuisines}.
   Shared context: {any episodes both reacted to}.
   Make them specific, playful, and reference Miami.

CREATE OR REPLACE FUNCTION fd_enforce_consent_gating()
RETURNS TRIGGER AS $$
BEGIN
    IF NEW.status = 'scheduled' AND NEW.consent_record_id IS NULL THEN
        RAISE EXCEPTION 'Cannot schedule episode without signed consent record';
    END IF;
    IF NEW.status = 'scheduled' AND NOT EXISTS (
        SELECT 1 FROM fd_consent_records WHERE id = NEW.consent_record_id
    ) THEN
        RAISE EXCEPTION 'Consent record does not exist';
    END IF;
    RETURN NEW;
END;
$$ LANGUAGE plpgsql;

CREATE TRIGGER trg_episode_consent_gating
    BEFORE UPDATE ON fd_episodes
    FOR EACH ROW
    WHEN (NEW.status = 'scheduled' AND OLD.status != 'scheduled')
    EXECUTE FUNCTION fd_enforce_consent_gating();