1// Binding used later to post the purchase result back into the trainer.
2@State private var trainerAction: [String: Any]? = nil
3
4kit.createTrainerChatView(
5    user: nil,                        // or your UserDetails
6    style: IStyle(style: "dark"),
7    isLoading: $isLoading,
8    customParams: [
9        "isSubscribed": SubscriptionManager.shared.isActive, // false = free tier
10        // Optional branding, so the preview sells YOUR coach:
11        "aiTrainerName": "ARIA+",
12        "aiTrainerColor": "#7C4DFF",
13    ],
14    workoutAction: $trainerAction,    // KinesteXAIKit >= 1.1.4
15    onMessageReceived: handleMessage
16)

val trainerView = KinesteXSDK.createTrainerChatView(
    context = this,
    style = IStyle(style = "dark"),
    customParams = mapOf(
        "isSubscribed" to subscriptionManager.isActive, // false = free tier
        // Optional branding, so the preview sells YOUR coach:
        "aiTrainerName" to "ARIA+",
        "aiTrainerColor" to "#7C4DFF",
    ),
    isLoading = isLoading,
    onMessageReceived = ::handleWebViewMessage,
    permissionHandler = this
)

const postData: IPostData = {
  key: 'YOUR_API_KEY',
  userId: 'user-123',
  company: 'YOUR_COMPANY',
  customParameters: {
    isSubscribed: subscriptionIsActive, // false = free tier
    // Optional branding, so the preview sells YOUR coach:
    aiTrainerName: 'ARIA+',
    aiTrainerColor: '#7C4DFF',
  },
  style: { style: 'dark' },
};

<KinestexSDK
  data={postData}
  integrationOption={IntegrationOption.AI_TRAINER_CHAT}
  handleMessage={handleMessage}
/>

KinesteXAIFramework.createTrainerChatView(
  style: IStyle(style: 'dark'),
  isShowKinestex: showKinesteX,
  isLoading: isLoading,
  customParams: {
    "isSubscribed": subscriptionIsActive, // false = free tier
    // Optional branding, so the preview sells YOUR coach:
    "aiTrainerName": "ARIA+",
    "aiTrainerColor": "#7C4DFF",
  },
  onMessageReceived: handleWebViewMessage,
);

// All parameters flat on the postData you send after kinestex_loaded.
const postData = {
  key: "YOUR_API_KEY",
  company: "YOUR_COMPANY",
  userId: "user-123",
  integration: "AI_TRAINER_CHAT",
  isSubscribed: subscriptionIsActive, // false = free tier
  // Optional branding, so the preview sells YOUR coach:
  aiTrainerName: "ARIA+",
  aiTrainerColor: "#7C4DFF",
  style: "dark",
};
iframe.contentWindow.postMessage(JSON.stringify(postData), "https://ai.kinestex.com");

const postData: IPostData = {
  key: 'YOUR_API_KEY',
  userId: 'user-123',
  company: 'YOUR_COMPANY',
  customParameters: {
    isSubscribed: subscriptionIsActive, // false = free tier
    // Optional branding, so the preview sells YOUR coach:
    aiTrainerName: 'ARIA+',
    aiTrainerColor: '#7C4DFF',
  },
};

<KinestexSDK
  integrationOption={IntegrationOption.AI_TRAINER_CHAT}
  data={postData}
  handleMessage={handleMessage}
/>

1private func handleMessage(_ message: KinestexMessage) {
2    switch message {
3    case .exit_kinestex:
4        showKinesteX = false
5    case .custom_type(let data):
6        guard let type = data["type"] as? String else { return }
7        if type == "open_subscription_flow" {
8            let source = data["source"] as? String // "generate_workout" | "chat_input"
9            analytics.track("paywall_shown", ["source": source ?? "unknown"])
10            presentSubscriptionFlow()
11        }
12    default:
13        break
14    }
15}

private fun handleWebViewMessage(message: WebViewMessage) {
    when (message) {
        is WebViewMessage.ExitKinestex -> closeTrainer()
        is WebViewMessage.CustomType -> when (message.data["type"] as? String) {
            "open_subscription_flow" -> {
                val source = message.data["source"] as? String // "generate_workout" | "chat_input"
                analytics.track("paywall_shown", mapOf("source" to (source ?: "unknown")))
                presentSubscriptionFlow()
            }
            else -> Unit
        }
        else -> Unit
    }
}

const handleMessage = (type: string, data: { [key: string]: any }) => {
  switch (type) {
    case 'open_subscription_flow':
      // data.source: "generate_workout" | "chat_input"
      analytics.track('paywall_shown', { source: data.source ?? 'unknown' });
      presentSubscriptionFlow();
      break;
    case 'exit_kinestex':
      closeTrainer();
      break;
  }
};

void handleWebViewMessage(WebViewMessage message) {
  if (message is ExitKinestex) {
    showKinesteX.value = false;
    return;
  }
  if (message is CustomType) {
    if (message.data['type'] == 'open_subscription_flow') {
      final source = message.data['source'] as String?; // "generate_workout" | "chat_input"
      analytics.track('paywall_shown', {'source': source ?? 'unknown'});
      presentSubscriptionFlow();
    }
  }
}

window.addEventListener("message", (event) => {
  if (event.origin !== "https://ai.kinestex.com") return;
  const message = JSON.parse(event.data);
  if (message.type === "open_subscription_flow") {
    // On the raw message, source sits next to type (there is no nested
    // .data object on this event): "generate_workout" | "chat_input"
    analytics.track("paywall_shown", { source: message.source ?? "unknown" });
    openPaywall();
  }
});

const handleMessage = (type: string, payload: Record<string, any>) => {
  switch (type) {
    case 'open_subscription_flow':
      // payload.source: "generate_workout" | "chat_input"
      analytics.track('paywall_shown', { source: payload.source ?? 'unknown' });
      presentSubscriptionFlow();
      break;
    case 'exit_kinestex':
      setShowTrainer(false);
      break;
  }
};

1func presentSubscriptionFlow() {
2    let paywall = PaywallViewController()
3    paywall.onPurchaseCompleted = { [weak self] in
4        self?.trainerAction = ["subscription_result": "purchased"] // parked workout generates
5        paywall.dismiss(animated: true)
6    }
7    paywall.onDismissed = { [weak self] in
8        self?.trainerAction = ["subscription_result": "dismissed"] // trainer resumes, preview stays
9    }
10    present(paywall, animated: true)
11}

private fun presentSubscriptionFlow() {
    PaywallSheet(
        onPurchaseCompleted = {
            KinesteXWebViewController.getInstance()
                .sendAction("subscription_result", "purchased") // parked workout generates
        },
        onDismissed = {
            KinesteXWebViewController.getInstance()
                .sendAction("subscription_result", "dismissed") // trainer resumes, preview stays
        }
    ).show(supportFragmentManager, "paywall")
}

// No runtime channel on React Native: remount with the fresh entitlement instead.
const [isSubscribed, setIsSubscribed] = useState(false);

async function presentSubscriptionFlow() {
  const purchased = await openPaywall();
  if (purchased) {
    // Changing isSubscribed remounts the trainer unlocked; the confirmed
    // profile is already persisted, so the user just taps Create my workout.
    setIsSubscribed(true);
  }
}

<KinestexSDK
  key={String(isSubscribed)}
  data={{ ...postData, customParameters: { ...postData.customParameters, isSubscribed } }}
  integrationOption={IntegrationOption.AI_TRAINER_CHAT}
  handleMessage={handleMessage}
/>

// No runtime channel on Flutter: remount with the fresh entitlement instead.
Future<void> presentSubscriptionFlow() async {
  final purchased = await openPaywall();
  if (purchased) {
    setState(() => isSubscribed = true); // rebuild the trainer view unlocked
  }
}

KinesteXAIFramework.createTrainerChatView(
  style: IStyle(style: 'dark'),
  isShowKinestex: showKinesteX,
  isLoading: isLoading,
  customParams: {"isSubscribed": isSubscribed},
  onMessageReceived: handleWebViewMessage,
);

function openPaywall() {
  showMyPaywallOverlay({
    onPurchased: () =>
      iframe.contentWindow.postMessage(
        JSON.stringify({ subscription_result: "purchased" }), // parked workout generates
        "https://ai.kinestex.com"
      ),
    onDismissed: () =>
      iframe.contentWindow.postMessage(
        JSON.stringify({ subscription_result: "dismissed" }), // trainer resumes, preview stays
        "https://ai.kinestex.com"
      ),
  });
}

// No runtime channel on React TS: remount with the fresh entitlement instead.
const [isSubscribed, setIsSubscribed] = useState(false);

async function presentSubscriptionFlow() {
  const purchased = await openPaywall();
  if (purchased) setIsSubscribed(true); // remounts the trainer unlocked
}

<KinestexSDK
  key={String(isSubscribed)}
  integrationOption={IntegrationOption.AI_TRAINER_CHAT}
  data={{ ...postData, customParameters: { ...postData.customParameters, isSubscribed } }}
  handleMessage={handleMessage}
/>