/* --- Step 1: Initialize Your JavaScript Project --- */
// Create a new project directory and navigate into it
// mkdir my-prisma-app
// cd my-prisma-app

// Initialize a new Node.js project
// npm init -y

/* --- Step 2: Install Prisma CLI and Client --- */
// Install Prisma CLI as a development dependency
// npm install prisma --save-dev

// Install Prisma Client as a regular dependency
// npm install @prisma/client

/* --- Step 3: Initialize Prisma in Your Project --- */
// This command sets up the Prisma directory and creates the schema.prisma file
// It also creates a .env file for database connection string
// npx prisma init --datasource-provider postgresql // or mysql, sqlite, sqlserver

/* --- Step 4: Define Your Data Model in schema.prisma --- */
// Locate your prisma/schema.prisma file and define your models.
// Replace 'postgres' with your chosen provider.
// Example schema.prisma content:

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

generator client {
  provider = "prisma-client-js"
}

model User {
  id        String   @id @default(uuid())
  email     String   @unique
  name      String?
  posts     Post[]
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
}

model Post {
  id        String    @id @default(uuid())
  title     String
  content   String?
  published Boolean   @default(false)
  author    User      @relation(fields: [authorId], references: [id])
  authorId  String
  tags      String[]
  createdAt DateTime  @default(now())
  updatedAt DateTime  @updatedAt
}

/* --- Step 1: Generate Prisma Client --- */
// After defining or updating your schema, always run this command
// It generates a type-safe Prisma Client based on your schema
// npx prisma generate

/* --- Step 2: Instantiate Prisma Client in Your Application --- */
// Example: src/index.js or api/server.js

import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient();

async function main() {
  // --- Create Operations ---
  // Create a new User
  const newUser = await prisma.user.create({
    data: {
      email: 'alice@example.com',
      name: 'Alice',
    },
  });
  console.log('Created user:', newUser);

  // Create a Post linked to the new User
  const newPost = await prisma.post.create({
    data: {
      title: 'My First Post with Prisma',
      content: 'Hello, Prisma world!',
      published: true,
      author: {
        connect: { id: newUser.id }, // Link by existing user ID
      },
      tags: ['prisma', 'javascript', 'orm']
    },
  });
  console.log('Created post:', newPost);

  // --- Read Operations ---
  // Find all Users
  const allUsers = await prisma.user.findMany();
  console.log('All users:', allUsers);

  // Find a User by unique identifier (email)
  const user = await prisma.user.findUnique({
    where: { email: 'alice@example.com' },
    include: { posts: true }, // Eager load user's posts
  });
  console.log('User with posts:', user);

  // Find published posts with pagination and ordering
  const publishedPosts = await prisma.post.findMany({
    where: { published: true },
    take: 10, // Limit to 10 records
    skip: 0,   // Offset by 0 records (first page)
    orderBy: { createdAt: 'desc' },
    select: { title: true, author: { select: { name: true } } }, // Select specific fields
  });
  console.log('Published posts:', publishedPosts);

  // --- Update Operations ---
  // Update a user's name
  const updatedUser = await prisma.user.update({
    where: { email: 'alice@example.com' },
    data: { name: 'Alice Smith' },
  });
  console.log('Updated user:', updatedUser);

  // Update a post's content
  const updatedPost = await prisma.post.update({
    where: { id: newPost.id },
    data: {
      content: 'Updated content for my first post.',
      tags: { push: 'database' } // Add a new tag to the array
    },
  });
  console.log('Updated post:', updatedPost);

  // --- Delete Operations ---
  // Delete a post
  // Note: Handle cascading deletes in your database or application logic
  const deletedPost = await prisma.post.delete({
    where: { id: newPost.id },
  });
  console.log('Deleted post:', deletedPost);

  // Delete a user (and related posts if cascade delete is configured in DB/schema)
  const deletedUser = await prisma.user.delete({
    where: { id: newUser.id },
  });
  console.log('Deleted user:', deletedUser);

} 

main()
  .catch((e) => {
    console.error(e);
    process.exit(1);
  })
  .finally(async () => {
    await prisma.$disconnect();
  });

/* --- Step 1: Create Initial Migration --- */
// After defining your schema, push it to the database and create a migration file
// This will apply the schema changes and generate a new migration file
// npx prisma migrate dev --name init

/* --- Step 2: Apply Pending Migrations --- */
// In production or other environments, apply migrations without generating new ones
// npx prisma migrate deploy

/* --- Step 3: Implement Database Seeding --- */
// Create a seed.js file (e.g., prisma/seed.js)
// Remember to add "prisma": {"seed": "node prisma/seed.js"} to package.json

// Example prisma/seed.js content:
import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient();

async function seed() {
  // Clean up existing data (optional, for development)
  await prisma.post.deleteMany({});
  await prisma.user.deleteMany({});

  // Create users
  const alice = await prisma.user.create({
    data: {
      email: 'alice@prisma.io',
      name: 'Alice',
    },
  });

  const bob = await prisma.user.create({
    data: {
      email: 'bob@prisma.io',
      name: 'Bob',
    },
  });

  // Create posts for Alice
  await prisma.post.create({
    data: {
      title: 'Hello World',
      content: 'This is my first post.',
      published: true,
      authorId: alice.id,
      tags: ['welcome', 'tutorial']
    },
  });

  await prisma.post.create({
    data: {
      title: 'Prisma is Great',
      content: 'Learning Prisma is fun and productive.',
      published: true,
      authorId: alice.id,
      tags: ['prisma', 'learn']
    },
  });

  // Create a post for Bob
  await prisma.post.create({
    data: {
      title: 'Database with Prisma',
      content: 'A deep dive into database interactions.',
      published: false,
      authorId: bob.id,
      tags: ['database', 'backend']
    },
  });

  console.log('Seeding complete!');
}

seed()
  .catch((e) => {
    console.error(e);
    process.exit(1);
  })
  .finally(async () => {
    await prisma.$disconnect();
  });

/* --- Step 4: Run the Seeder --- */
// npx prisma db seed

/* --- Step 5: Execute a Transaction (Example) --- */
// This ensures atomicity for multiple operations

async function transferPosts(fromUserId, toUserId) {
  return prisma.$transaction(async (tx) => {
    // Disconnect posts from original author
    await tx.post.updateMany({
      where: { authorId: fromUserId },
      data: { authorId: null }, // Temporarily set to null if allowed, or reassign directly
    });

    // Reassign posts to new author
    const updatedPosts = await tx.post.updateMany({
      where: { authorId: null }, // Assuming previous step set them to null
      data: { authorId: toUserId },
    });

    // Or, a more direct way if no intermediate null is needed:
    // const updatedPosts = await tx.post.updateMany({
    //   where: { authorId: fromUserId },
    //   data: { authorId: toUserId },
    // });

    return updatedPosts;
  });
}

// Example usage (assuming 'alice' and 'bob' are defined elsewhere)
// transferPosts(alice.id, bob.id).then(result => console.log('Transferred posts:', result));

/* --- Step 6: Execute Raw SQL Queries (Example) --- */
// For operations not directly supported by Prisma Client API

async function getOldestUsers() {
  const result = await prisma.$queryRaw`SELECT * FROM "User" ORDER BY "createdAt" ASC LIMIT 5`;
  console.log('Oldest users (raw query):', result);
}

// getOldestUsers();

/* --- Step 1: Manage Database Connection String with Environment Variables --- */
// In your .env file:
// DATABASE_URL="postgresql://user:password@host:port/database?schema=public"

// Accessing in your code (Node.js example, ensure dotenv is configured):
// import dotenv from 'dotenv';
// dotenv.config();
// const databaseUrl = process.env.DATABASE_URL; // Prisma Client picks this up automatically

/* --- Step 2: Implement Robust Error Handling --- */
// Wrap database operations in try-catch blocks
// Handle specific Prisma Client errors (e.g., P2002 for unique constraint violation)

import { PrismaClient, Prisma } from '@prisma/client';
const prisma = new PrismaClient();

async function createUserSafe(email, name) {
  try {
    const user = await prisma.user.create({
      data: { email, name },
    });
    return { success: true, user };
  } catch (error) {
    if (error instanceof Prisma.PrismaClientKnownRequestError) {
      if (error.code === 'P2002') {
        // Unique constraint violation
        console.error(`Error: A user with email '${email}' already exists.`);
        return { success: false, message: 'Email already registered.' };
      } else if (error.code === 'P2000') {
        // Value too long for column
        console.error('Error: Input data is too long for a database column.');
        return { success: false, message: 'Invalid input data.' };
      }
    }
    console.error('Unhandled database error:', error);
    return { success: false, message: 'An unexpected error occurred.' };
  }
}

// Example usage:
// await createUserSafe('john@example.com', 'John Doe');
// await createUserSafe('alice@example.com', 'Alice'); // Should trigger P2002 if Alice already exists

/* --- Step 3: Configure Connection Pooling (Automatic by Prisma, but be aware) --- */
// Prisma Client manages connection pooling efficiently.
// For serverless functions, consider `prisma.$disconnect()` after each request or
// using connection management services like Prisma Data Proxy.
// No direct code example needed here, as it's an architectural consideration.

/* --- Step 4: Logging and Debugging --- */
// Configure Prisma Client to log queries and events for debugging

// const prisma = new PrismaClient({
//   log: ['query', 'info', 'warn', 'error'],
// });

// Example: Log query execution time
// prisma.$on('query', (e) => {
//   console.log('Query: ' + e.query);
//   console.log('Params: ' + e.params);
//   console.log('Duration: ' + e.duration + 'ms');
// });