// POST /api/v1/billing/checkout
// Body: { tier: 'maker' | 'pro' | 'agency', isYearly?: boolean, promoCode?: string }
async function createCheckout(userId: string, tier: string, isYearly = false, promoCode?: string) {
  const session = await stripeService.createCheckoutSession({
    userId,
    email: user.email,
    tier,
    isYearly,
    promoCode,
    trialDays: 3, // ← Free trial before first charge (0 to disable)
  })

  return session.url
}

// packages/api-gateway/src/routes/billing.ts
const session = await stripeService.createCheckoutSession({
  userId,
  email,
  tier: tier as SubscriptionTier,
  isYearly,
  promoCode,
  trialDays: 3, // ← Change this value (0 to disable trials)
});

// Deduct credit for generation
async function useCredit(userId: string, amount: number = 1) {
  // Check balance
  const user = await getUser(userId);
  
  // Check daily reset
  if (new Date() > user.credits_reset_at) {
    await resetDailyCredits(userId);
  }
  
  if (user.credits_remaining < amount) {
    throw new InsufficientCreditsError();
  }
  
  // Deduct and log
  await db.query(`
    UPDATE app_users SET credits_remaining = credits_remaining - $1, lifetime_credits_used = lifetime_credits_used + $1
    WHERE id = $2
  `, [amount, userId]);
  
  await logCreditTransaction(userId, -amount, 'generation');
}

// POST /api/v1/billing/lifetime-checkout
async function createLifetimeLicenseCheckout(promoCode?: string) {
  let priceId = process.env.STRIPE_PRICE_LIFETIME!;

  // Apply promo code for early bird pricing
  const promotionCode = promoCode === 'EARLYSYNTH'
    ? await getStripePromotionCode('EARLYSYNTH')
    : undefined;

  const session = await stripe.checkout.sessions.create({
    mode: 'payment', // One-time payment, not subscription
    payment_method_types: ['card'],
    line_items: [{ price: priceId, quantity: 1 }],
    success_url: `${FRONTEND_URL}/?license=success&session_id={CHECKOUT_SESSION_ID}`,
    cancel_url: `${FRONTEND_URL}/?license=cancelled`,
    metadata: {
      type: 'lifetime_license', // Critical for webhook routing
    },
    ...(promotionCode && { discounts: [{ promotion_code: promotionCode.id }] }),
  });

  return session.url;
}

// In stripe-webhooks.ts
async function handleCheckoutCompleted(session: Stripe.Checkout.Session) {
  if (session.metadata?.type === 'lifetime_license') {
    const { customer_email, id: sessionId, amount_total } = session;

    // 1. Create license record
    await db.query(`
      INSERT INTO lifetime_licenses (
        stripe_session_id,
        stripe_customer_id,
        email,
        amount_paid_cents,
        github_access_status
      ) VALUES ($1, $2, $3, $4, 'pending')
      ON CONFLICT (stripe_session_id) DO NOTHING
    `, [sessionId, session.customer, customer_email, amount_total]);

    // 2. Send welcome email with license access link
    const emailService = getEmailService();
    await emailService.sendLifetimeWelcomeEmail({
      to: customer_email!,
      sessionId,
      licenseAccessUrl: `${FRONTEND_URL}/license-access?session=${sessionId}`,
    });

    // 3. Update email sent timestamp
    await db.query(`
      UPDATE lifetime_licenses
      SET welcome_email_sent_at = NOW()
      WHERE stripe_session_id = $1
    `, [sessionId]);

    fastify.log.info({ email: customer_email, sessionId }, 'Lifetime license purchased');
  }
}

// POST /api/v1/license-access/submit-username
async function submitGithubUsername(sessionId: string, githubUsername: string) {
  // 1. Validate license exists
  const license = await db.query(
    'SELECT id, email FROM lifetime_licenses WHERE stripe_session_id = $1',
    [sessionId]
  );

  if (!license.rows.length) {
    throw new NotFoundError('License not found');
  }

  // 2. Validate GitHub username exists
  const githubService = new GitHubOrgService(fastify);
  const validation = await githubService.validateUsername(githubUsername);

  if (!validation.valid) {
    throw new BadRequestError(validation.error || 'Invalid GitHub username');
  }

  // 3. Update license with username
  await db.query(`
    UPDATE lifetime_licenses
    SET github_username = $1,
        github_username_submitted_at = NOW(),
        github_access_status = 'username_submitted'
    WHERE stripe_session_id = $2
  `, [githubUsername, sessionId]);

  // 4. Send GitHub invitation
  const { email } = license.rows[0];
  const invitation = await githubService.inviteToOrganization(githubUsername, email);

  if (!invitation.success) {
    throw new InternalServerError('Failed to send GitHub invitation');
  }

  // 5. Update status and send confirmation email
  await db.query(`
    UPDATE lifetime_licenses
    SET github_access_status = 'invited',
        github_invitation_sent_at = NOW()
    WHERE stripe_session_id = $1
  `, [sessionId]);

  await emailService.sendLifetimeInvitationSentEmail({
    to: email,
    githubUsername,
  });

  return { success: true, message: 'GitHub invitation sent!' };
}

import { Octokit } from '@octokit/rest';

export class GitHubOrgService {
  private octokit: Octokit;
  private orgName = process.env.GITHUB_ORG_NAME || 'manicinc';
  private teamSlug = process.env.GITHUB_TEAM_SLUG || 'synthstack-pro';

  constructor(fastify: FastifyInstance) {
    this.octokit = new Octokit({
      auth: process.env.GH_PAT
    });
  }

  async validateUsername(username: string) {
    try {
      await this.octokit.users.getByUsername({ username });
      return { valid: true };
    } catch (error: any) {
      if (error.status === 404) {
        return { valid: false, error: 'GitHub username not found' };
      }
      return { valid: false, error: 'Failed to validate username' };
    }
  }

  async inviteToOrganization(username: string, email: string) {
    try {
      const userId = await this.getUserId(username);
      const teamId = await this.getTeamId();

      await this.octokit.orgs.createInvitation({
        org: this.orgName,
        invitee_id: userId,
        role: 'member', // Read-only access
        team_ids: [teamId],
      });

      return { success: true };
    } catch (error: any) {
      return { success: false, error: error.message };
    }
  }

  async checkMembershipStatus(username: string) {
    try {
      await this.octokit.orgs.checkMembershipForUser({
        org: this.orgName,
        username,
      });
      return 'active';
    } catch (error: any) {
      if (error.status === 404) {
        const invitations = await this.octokit.orgs.listPendingInvitations({
          org: this.orgName,
        });
        const hasPending = invitations.data.some(
          inv => inv.login?.toLowerCase() === username.toLowerCase()
        );
        return hasPending ? 'pending' : 'none';
      }
      throw error;
    }
  }

  private async getUserId(username: string): Promise<number> {
    const { data } = await this.octokit.users.getByUsername({ username });
    return data.id;
  }

  private async getTeamId(): Promise<number> {
    const { data } = await this.octokit.teams.getByName({
      org: this.orgName,
      team_slug: this.teamSlug,
    });
    return data.id;
  }
}