Scaling NIL Marketplace for College Athletes with Payment Processing

// backend/models/Athlete.ts
import { Entity, PrimaryGeneratedColumn, Column, OneToMany } from 'typeorm';
 
@Entity('athletes')
export class Athlete {
  @PrimaryGeneratedColumn('uuid')
  id: string;
 
  // Basic Info
  @Column()
  firstName: string;
 
  @Column()
  lastName: string;
 
  @Column({ unique: true })
  email: string;
 
  @Column()
  school: string;
 
  @Column()
  sport: string;
 
  @Column()
  position: string;
 
  @Column()
  gradYear: number;
 
  // Athletic Stats
  @Column('json', { nullable: true })
  stats: {
    height?: string;
    weight?: string;
    jerseyNumber?: string;
    seasonStats?: Record<string, any>;
  };
 
  // Social Media Metrics
  @Column('json')
  socialMedia: {
    instagram?: { handle: string; followers: number; engagement: number };
    twitter?: { handle: string; followers: number; engagement: number };
    tiktok?: { handle: string; followers: number; engagement: number };
  };
 
  // Verified Media
  @Column('simple-array', { nullable: true })
  photos: string[]; // S3 URLs
 
  @Column('simple-array', { nullable: true })
  videos: string[]; // S3 URLs for highlight reels
 
  // Bio & Interests
  @Column('text')
  bio: string;
 
  @Column('simple-array')
  interests: string[]; // ["fitness", "fashion", "gaming"]
 
  // NIL Preferences
  @Column('json')
  nilPreferences: {
    minDealValue: number;
    categories: string[]; // Types of deals interested in
    availability: string; // "weekends", "flexible", etc.
  };
 
  // Compliance
  @Column({ default: false })
  ncaaVerified: boolean;
 
  @Column({ nullable: true })
  guardianConsent: boolean; // For athletes under 18
 
  @Column('simple-array', { nullable: true })
  complianceDocuments: string[]; // S3 URLs
 
  // Analytics
  @Column({ type: 'decimal', precision: 10, scale: 2, default: 0 })
  totalEarnings: number;
 
  @Column({ default: 0 })
  dealsCompleted: number;
 
  @Column({ type: 'decimal', precision: 3, scale: 2, default: 0 })
  averageRating: number;
 
  // Stripe Connect
  @Column({ nullable: true })
  stripeConnectId: string;
 
  @Column({ default: false })
  stripeOnboarded: boolean;
 
  @Column()
  createdAt: Date;
 
  @Column()
  updatedAt: Date;
 
  // Relations
  @OneToMany(() => Deal, deal => deal.athlete)
  deals: Deal[];
}

// backend/services/matchmaking.service.ts
interface MatchScore {
  athleteId: string;
  businessId: string;
  totalScore: number;
  breakdown: {
    audienceAlignment: number;
    budgetFit: number;
    categoryMatch: number;
    geographicProximity: number;
    socialReach: number;
  };
}
 
export class MatchmakingService {
  /**
   * Find best athlete matches for a business
   * 
   * Scoring factors:
   * 1. Audience alignment (35%) - Demographics, interests
   * 2. Budget fit (25%) - Athlete's typical deal size vs business budget
   * 3. Category match (20%) - Business industry vs athlete interests
   * 4. Geographic proximity (10%) - Local deals preferred
   * 5. Social reach (10%) - Follower count and engagement
   */
  async findAthleteMatches(
    businessId: string,
    filters: {
      sport?: string;
      minFollowers?: number;
      maxBudget?: number;
      location?: string;
    },
    limit: number = 20
  ): Promise<MatchScore[]> {
    const business = await this.businessRepo.findOne({ where: { id: businessId } });
    
    // Get candidate athletes
    let query = this.athleteRepo.createQueryBuilder('athlete')
      .where('athlete.stripeOnboarded = :onboarded', { onboarded: true })
      .andWhere('athlete.ncaaVerified = :verified', { verified: true });
 
    if (filters.sport) {
      query = query.andWhere('athlete.sport = :sport', { sport: filters.sport });
    }
 
    if (filters.location) {
      query = query.andWhere('athlete.school LIKE :location', { 
        location: `%${filters.location}%` 
      });
    }
 
    const athletes = await query.getMany();
 
    // Score each athlete
    const scores = athletes.map(athlete => {
      const breakdown = {
        audienceAlignment: this.scoreAudienceAlignment(athlete, business),
        budgetFit: this.scoreBudgetFit(athlete, business, filters.maxBudget),
        categoryMatch: this.scoreCategoryMatch(athlete, business),
        geographicProximity: this.scoreGeography(athlete, business),
        socialReach: this.scoreSocialReach(athlete, filters.minFollowers)
      };
 
      const totalScore = 
        breakdown.audienceAlignment * 0.35 +
        breakdown.budgetFit * 0.25 +
        breakdown.categoryMatch * 0.20 +
        breakdown.geographicProximity * 0.10 +
        breakdown.socialReach * 0.10;
 
      return {
        athleteId: athlete.id,
        businessId: business.id,
        totalScore,
        breakdown
      };
    });
 
    // Sort by score and return top matches
    return scores
      .sort((a, b) => b.totalScore - a.totalScore)
      .slice(0, limit);
  }
 
  private scoreAudienceAlignment(athlete: Athlete, business: Business): number {
    // Compare athlete's audience demographics with business target audience
    const athleteAudience = athlete.socialMedia;
    const targetAudience = business.targetAudience;
 
    let score = 0;
 
    // Age alignment
    if (this.ageRangesOverlap(athleteAudience.ageRange, targetAudience.ageRange)) {
      score += 0.4;
    }
 
    // Interest alignment
    const commonInterests = athlete.interests.filter(interest =>
      targetAudience.interests.includes(interest)
    );
    score += (commonInterests.length / athlete.interests.length) * 0.4;
 
    // Location alignment (if business is local)
    if (targetAudience.geographic === 'local' && 
        athlete.school.includes(business.city)) {
      score += 0.2;
    }
 
    return Math.min(score, 1.0);
  }
 
  private scoreBudgetFit(
    athlete: Athlete,
    business: Business,
    maxBudget?: number
  ): number {
    // Estimate athlete's typical deal value based on followers
    const totalFollowers = 
      (athlete.socialMedia.instagram?.followers || 0) +
      (athlete.socialMedia.twitter?.followers || 0) +
      (athlete.socialMedia.tiktok?.followers || 0);
 
    // Industry standard: $10 per 1000 followers for micro-influencers
    const estimatedValue = (totalFollowers / 1000) * 10;
 
    const budget = maxBudget || business.typicalBudget;
 
    // Perfect match if budget is 80-120% of estimated value
    if (budget >= estimatedValue * 0.8 && budget <= estimatedValue * 1.2) {
      return 1.0;
    }
 
    // Partial match if within 50-150%
    if (budget >= estimatedValue * 0.5 && budget <= estimatedValue * 1.5) {
      return 0.6;
    }
 
    // Poor match otherwise
    return 0.3;
  }
 
  private scoreCategoryMatch(athlete: Athlete, business: Business): number {
    // Match business industry with athlete interests
    const relevantCategories = {
      'fitness': ['gym', 'nutrition', 'sportswear', 'health'],
      'fashion': ['clothing', 'accessories', 'beauty'],
      'food': ['restaurant', 'cafe', 'food delivery'],
      'tech': ['electronics', 'gaming', 'software'],
      'automotive': ['car dealership', 'auto repair']
    };
 
    let score = 0;
 
    for (const interest of athlete.interests) {
      const matchingCategories = relevantCategories[interest] || [];
      if (matchingCategories.includes(business.industry)) {
        score += 0.3;
      }
    }
 
    // Bonus if athlete has prior deals in this category
    const priorDeals = athlete.deals.filter(deal => 
      deal.business.industry === business.industry && 
      deal.status === 'completed'
    );
    
    if (priorDeals.length > 0) {
      score += 0.3;
    }
 
    return Math.min(score, 1.0);
  }
 
  private scoreGeography(athlete: Athlete, business: Business): number {
    // Local deals preferred (athlete and business in same city)
    if (athlete.school.toLowerCase().includes(business.city.toLowerCase())) {
      return 1.0;
    }
 
    // Regional deals (same state)
    if (athlete.school.includes(business.state)) {
      return 0.5;
    }
 
    // National deals still possible
    return 0.2;
  }
 
  private scoreSocialReach(athlete: Athlete, minFollowers?: number): number {
    const totalFollowers = 
      (athlete.socialMedia.instagram?.followers || 0) +
      (athlete.socialMedia.twitter?.followers || 0) +
      (athlete.socialMedia.tiktok?.followers || 0);
 
    if (!minFollowers) {
      // Normalize follower count (1k = 0, 100k = 1.0)
      return Math.min(totalFollowers / 100000, 1.0);
    }
 
    // If minimum specified, check if athlete meets it
    return totalFollowers >= minFollowers ? 1.0 : 0.0;
  }
 
  private ageRangesOverlap(
    range1: { min: number; max: number },
    range2: { min: number; max: number }
  ): boolean {
    return range1.max >= range2.min && range2.max >= range1.min;
  }
}

// backend/services/payment.service.ts
import Stripe from 'stripe';
 
const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!, {
  apiVersion: '2023-10-16'
});
 
export class PaymentService {
  /**
   * Create Stripe Connect account for athlete
   * 
   * Athletes need Connect accounts to receive payouts
   */
  async createAthleteConnectAccount(athleteId: string): Promise<string> {
    const athlete = await this.athleteRepo.findOne({ where: { id: athleteId } });
 
    // Create Express Connect account
    const account = await stripe.accounts.create({
      type: 'express',
      country: 'US',
      email: athlete.email,
      capabilities: {
        card_payments: { requested: true },
        transfers: { requested: true }
      },
      business_type: 'individual',
      individual: {
        first_name: athlete.firstName,
        last_name: athlete.lastName,
        email: athlete.email
      }
    });
 
    // Save to database
    athlete.stripeConnectId = account.id;
    await this.athleteRepo.save(athlete);
 
    return account.id;
  }
 
  /**
   * Generate onboarding link for athlete
   * 
   * Athletes complete Stripe onboarding to verify identity and banking
   */
  async generateOnboardingLink(athleteId: string): Promise<string> {
    const athlete = await this.athleteRepo.findOne({ where: { id: athleteId } });
 
    const accountLink = await stripe.accountLinks.create({
      account: athlete.stripeConnectId!,
      refresh_url: `${process.env.FRONTEND_URL}/onboarding/refresh`,
      return_url: `${process.env.FRONTEND_URL}/onboarding/complete`,
      type: 'account_onboarding'
    });
 
    return accountLink.url;
  }
 
  /**
   * Process deal payment with split
   * 
   * Flow:
   * 1. Business pays total amount
   * 2. Platform takes fee (15%)
   * 3. Athlete receives net amount (85%)
   */
  async processDealPayment(dealId: string): Promise<{ paymentIntentId: string; transferId: string }> {
    const deal = await this.dealRepo.findOne({
      where: { id: dealId },
      relations: ['athlete', 'business']
    });
 
    const totalAmount = deal.amount * 100; // Convert to cents
    const platformFee = Math.floor(totalAmount * 0.15); // 15% platform fee
    const athleteAmount = totalAmount - platformFee;
 
    // Create payment intent (charge business)
    const paymentIntent = await stripe.paymentIntents.create({
      amount: totalAmount,
      currency: 'usd',
      customer: deal.business.stripeCustomerId,
      payment_method: deal.business.defaultPaymentMethod,
      off_session: true,
      confirm: true,
      description: `NIL Deal: ${deal.title}`,
      metadata: {
        dealId: deal.id,
        athleteId: deal.athlete.id,
        businessId: deal.business.id
      }
    });
 
    // Transfer to athlete (after charge succeeds)
    const transfer = await stripe.transfers.create({
      amount: athleteAmount,
      currency: 'usd',
      destination: deal.athlete.stripeConnectId!,
      description: `Payout for deal: ${deal.title}`,
      metadata: {
        dealId: deal.id
      }
    });
 
    // Update deal status
    deal.paymentStatus = 'paid';
    deal.paymentIntentId = paymentIntent.id;
    deal.transferId = transfer.id;
    deal.platformFee = platformFee / 100;
    deal.athleteNet = athleteAmount / 100;
    await this.dealRepo.save(deal);
 
    // Update athlete earnings
    deal.athlete.totalEarnings += athleteAmount / 100;
    deal.athlete.dealsCompleted += 1;
    await this.athleteRepo.save(deal.athlete);
 
    return {
      paymentIntentId: paymentIntent.id,
      transferId: transfer.id
    };
  }
 
  /**
   * Handle payment escrow for milestone-based deals
   * 
   * Some deals require payment to be held until deliverables completed
   */
  async createEscrowPayment(
    dealId: string,
    milestones: Array<{ description: string; percentage: number }>
  ): Promise<string> {
    const deal = await this.dealRepo.findOne({
      where: { id: dealId },
      relations: ['athlete', 'business']
    });
 
    const totalAmount = deal.amount * 100;
 
    // Charge business but hold funds
    const paymentIntent = await stripe.paymentIntents.create({
      amount: totalAmount,
      currency: 'usd',
      customer: deal.business.stripeCustomerId,
      payment_method: deal.business.defaultPaymentMethod,
      capture_method: 'manual', // Hold funds until capture
      confirm: true,
      description: `Escrow for NIL Deal: ${deal.title}`
    });
 
    // Store milestones in database
    deal.paymentStructure = 'escrow';
    deal.milestones = milestones;
    deal.paymentIntentId = paymentIntent.id;
    deal.paymentStatus = 'escrowed';
    await this.dealRepo.save(deal);
 
    return paymentIntent.id;
  }
 
  /**
   * Release milestone payment
   */
  async releaseMilestonePayment(
    dealId: string,
    milestoneIndex: number
  ): Promise<void> {
    const deal = await this.dealRepo.findOne({
      where: { id: dealId },
      relations: ['athlete']
    });
 
    const milestone = deal.milestones[milestoneIndex];
    const releaseAmount = Math.floor(deal.amount * milestone.percentage * 100);
 
    // Capture payment
    await stripe.paymentIntents.capture(deal.paymentIntentId!, {
      amount_to_capture: releaseAmount
    });
 
    // Transfer to athlete
    const transfer = await stripe.transfers.create({
      amount: Math.floor(releaseAmount * 0.85), // After platform fee
      currency: 'usd',
      destination: deal.athlete.stripeConnectId!,
      description: `Milestone ${milestoneIndex + 1}: ${milestone.description}`
    });
 
    // Update milestone status
    deal.milestones[milestoneIndex].status = 'paid';
    deal.milestones[milestoneIndex].transferId = transfer.id;
    await this.dealRepo.save(deal);
  }
}

// backend/services/contract.service.ts
import { DocuSign } from 'docusign-esign';
import fs from 'fs';
import path from 'path';
import Handlebars from 'handlebars';
 
export class ContractService {
  private docusignClient: DocuSign.ApiClient;
 
  constructor() {
    this.docusignClient = new DocuSign.ApiClient();
    this.docusignClient.setBasePath(process.env.DOCUSIGN_BASE_PATH!);
    this.docusignClient.addDefaultHeader(
      'Authorization',
      `Bearer ${process.env.DOCUSIGN_ACCESS_TOKEN}`
    );
  }
 
  /**
   * Generate contract from template
   * 
   * Template includes:
   * - Deal terms (compensation, deliverables, timeline)
   * - NCAA compliance clauses
   * - Rights granted (image usage, social media posts, etc.)
   * - Termination conditions
   */
  async generateContract(dealId: string): Promise<string> {
    const deal = await this.dealRepo.findOne({
      where: { id: dealId },
      relations: ['athlete', 'business']
    });
 
    // Load contract template
    const templatePath = path.join(__dirname, '../templates/nil-contract.html');
    const templateSource = fs.readFileSync(templatePath, 'utf8');
    const template = Handlebars.compile(templateSource);
 
    // Populate template with deal data
    const contractHtml = template({
      // Parties
      athleteName: `${deal.athlete.firstName} ${deal.athlete.lastName}`,
      athleteSchool: deal.athlete.school,
      businessName: deal.business.name,
      businessAddress: deal.business.address,
      
      // Deal Terms
      dealTitle: deal.title,
      dealDescription: deal.description,
      compensation: deal.amount.toFixed(2),
      startDate: deal.startDate.toLocaleDateString(),
      endDate: deal.endDate.toLocaleDateString(),
      
      // Deliverables
      deliverables: deal.deliverables,
      
      // Rights Granted
      rightsGranted: deal.rightsGranted,
      
      // Usage Terms
      usageTerms: {
        socialMediaPosts: deal.termsOfUse.socialMediaPosts,
        photoshoots: deal.termsOfUse.photoshoots,
        appearances: deal.termsOfUse.appearances,
        exclusivity: deal.termsOfUse.exclusivity
      },
      
      // Compliance
      ncaaCompliance: this.generateComplianceClause(deal),
      
      // Today's date
      contractDate: new Date().toLocaleDateString()
    });
 
    // Convert HTML to PDF
    const pdfBuffer = await this.htmlToPdf(contractHtml);
 
    // Upload to S3
    const contractUrl = await this.uploadToS3(
      pdfBuffer,
      `contracts/${deal.id}/contract.pdf`
    );
 
    // Save to database
    deal.contractUrl = contractUrl;
    deal.contractGeneratedAt = new Date();
    await this.dealRepo.save(deal);
 
    return contractUrl;
  }
 
  /**
   * Send contract for e-signature via DocuSign
   */
  async sendForSignature(dealId: string): Promise<string> {
    const deal = await this.dealRepo.findOne({
      where: { id: dealId },
      relations: ['athlete', 'business']
    });
 
    const envelopeDefinition = {
      emailSubject: `NIL Deal Contract: ${deal.title}`,
      documents: [{
        documentBase64: await this.getContractBase64(deal.contractUrl),
        name: 'NIL Agreement',
        fileExtension: 'pdf',
        documentId: '1'
      }],
      recipients: {
        signers: [
          {
            email: deal.athlete.email,
            name: `${deal.athlete.firstName} ${deal.athlete.lastName}`,
            recipientId: '1',
            routingOrder: '1',
            tabs: {
              signHereTabs: [{
                documentId: '1',
                pageNumber: '1',
                xPosition: '100',
                yPosition: '600'
              }]
            }
          },
          {
            email: deal.business.email,
            name: deal.business.name,
            recipientId: '2',
            routingOrder: '2',
            tabs: {
              signHereTabs: [{
                documentId: '1',
                pageNumber: '1',
                xPosition: '300',
                yPosition: '600'
              }]
            }
          }
        ]
      },
      status: 'sent'
    };
 
    const envelopesApi = new DocuSign.EnvelopesApi(this.docusignClient);
    const envelope = await envelopesApi.createEnvelope(
      process.env.DOCUSIGN_ACCOUNT_ID!,
      { envelopeDefinition }
    );
 
    // Save envelope ID
    deal.docusignEnvelopeId = envelope.envelopeId;
    deal.contractStatus = 'pending_signatures';
    await this.dealRepo.save(deal);
 
    return envelope.envelopeId!;
  }
 
  /**
   * Generate NCAA compliance clause based on athlete's school
   */
  private generateComplianceClause(deal: Deal): string {
    const baseClause = `
      This agreement is made in compliance with NCAA Name, Image, and Likeness (NIL) regulations.
      The Athlete represents that:
      1. They are eligible to enter into NIL agreements under NCAA and state law
      2. This agreement does not violate any institutional policies
      3. This agreement is not contingent on athletic performance or enrollment
      4. The compensation is for use of their NIL only
    `;
 
    // Add state-specific clauses
    const stateRules = this.getStateSpecificRules(deal.athlete.school);
    
    return baseClause + '\n\n' + stateRules;
  }
 
  private getStateSpecificRules(school: string): string {
    // State-specific NIL rules
    const stateRules = {
      'California': 'Per California SB 206, athlete may use agents and retain counsel.',
      'Florida': 'Per Florida HB 7003, athlete must complete financial literacy course.',
      'Texas': 'Per Texas HB 1435, schools may facilitate NIL opportunities.',
      // ... more states
    };
 
    // Detect state from school name (simplified)
    for (const [state, rule] of Object.entries(stateRules)) {
      if (school.toLowerCase().includes(state.toLowerCase())) {
        return rule;
      }
    }
 
    return '';
  }
}

// backend/services/compliance.service.ts
export class ComplianceService {
  /**
   * Check if deal complies with NCAA rules
   * 
   * NCAA Restrictions:
   * - No payment contingent on performance
   * - No payment contingent on enrollment decision
   * - School logos/uniforms restricted
   * - Must report deals >$600/year (IRS)
   */
  async validateDealCompliance(dealId: string): Promise<{
    compliant: boolean;
    issues: string[];
    warnings: string[];
  }> {
    const deal = await this.dealRepo.findOne({
      where: { id: dealId },
      relations: ['athlete', 'business']
    });
 
    const issues: string[] = [];
    const warnings: string[] = [];
 
    // Check 1: No performance-based compensation
    if (this.hasPerformanceClause(deal.description)) {
      issues.push('Deal appears to include performance-based compensation (NCAA violation)');
    }
 
    // Check 2: No enrollment incentives
    if (this.hasEnrollmentIncentive(deal.description)) {
      issues.push('Deal appears tied to enrollment decision (NCAA violation)');
    }
 
    // Check 3: School logo usage
    if (deal.termsOfUse.schoolLogoUsage && !deal.schoolApproval) {
      issues.push('School logo usage requires institutional approval');
    }
 
    // Check 4: Athlete age (minors need guardian consent)
    const athleteAge = this.calculateAge(deal.athlete.birthdate);
    if (athleteAge < 18 && !deal.athlete.guardianConsent) {
      issues.push('Athlete is minor - guardian consent required');
    }
 
    // Check 5: Compensation limits (state-specific)
    const stateLimit = this.getStateCompensationLimit(deal.athlete.school);
    if (stateLimit && deal.amount > stateLimit) {
      warnings.push(`Deal exceeds state recommended limit of $${stateLimit}`);
    }
 
    // Check 6: Required disclosures
    if (deal.amount >= 600 && !deal.taxFormCompleted) {
      warnings.push('Deal requires W-9 form for IRS reporting');
    }
 
    // Check 7: Exclusivity conflicts
    const conflictingDeals = await this.findConflictingDeals(deal);
    if (conflictingDeals.length > 0) {
      warnings.push(`Potential exclusivity conflict with ${conflictingDeals.length} existing deals`);
    }
 
    return {
      compliant: issues.length === 0,
      issues,
      warnings
    };
  }
 
  private hasPerformanceClause(text: string): boolean {
    const performanceKeywords = [
      'if athlete scores',
      'based on performance',
      'contingent on wins',
      'per touchdown',
      'performance bonus'
    ];
 
    return performanceKeywords.some(keyword =>
      text.toLowerCase().includes(keyword)
    );
  }
 
  private hasEnrollmentIncentive(text: string): boolean {
    const enrollmentKeywords = [
      'if athlete commits',
      'upon enrollment',
      'signing with university',
      'choosing our school'
    ];
 
    return enrollmentKeywords.some(keyword =>
      text.toLowerCase().includes(keyword)
    );
  }
 
  private async findConflictingDeals(deal: Deal): Promise<Deal[]> {
    // Find active deals with exclusivity clauses in same category
    if (!deal.termsOfUse.exclusivity) {
      return [];
    }
 
    return await this.dealRepo.find({
      where: {
        athleteId: deal.athleteId,
        status: 'active',
        category: deal.category,
        'termsOfUse.exclusivity': true
      }
    });
  }
}

// frontend/components/Dashboard.tsx
import React, { useEffect, useState } from 'react';
import { Line, Bar, Pie } from 'react-chartjs-2';
import axios from 'axios';
 
interface DashboardMetrics {
  totalEarnings: number;
  activeDeals: number;
  completedDeals: number;
  pendingDeals: number;
  avgDealValue: number;
  topCategories: { category: string; count: number; earnings: number }[];
  monthlyEarnings: { month: string; amount: number }[];
  engagementMetrics: {
    profileViews: number;
    dealInquiries: number;
    conversionRate: number;
  };
}
 
export const AthleteDashboard: React.FC<{ athleteId: string }> = ({ athleteId }) => {
  const [metrics, setMetrics] = useState<DashboardMetrics | null>(null);
  const [loading, setLoading] = useState(true);
 
  useEffect(() => {
    loadDashboardData();
  }, [athleteId]);
 
  const loadDashboardData = async () => {
    try {
      const response = await axios.get(`/api/athletes/${athleteId}/dashboard`);
      setMetrics(response.data);
    } catch (error) {
      console.error('Failed to load dashboard:', error);
    } finally {
      setLoading(false);
    }
  };
 
  if (loading || !metrics) {
    return <div>Loading...</div>;
  }
 
  return (
    <div className="dashboard p-8 bg-gray-50 min-h-screen">
      <h1 className="text-3xl font-bold mb-8">NIL Dashboard</h1>
 
      {/* Summary Cards */}
      <div className="grid grid-cols-4 gap-6 mb-8">
        <div className="bg-white rounded-lg shadow p-6">
          <p className="text-gray-600 text-sm mb-2">Total Earnings</p>
          <p className="text-3xl font-bold text-green-600">
            ${metrics.totalEarnings.toLocaleString()}
          </p>
        </div>
 
        <div className="bg-white rounded-lg shadow p-6">
          <p className="text-gray-600 text-sm mb-2">Active Deals</p>
          <p className="text-3xl font-bold text-blue-600">
            {metrics.activeDeals}
          </p>
        </div>
 
        <div className="bg-white rounded-lg shadow p-6">
          <p className="text-gray-600 text-sm mb-2">Avg Deal Value</p>
          <p className="text-3xl font-bold text-purple-600">
            ${metrics.avgDealValue.toLocaleString()}
          </p>
        </div>
 
        <div className="bg-white rounded-lg shadow p-6">
          <p className="text-gray-600 text-sm mb-2">Conversion Rate</p>
          <p className="text-3xl font-bold text-orange-600">
            {metrics.engagementMetrics.conversionRate.toFixed(1)}%
          </p>
        </div>
      </div>
 
      {/* Charts */}
      <div className="grid grid-cols-2 gap-6">
        {/* Monthly Earnings */}
        <div className="bg-white rounded-lg shadow p-6">
          <h2 className="text-xl font-semibold mb-4">Monthly Earnings</h2>
          <Line
            data={{
              labels: metrics.monthlyEarnings.map(m => m.month),
              datasets: [{
                label: 'Earnings',
                data: metrics.monthlyEarnings.map(m => m.amount),
                borderColor: 'rgb(75, 192, 192)',
                backgroundColor: 'rgba(75, 192, 192, 0.2)',
                tension: 0.4
              }]
            }}
            options={{
              responsive: true,
              scales: {
                y: {
                  beginAtZero: true,
                  ticks: {
                    callback: (value) => `$${value}`
                  }
                }
              }
            }}
          />
        </div>
 
        {/* Top Categories */}
        <div className="bg-white rounded-lg shadow p-6">
          <h2 className="text-xl font-semibold mb-4">Deals by Category</h2>
          <Bar
            data={{
              labels: metrics.topCategories.map(c => c.category),
              datasets: [{
                label: 'Earnings',
                data: metrics.topCategories.map(c => c.earnings),
                backgroundColor: [
                  'rgba(255, 99, 132, 0.6)',
                  'rgba(54, 162, 235, 0.6)',
                  'rgba(255, 206, 86, 0.6)',
                  'rgba(75, 192, 192, 0.6)',
                  'rgba(153, 102, 255, 0.6)'
                ]
              }]
            }}
            options={{
              responsive: true,
              scales: {
                y: {
                  beginAtZero: true,
                  ticks: {
                    callback: (value) => `$${value}`
                  }
                }
              }
            }}
          />
        </div>
      </div>
    </div>
  );
};

// Suggest counter-offers based on market data
const suggestedCounterOffer = await analyzeMarketRate(
  athleteFollowers,
  industry,
  dealType
);
 
if (initialOffer < suggestedCounterOffer * 0.8) {
  alert(`This offer is 20% below market rate. Suggest: $${suggestedCounterOffer}`);
}

// Monitor athlete's branded posts
const postMetrics = await instagram.getPostMetrics(postId);
 
const roi = {
  impressions: postMetrics.impressions,
  engagement: postMetrics.likes + postMetrics.comments,
  costPerEngagement: dealAmount / postMetrics.engagement,
  estimatedReach: postMetrics.reach
};

const teamDeal = await createGroupDeal({
  businessId: 'acme-corp',
  sport: 'basketball',
  school: 'University of Illinois',
  totalBudget: 50000,
  athleteCount: 12
});
 
// Split payment across athletes based on social reach
const splits = calculateSmartSplit(teamDeal.athletes, teamDeal.totalBudget);