// lib/mixpanel.ts
"use client";
import mixpanel from "mixpanel-browser";

let initialized = false;

export function initMixpanel() {
  if (initialized || typeof window === "undefined") return;
  mixpanel.init(process.env.NEXT_PUBLIC_MIXPANEL_TOKEN!, {
    persistence: "localStorage",
    // Route tracking calls through your own domain to bypass ad blockers
    api_host: "/mp",
    // Enable session replay (20K replays/month on Growth plan)
    record_sessions_percent: 100,
    // Enable heatmap data collection
    record_heatmap_data: true,
    // Stop persisting UTM params in super properties (modern behavior)
    stop_utm_persistence: true,
    debug: process.env.NODE_ENV === "development",
  });
  initialized = true;
}

export { mixpanel };

// components/analytics-provider.tsx
"use client";
import { useEffect } from "react";
import { usePathname } from "next/navigation";
import { initMixpanel, mixpanel } from "@/lib/mixpanel";

export function AnalyticsProvider({ children }: { children: React.ReactNode }) {
  const pathname = usePathname();

  useEffect(() => {
    initMixpanel();
  }, []);

  // Track page views on route change
  useEffect(() => {
    if (typeof window !== "undefined") {
      mixpanel.track("Page Viewed", {
        path: pathname,
        url: window.location.href,
        referrer: document.referrer,
      });
    }
  }, [pathname]);

  return <>{children}</>;
}

// next.config.ts
const nextConfig = {
  async rewrites() {
    return [
      {
        source: "/mp/:path*",
        destination: "https://api.mixpanel.com/:path*",
      },
    ];
  },
};

// lib/mixpanel-server.ts
import Mixpanel from "mixpanel";

// Singleton — reuse across requests
export const mp = Mixpanel.init(process.env.MIXPANEL_TOKEN!, {
  // Use EU data residency if needed
  // host: "api-eu.mixpanel.com",
});

// Helper: track a server-side event
export function trackServer(
  distinctId: string,
  event: string,
  properties?: Record<string, unknown>
) {
  mp.track(event, {
    distinct_id: distinctId,
    ...properties,
  });
}

// hooks/useAuth.ts — call these at the right lifecycle moments

import { mixpanel } from "@/lib/mixpanel";

// After successful login or signup
export function onUserAuthenticated(user: {
  id: string;
  email: string;
  name: string;
  plan: string;
  createdAt: string;
}) {
  // Link anonymous session to authenticated user
  mixpanel.identify(user.id);

  // Set persistent user profile properties
  mixpanel.people.set({
    $email: user.email,
    $name: user.name,
    plan: user.plan,
    created_at: user.createdAt,
  });

  // Set super properties — attached to every future event
  mixpanel.register({
    user_id: user.id,
    plan: user.plan,
  });
}

// After logout
export function onUserLoggedOut() {
  mixpanel.track("User Logged Out");
  // Clear identity — critical for shared devices
  mixpanel.reset();
}

// app/api/webhooks/stripe/route.ts
import { trackServer } from "@/lib/mixpanel-server";

export async function POST(req: Request) {
  const event = await parseStripeWebhook(req);

  if (event.type === "customer.subscription.created") {
    const { userId, plan, mrr } = extractSubscriptionData(event);

    // Server-side event — use the authenticated user ID as distinct_id
    trackServer(userId, "Subscription Started", {
      plan_name: plan,
      mrr_usd: mrr,
      billing_interval: "monthly",
      source: "stripe_webhook",
    });
  }
}

// Example: track when a user runs a report
import { mixpanel } from "@/lib/mixpanel";

function ReportBuilder() {
  const handleRunReport = async (config: ReportConfig) => {
    const startTime = Date.now();
    const result = await runReport(config);

    mixpanel.track("Report Run", {
      report_type: config.type,
      date_range_days: config.dateRangeDays,
      filters_applied: config.filters.length,
      result_count: result.rows.length,
      duration_ms: Date.now() - startTime,
    });
  };

  return <button onClick={() => handleRunReport(config)}>Run Report</button>;
}

// Set profile properties (client-side)
mixpanel.people.set({
  $email: user.email,
  $name: user.name,
  $avatar: user.avatarUrl,
  plan: user.plan,
  company: user.company,
  role: user.role,
  created_at: user.createdAt,
});

// Increment a numeric property (e.g., total reports run)
mixpanel.people.increment("reports_run", 1);

// Append to a list property (e.g., features used)
mixpanel.people.union("features_used", ["report_builder"]);

// Server-side profile update (Node.js)
mp.people.set(userId, {
  plan: newPlan,
  mrr: newMrr,
  last_payment_at: new Date().toISOString(),
});

// Register super properties after login
mixpanel.register({
  plan: user.plan,           // "free" | "growth" | "enterprise"
  user_role: user.role,      // "admin" | "member" | "viewer"
  app_version: APP_VERSION,  // "2.4.1"
  environment: process.env.NODE_ENV,
});

// Register a one-time property (won't overwrite if already set)
mixpanel.register_once({
  first_seen_at: new Date().toISOString(),
  acquisition_channel: getUtmSource(),
});

// Track each onboarding step
const ONBOARDING_STEPS = [
  "account_created",
  "profile_completed",
  "first_project_created",
  "first_team_member_invited",
  "first_feature_used",
] as const;

function trackOnboardingStep(
  step: (typeof ONBOARDING_STEPS)[number],
  properties?: Record<string, unknown>
) {
  mixpanel.track("Onboarding Step Completed", {
    step_name: step,
    step_number: ONBOARDING_STEPS.indexOf(step) + 1,
    total_steps: ONBOARDING_STEPS.length,
    ...properties,
  });
}

// Track the full trial-to-paid funnel (server-side)
// 1. Trial Started
trackServer(userId, "Trial Started", { plan: "growth", trial_days: 14 });

// 2. Pricing Page Viewed (client-side)
mixpanel.track("Pricing Page Viewed", { source: "in_app_banner" });

// 3. Upgrade CTA Clicked (client-side)
mixpanel.track("Upgrade CTA Clicked", { plan: "growth", cta_location: "sidebar" });

// 4. Checkout Started (client-side)
mixpanel.track("Checkout Started", { plan: "growth", mrr: 49 });

// 5. Subscription Started (server-side, from Stripe webhook)
trackServer(userId, "Subscription Started", {
  plan_name: "growth",
  mrr_usd: 49,
  billing_interval: "monthly",
  trial_converted: true,
  trial_days_used: 11,
});

// Full session replay + heatmap config
mixpanel.init(process.env.NEXT_PUBLIC_MIXPANEL_TOKEN!, {
  // Record 100% of sessions (reduce for high-traffic apps)
  record_sessions_percent: 100,
  // Enable heatmap data collection
  record_heatmap_data: true,
  // Mask sensitive inputs by default (PII protection)
  // record_mask_text_selector: ".sensitive, input[type=password]",
});

// Manually start/stop recording for specific flows
mixpanel.start_session_recording();
mixpanel.stop_session_recording();

// Link a replay to a specific event for easy lookup
mixpanel.track("Checkout Started", {
  plan: "growth",
  // Mixpanel automatically links this event to the active replay
});

// In Mixpanel Insights: filter by frustration signals
// Event: $mp_rage_click
// Breakdown by: $mp_element_text, $mp_page_url
// This shows you which buttons/links users are rage-clicking most

// You can also filter Session Replays by these events:
// Replays > Filter > Event contains "$mp_rage_click"
// → Watch exactly what frustrated users were trying to do

// Track when a user is assigned to an experiment variant
function trackExperimentExposure(
  experimentName: string,
  variant: "control" | "treatment"
) {
  mixpanel.track("Experiment Viewed", {
    experiment_name: experimentName,
    variant,
    // Mixpanel Experiments report uses these property names
    $experiment_started: experimentName,
    $variant: variant,
  });

  // Also register as super property so all subsequent events
  // carry the experiment context
  mixpanel.register({
    ["experiment_" + experimentName]: variant,
  });
}

// Usage: call when the feature flag is evaluated
const variant = featureFlags.getVariant("onboarding_v2");
trackExperimentExposure("onboarding_v2", variant);

-- 1. Create a Mixpanel service user in Snowflake
CREATE USER mixpanel_connector
  PASSWORD = '<secure_password>'
  DEFAULT_ROLE = mixpanel_role;

-- 2. Grant read access to your events table
GRANT SELECT ON TABLE analytics.events TO ROLE mixpanel_role;

-- 3. For Mirror mode, grant stream creation privileges
GRANT CREATE STREAM ON SCHEMA analytics TO ROLE mixpanel_role;

-- 4. In Mixpanel UI:
--    Settings > Warehouse Connectors > Add Connection
--    Select Snowflake, enter credentials
--    Map columns: distinct_id, event_name, time, properties
--    Choose sync mode: "Mirror" for real-time CDC sync

// 1. Initialize with group key (must match Mixpanel project settings)
mixpanel.init(token, {
  // ... other config
});

// 2. Set the group for the current user session
mixpanel.set_group("company_id", user.companyId);

// 3. Set group profile properties
mixpanel.get_group("company_id", user.companyId).set({
  company_name: company.name,
  plan: company.plan,
  mrr: company.mrr,
  employee_count: company.size,
  industry: company.industry,
  created_at: company.createdAt,
});

// 4. All events now carry the group key automatically
// You can analyze: "How many companies used Feature X this week?"
// instead of "How many users used Feature X this week?"

// Opt a user out of tracking (GDPR right to object)
mixpanel.opt_out_tracking();

// Check if user has opted out
const hasOptedOut = mixpanel.has_opted_out_tracking();

// Opt back in
mixpanel.opt_in_tracking();

// Delete a user's data (GDPR right to erasure)
// Use the Mixpanel GDPR API — server-side only
const response = await fetch(
  "https://mixpanel.com/api/app/data-deletions/v3.0/",
  {
    method: "POST",
    headers: {
      Authorization: `Basic ${btoa(process.env.MIXPANEL_SERVICE_ACCOUNT!)}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      distinct_ids: [userId],
      compliance_type: "GDPR",
    }),
  }
);

// Mask sensitive elements in session replay
mixpanel.init(token, {
  // Mask all text by default (most conservative)
  record_mask_text_selector: "*",
  // Or mask only specific elements
  // record_mask_text_selector: ".pii, input[type=email], input[type=password]",
  // Block specific elements from being recorded entirely
  record_block_selector: ".credit-card-form, .ssn-field",
});