model User {
  id            String    @id @default(auto()) @map("_id") @db.ObjectId
  email         String    @unique
  emailVerified Boolean   @default(false)
  name          String?
  image         String?
  createdAt     DateTime  @default(now())
  updatedAt     DateTime  @updatedAt
  
  // Relations Better Auth
  accounts      Account[]
  sessions      Session[]
  twoFactor     TwoFactor[]
  organizations OrganizationMember[]
  
  // Relations Trading (à réactiver)
  swingPositions swingPosition[]
  exchanges      exchange[]
}

model exchange {
  id            String         @id @default(auto()) @map("_id") @db.ObjectId
  name          String
  apiKey        String /// @encrypted
  apiSecret     String /// @encrypted
  password      String? /// @encrypted
  balanceTotal  Float?
  balanceFree   Float?
  type          ExchangeType
  isActive      Boolean        @default(false)
  
  // Relation User (à réactiver)
  userId        String?        @db.ObjectId
  user          User?          @relation(fields: [userId], references: [id])
  
  exchangePairs exchangePair[]
  symbolPairs   SymbolPair[]
}

model swingPosition {
  id                      String         @id @default(auto()) @map("_id") @db.ObjectId
  exchangePair            exchangePair   @relation(fields: [exchangePairId], references: [id])
  exchangePairId          String         @db.ObjectId
  
  // Relation User (à réactiver)
  userId                  String?        @db.ObjectId
  user                    User?          @relation(fields: [userId], references: [id])
  
  activity                Json? @default("[]")
  orderSide               OrderSide
  timeframe               Timeframe      @relation(fields: [timeframeId], references: [id])
  timeframeId             String         @db.ObjectId
  status                  PositionStatus @default(NEW)
  
  // ... reste des champs
}

// Méthode deleteUser à mettre à jour
async deleteUser(userId: string) {
  try {
    // Supprimer les positions de trading de l'utilisateur
    await this.prisma.swingPosition.updateMany({
      where: { userId },
      data: { userId: null }
    })
    
    // Supprimer les exchanges de l'utilisateur
    await this.prisma.exchange.updateMany({
      where: { userId },
      data: { userId: null }
    })
    
    // Supprimer l'utilisateur (cascade supprimera les sessions, accounts, etc.)
    await this.prisma.user.delete({
      where: { id: userId }
    })
    
    return true
  } catch (error) {
    console.error("Error deleting user:", error)
    throw error
  }
}

// Méthode getUserStats à mettre à jour
async getUserStats(userId: string) {
  try {
    const [swingPositions, exchanges, totalPnl] = await Promise.all([
      this.prisma.swingPosition.count({
        where: { userId }
      }),
      this.prisma.exchange.count({
        where: { userId }
      }),
      this.prisma.swingPosition.aggregate({
        where: { userId },
        _sum: { pnl: true }
      })
    ])
    
    return {
      swingPositions,
      exchanges,
      totalPnl: totalPnl._sum.pnl || 0
    }
  } catch (error) {
    console.error("Error getting user stats:", error)
    throw error
  }
}

// scripts/migrate-user-trading.ts
import { PrismaClient } from '@prisma/client'

async function migrateUserTrading() {
  const prisma = new PrismaClient()
  
  try {
    // 1. Créer un utilisateur par défaut pour les données existantes
    const defaultUser = await prisma.user.create({
      data: {
        email: '[email protected]',
        name: 'System User',
        emailVerified: true
      }
    })
    
    // 2. Lier les exchanges existants à l'utilisateur par défaut
    await prisma.exchange.updateMany({
      where: { userId: null },
      data: { userId: defaultUser.id }
    })
    
    // 3. Lier les positions existantes à l'utilisateur par défaut
    await prisma.swingPosition.updateMany({
      where: { userId: null },
      data: { userId: defaultUser.id }
    })
    
    console.log('Migration terminée avec succès')
  } catch (error) {
    console.error('Erreur lors de la migration:', error)
  } finally {
    await prisma.$disconnect()
  }
}