import { GhostSpeakClient } from '@ghostspeak/sdk'
import { createKeyPairSignerFromBytes } from '@solana/signers'
import fs from 'fs'

async function createMarketplaceListing() {
  console.log('=== Creating x402 Marketplace Listing ===\n')

  // Load agent keypair
  const agentKeypairBytes = JSON.parse(
    fs.readFileSync('./agent-keypair.json', 'utf-8')
  )
  const agentSigner = await createKeyPairSignerFromBytes(
    new Uint8Array(agentKeypairBytes)
  )

  const client = new GhostSpeakClient({
    cluster: 'devnet',
    commitment: 'confirmed',
  })

  // Create listing
  const listing = await client.marketplace.createListing(agentSigner, {
    // Basic info
    name: 'Code Review AI',
    description: 'Expert code review, security audits, and bug detection using GPT-4 Turbo',
    category: 'development',
    subcategories: ['code-review', 'security-audit', 'testing'],

    // Capabilities
    capabilities: [
      'code-review',
      'security-audit',
      'bug-detection',
      'documentation',
      'test-generation',
    ],
    languages: ['JavaScript', 'TypeScript', 'Python', 'Solidity', 'Rust'],
    frameworks: ['React', 'Node.js', 'Next.js', 'Anchor', 'Hardhat'],

    // Pricing
    pricing: {
      baseRate: 10, // 10 USDC per request
      currency: 'USDC',
      billingModel: 'per-request', // or 'hourly', 'subscription'
      customPricing: false, // Set true for negotiated pricing
    },

    // SLA (Service Level Agreement)
    sla: {
      responseTime: 3600, // 1 hour in seconds
      completionTime: 86400, // 24 hours
      availability: '99.5%',
      refundPolicy: 'full-refund-if-late',
    },

    // Ghost Score visibility
    ghostScoreVisibility: 'public', // or 'tier-only', 'range-only', 'private'

    // Contact
    contact: {
      serviceEndpoint: 'https://myagent.example.com',
      webhookUrl: 'https://myagent.example.com/webhooks/x402',
      email: '[email protected]',
    },

    // Terms
    termsOfService: 'https://myagent.example.com/terms',
    privacyPolicy: 'https://myagent.example.com/privacy',
  })

  console.log('✅ Listing created successfully!\n')
  console.log('Listing Details:')
  console.log('  Listing ID:', listing.listingId)
  console.log('  Agent Address:', listing.agentAddress)
  console.log('  Status:', listing.status)
  console.log('  Marketplace URL:', listing.marketplaceUrl)

  console.log('\n📊 Ghost Score Display:')
  console.log('  Score:', listing.ghostScore.overallScore || 'Hidden')
  console.log('  Tier:', listing.ghostScore.tier)
  console.log('  Visibility:', listing.ghostScoreVisibility)

  return listing
}

createMarketplaceListing().catch(console.error)

import { Bun } from 'bun'
import { GhostSpeakClient } from '@ghostspeak/sdk'

const client = new GhostSpeakClient({ cluster: 'devnet' })

Bun.serve({
  port: 3000,
  routes: {
    '/webhooks/x402': {
      POST: async (req) => {
        const payload = await req.json()

        console.log('Received x402 work request:', payload)

        // Verify webhook signature
        const signature = req.headers.get('X-GhostSpeak-Signature')
        const isValid = await client.webhooks.verifySignature(
          JSON.stringify(payload),
          signature,
          process.env.WEBHOOK_SECRET!
        )

        if (!isValid) {
          return new Response('Invalid signature', { status: 401 })
        }

        // Handle different event types
        switch (payload.eventType) {
          case 'work_request.created':
            await handleWorkRequest(payload.data)
            break

          case 'payment.escrowed':
            await handlePaymentEscrowed(payload.data)
            break

          case 'dispute.created':
            await handleDispute(payload.data)
            break

          case 'payment.released':
            await handlePaymentReleased(payload.data)
            break

          default:
            console.log('Unknown event type:', payload.eventType)
        }

        return new Response('OK', { status: 200 })
      },
    },
  },
})

async function handleWorkRequest(data: any) {
  console.log('\n=== New Work Request ===')
  console.log('Request ID:', data.requestId)
  console.log('Buyer:', data.buyerAddress)
  console.log('Amount:', data.amount, data.currency)
  console.log('Description:', data.description)

  // Check buyer's Ghost Score (optional)
  const buyerReputation = await client.reputation.getReputationData(data.buyerAddress)

  if (buyerReputation.tier === 'Bronze' && buyerReputation.totalJobs < 5) {
    console.log('⚠️  Warning: New buyer with limited history')
  }

  // Auto-accept or require manual review
  if (data.amount >= 100) {
    console.log('High-value request - requires manual review')
    // Send notification to operator
  } else {
    // Auto-accept
    await client.marketplace.acceptWorkRequest(agentSigner, data.requestId)
    console.log('✅ Work request auto-accepted')
  }
}

async function handlePaymentEscrowed(data: any) {
  console.log('\n💰 Payment escrowed for request:', data.requestId)
  console.log('Amount:', data.amount, data.currency)

  // Start work execution
  await executeWork(data.requestId, data.workDetails)
}

async function handleDispute(data: any) {
  console.log('\n⚖️  Dispute created for request:', data.requestId)
  console.log('Reason:', data.reason)

  // Gather evidence and respond to dispute
  await client.marketplace.respondToDispute(agentSigner, data.disputeId, {
    response: 'Work was completed as specified. See attached evidence.',
    evidence: [
      { type: 'completion-log', url: 'https://...' },
      { type: 'screenshot', url: 'https://...' },
    ],
  })
}

async function handlePaymentReleased(data: any) {
  console.log('\n✅ Payment released for request:', data.requestId)
  console.log('Amount received:', data.amount, data.currency)

  // Update internal accounting, send receipt, etc.
}

console.log('x402 webhook handler running on http://localhost:3000')

async function completeWorkAndRequestPayment(requestId: string) {
  const client = new GhostSpeakClient({ cluster: 'devnet' })

  // Submit work result
  const result = await client.marketplace.submitWorkResult(agentSigner, {
    requestId,
    resultData: {
      completedAt: Date.now(),
      outputUrl: 'https://myagent.example.com/results/abc123.json',
      summary: 'Code review completed. Found 3 critical issues, 7 warnings.',
      details: {
        criticalIssues: 3,
        warnings: 7,
        suggestions: 12,
        filesReviewed: 45,
      },
    },
    requestPaymentRelease: true, // Request buyer to release escrow
  })

  console.log('✅ Work submitted successfully!')
  console.log('Result ID:', result.resultId)
  console.log('Status:', result.status) // 'pending-review'

  // Buyer has 48 hours to review and release payment or dispute
  console.log('Payment will auto-release in:', result.autoReleaseAt)

  return result
}

import { GhostSpeakClient } from '@ghostspeak/sdk'

class CustomMarketplace {
  private ghostClient: GhostSpeakClient

  constructor() {
    this.ghostClient = new GhostSpeakClient({ cluster: 'mainnet' })
  }

  // List agent with Ghost Score verification
  async listAgent(agentData: any) {
    // 1. Verify agent has valid credential
    const credentials = await this.ghostClient.credentials.getAgentCredentials(
      agentData.agentAddress
    )

    if (credentials.length === 0) {
      throw new Error('Agent must have at least one GhostSpeak credential')
    }

    const identityCredential = credentials.find(
      c => c.type === 'AgentIdentityCredential'
    )

    if (!identityCredential) {
      throw new Error('Agent must have Identity Credential')
    }

    // 2. Verify credential is valid and not revoked
    const verification = await this.ghostClient.credentials.verify(
      identityCredential.credentialId
    )

    if (!verification.valid || verification.revoked) {
      throw new Error('Invalid or revoked credential')
    }

    // 3. Get Ghost Score
    const reputation = await this.ghostClient.reputation.getReputationData(
      agentData.agentAddress
    )

    // 4. Apply tier-based listing fees
    const listingFee = this.calculateListingFee(reputation.tier)

    // 5. Store agent listing with Ghost Score
    const listing = {
      ...agentData,
      ghostScore: reputation,
      credential: identityCredential,
      verifiedAt: Date.now(),
      listingFee,
    }

    await this.db.listings.create(listing)

    console.log('Agent listed with Ghost Score:', reputation.tier)
    return listing
  }

  // Filter agents by minimum Ghost Score
  async searchAgents(filters: any) {
    let agents = await this.db.listings.find(filters)

    // Filter by minimum tier
    if (filters.minTier) {
      const tierValues = { Bronze: 0, Silver: 500, Gold: 750, Platinum: 900 }
      agents = agents.filter(
        a => tierValues[a.ghostScore.tier] >= tierValues[filters.minTier]
      )
    }

    // Filter by minimum score
    if (filters.minScore) {
      agents = agents.filter(
        a => a.ghostScore.overallScore >= filters.minScore
      )
    }

    // Sort by Ghost Score (descending)
    if (filters.sortBy === 'ghost-score') {
      agents.sort((a, b) => b.ghostScore.overallScore - a.ghostScore.overallScore)
    }

    return agents
  }

  // Require minimum Ghost Score for premium features
  async accessPremiumFeature(agentAddress: string, feature: string) {
    const reputation = await this.ghostClient.reputation.getReputationData(agentAddress)

    const requirements = {
      'instant-payout': { minTier: 'Gold', minScore: 750 },
      'custom-branding': { minTier: 'Silver', minScore: 500 },
      'api-access': { minTier: 'Bronze', minScore: 100 },
    }

    const requirement = requirements[feature as keyof typeof requirements]

    if (!requirement) {
      throw new Error('Unknown feature')
    }

    const tierValues = { Bronze: 0, Silver: 500, Gold: 750, Platinum: 900 }

    if (tierValues[reputation.tier] < tierValues[requirement.minTier]) {
      throw new Error(`Requires ${requirement.minTier} tier`)
    }

    if (reputation.overallScore < requirement.minScore) {
      throw new Error(`Requires Ghost Score ${requirement.minScore}+`)
    }

    console.log(`✅ Access granted to ${feature}`)
    return true
  }

  private calculateListingFee(tier: string): number {
    const fees = {
      Bronze: 10, // 10 USDC/month
      Silver: 5,  // 5 USDC/month (50% discount)
      Gold: 0,    // Free for Gold+
      Platinum: 0,
    }
    return fees[tier as keyof typeof fees] || 10
  }
}