'use strict';
const { v4: uuidv4 } = require('uuid');

/** @type {import('sequelize-cli').Migration} */
module.exports = {
  async up(queryInterface, Sequelize) {
    // First, get the category IDs we need
    const [categories] = await queryInterface.sequelize.query(
      `SELECT id, slug FROM categories WHERE slug IN ('javascript', 'angular', 'react', 'nodejs', 'typescript', 'sql-databases', 'system-design')`
    );

    const categoryMap = {};
    categories.forEach(cat => {
      categoryMap[cat.slug] = cat.id;
    });

    // Get admin user ID for created_by
    const [users] = await queryInterface.sequelize.query(
      `SELECT id FROM users WHERE email = 'admin@quiz.com' LIMIT 1`
    );
    const adminId = users[0]?.id || null;

    const questions = [];

    // JavaScript Questions (15 questions)
    const jsQuestions = [
      {
        id: uuidv4(),
        category_id: categoryMap['javascript'],
        question_text: 'What is the difference between let and var in JavaScript?',
        question_type: 'multiple',
        options: JSON.stringify([
          { id: 'a', text: 'let has block scope, var has function scope' },
          { id: 'b', text: 'var has block scope, let has function scope' },
          { id: 'c', text: 'They are exactly the same' },
          { id: 'd', text: 'let cannot be reassigned' }
        ]),
        correct_answer: JSON.stringify(['a']),
        explanation: 'let has block scope (only accessible within {}), while var has function scope (accessible anywhere in the function).',
        difficulty: 'easy',
        points: 5,
        time_limit: 60,
        keywords: JSON.stringify(['scope', 'let', 'var', 'es6']),
        tags: JSON.stringify(['variables', 'scope', 'fundamentals']),
        is_active: true,
        times_attempted: 0,
        times_correct: 0,
        created_by: adminId,
        created_at: new Date(),
        updated_at: new Date()
      },
      {
        id: uuidv4(),
        category_id: categoryMap['javascript'],
        question_text: 'What is a closure in JavaScript?',
        question_type: 'multiple',
        options: JSON.stringify([
          { id: 'a', text: 'A function that returns another function' },
          { id: 'b', text: 'A function that has access to variables from its outer scope' },
          { id: 'c', text: 'A function that closes the browser' },
          { id: 'd', text: 'A method to close database connections' }
        ]),
        correct_answer: JSON.stringify(['b']),
        explanation: 'A closure is a function that remembers and can access variables from its outer (enclosing) scope, even after the outer function has finished executing.',
        difficulty: 'medium',
        points: 10,
        time_limit: 90,
        keywords: JSON.stringify(['closure', 'scope', 'lexical']),
        tags: JSON.stringify(['functions', 'scope', 'advanced']),
        is_active: true,
        times_attempted: 0,
        times_correct: 0,
        created_by: adminId,
        created_at: new Date(),
        updated_at: new Date()
      },
      {
        id: uuidv4(),
        category_id: categoryMap['javascript'],
        question_text: 'What does the spread operator (...) do in JavaScript?',
        question_type: 'multiple',
        options: JSON.stringify([
          { id: 'a', text: 'Creates a copy of an array or object' },
          { id: 'b', text: 'Expands an iterable into individual elements' },
          { id: 'c', text: 'Both A and B' },
          { id: 'd', text: 'Performs mathematical operations' }
        ]),
        correct_answer: JSON.stringify(['c']),
        explanation: 'The spread operator (...) can expand iterables into individual elements and is commonly used to copy arrays/objects or pass elements as function arguments.',
        difficulty: 'easy',
        points: 5,
        time_limit: 60,
        keywords: JSON.stringify(['spread', 'operator', 'es6', 'array']),
        tags: JSON.stringify(['operators', 'es6', 'arrays']),
        is_active: true,
        times_attempted: 0,
        times_correct: 0,
        created_by: adminId,
        created_at: new Date(),
        updated_at: new Date()
      },
      {
        id: uuidv4(),
        category_id: categoryMap['javascript'],
        question_text: 'What is the purpose of Promise.all()?',
        question_type: 'multiple',
        options: JSON.stringify([
          { id: 'a', text: 'Waits for all promises to resolve or any to reject' },
          { id: 'b', text: 'Runs promises sequentially' },
          { id: 'c', text: 'Cancels all promises' },
          { id: 'd', text: 'Returns the first resolved promise' }
        ]),
        correct_answer: JSON.stringify(['a']),
        explanation: 'Promise.all() takes an array of promises and returns a single promise that resolves when all promises resolve, or rejects when any promise rejects.',
        difficulty: 'medium',
        points: 10,
        time_limit: 90,
        keywords: JSON.stringify(['promise', 'async', 'concurrent']),
        tags: JSON.stringify(['promises', 'async', 'concurrency']),
        is_active: true,
        times_attempted: 0,
        times_correct: 0,
        created_by: adminId,
        created_at: new Date(),
        updated_at: new Date()
      },
      {
        id: uuidv4(),
        category_id: categoryMap['javascript'],
        question_text: 'What is event delegation in JavaScript?',
        question_type: 'multiple',
        options: JSON.stringify([
          { id: 'a', text: 'Attaching event listeners to parent elements to handle events on children' },
          { id: 'b', text: 'Creating custom events' },
          { id: 'c', text: 'Removing event listeners' },
          { id: 'd', text: 'Preventing event propagation' }
        ]),
        correct_answer: JSON.stringify(['a']),
        explanation: 'Event delegation uses event bubbling to handle events on child elements by attaching a single listener to a parent element, improving performance.',
        difficulty: 'medium',
        points: 10,
        time_limit: 90,
        keywords: JSON.stringify(['event', 'delegation', 'bubbling', 'dom']),
        tags: JSON.stringify(['events', 'dom', 'patterns']),
        is_active: true,
        times_attempted: 0,
        times_correct: 0,
        created_by: adminId,
        created_at: new Date(),
        updated_at: new Date()
      }
    ];

    // Angular Questions (12 questions)
    const angularQuestions = [
      {
        id: uuidv4(),
        category_id: categoryMap['angular'],
        question_text: 'What is the purpose of NgModule in Angular?',
        question_type: 'multiple',
        options: JSON.stringify([
          { id: 'a', text: 'To organize application structure and define compilation context' },
          { id: 'b', text: 'To create components' },
          { id: 'c', text: 'To handle routing' },
          { id: 'd', text: 'To manage state' }
        ]),
        correct_answer: JSON.stringify(['a']),
        explanation: 'NgModule is a decorator that defines a module - a cohesive block of code with related components, directives, pipes, and services. It organizes the application.',
        difficulty: 'easy',
        points: 5,
        time_limit: 60,
        keywords: JSON.stringify(['ngmodule', 'module', 'decorator']),
        tags: JSON.stringify(['modules', 'architecture', 'fundamentals']),
        is_active: true,
        times_attempted: 0,
        times_correct: 0,
        created_by: adminId,
        created_at: new Date(),
        updated_at: new Date()
      },
      {
        id: uuidv4(),
        category_id: categoryMap['angular'],
        question_text: 'What is dependency injection in Angular?',
        question_type: 'multiple',
        options: JSON.stringify([
          { id: 'a', text: 'A design pattern where dependencies are provided to a class instead of creating them internally' },
          { id: 'b', text: 'A way to import modules' },
          { id: 'c', text: 'A routing technique' },
          { id: 'd', text: 'A method to create components' }
        ]),
        correct_answer: JSON.stringify(['a']),
        explanation: 'Dependency Injection (DI) is a design pattern where Angular provides dependencies (services) to components/services through their constructors, promoting loose coupling.',
        difficulty: 'medium',
        points: 10,
        time_limit: 90,
        keywords: JSON.stringify(['di', 'dependency injection', 'service', 'provider']),
        tags: JSON.stringify(['di', 'services', 'architecture']),
        is_active: true,
        times_attempted: 0,
        times_correct: 0,
        created_by: adminId,
        created_at: new Date(),
        updated_at: new Date()
      },
      {
        id: uuidv4(),
        category_id: categoryMap['angular'],
        question_text: 'What is the difference between @Input() and @Output() decorators?',
        question_type: 'multiple',
        options: JSON.stringify([
          { id: 'a', text: '@Input() receives data from parent, @Output() emits events to parent' },
          { id: 'b', text: '@Input() emits events, @Output() receives data' },
          { id: 'c', text: 'They are the same' },
          { id: 'd', text: '@Input() is for services, @Output() is for components' }
        ]),
        correct_answer: JSON.stringify(['a']),
        explanation: '@Input() allows a child component to receive data from its parent, while @Output() with EventEmitter allows a child to emit events to its parent.',
        difficulty: 'easy',
        points: 5,
        time_limit: 60,
        keywords: JSON.stringify(['input', 'output', 'decorator', 'communication']),
        tags: JSON.stringify(['decorators', 'component-communication', 'fundamentals']),
        is_active: true,
        times_attempted: 0,
        times_correct: 0,
        created_by: adminId,
        created_at: new Date(),
        updated_at: new Date()
      },
      {
        id: uuidv4(),
        category_id: categoryMap['angular'],
        question_text: 'What is RxJS used for in Angular?',
        question_type: 'multiple',
        options: JSON.stringify([
          { id: 'a', text: 'Reactive programming with Observables for async operations' },
          { id: 'b', text: 'Styling components' },
          { id: 'c', text: 'Creating animations' },
          { id: 'd', text: 'Testing components' }
        ]),
        correct_answer: JSON.stringify(['a']),
        explanation: 'RxJS provides reactive programming capabilities using Observables, which are used extensively in Angular for handling async operations like HTTP requests and events.',
        difficulty: 'medium',
        points: 10,
        time_limit: 90,
        keywords: JSON.stringify(['rxjs', 'observable', 'reactive', 'async']),
        tags: JSON.stringify(['rxjs', 'async', 'observables']),
        is_active: true,
        times_attempted: 0,
        times_correct: 0,
        created_by: adminId,
        created_at: new Date(),
        updated_at: new Date()
      },
      {
        id: uuidv4(),
        category_id: categoryMap['angular'],
        question_text: 'What is the purpose of Angular lifecycle hooks?',
        question_type: 'multiple',
        options: JSON.stringify([
          { id: 'a', text: 'To tap into key moments in component/directive lifecycle' },
          { id: 'b', text: 'To create routes' },
          { id: 'c', text: 'To style components' },
          { id: 'd', text: 'To handle errors' }
        ]),
        correct_answer: JSON.stringify(['a']),
        explanation: 'Lifecycle hooks like ngOnInit, ngOnChanges, and ngOnDestroy allow you to execute code at specific points in a component or directive\'s lifecycle.',
        difficulty: 'easy',
        points: 5,
        time_limit: 60,
        keywords: JSON.stringify(['lifecycle', 'hooks', 'ngoninit']),
        tags: JSON.stringify(['lifecycle', 'hooks', 'fundamentals']),
        is_active: true,
        times_attempted: 0,
        times_correct: 0,
        created_by: adminId,
        created_at: new Date(),
        updated_at: new Date()
      }
    ];

    // React Questions (12 questions)
    const reactQuestions = [
      {
        id: uuidv4(),
        category_id: categoryMap['react'],
        question_text: 'What is the virtual DOM in React?',
        question_type: 'multiple',
        options: JSON.stringify([
          { id: 'a', text: 'A lightweight copy of the real DOM kept in memory' },
          { id: 'b', text: 'A database for storing component state' },
          { id: 'c', text: 'A routing mechanism' },
          { id: 'd', text: 'A testing library' }
        ]),
        correct_answer: JSON.stringify(['a']),
        explanation: 'The virtual DOM is a lightweight JavaScript representation of the real DOM. React uses it to optimize updates by comparing changes and updating only what\'s necessary.',
        difficulty: 'easy',
        points: 5,
        time_limit: 60,
        keywords: JSON.stringify(['virtual dom', 'reconciliation', 'performance']),
        tags: JSON.stringify(['fundamentals', 'performance', 'dom']),
        is_active: true,
        times_attempted: 0,
        times_correct: 0,
        created_by: adminId,
        created_at: new Date(),
        updated_at: new Date()
      },
      {
        id: uuidv4(),
        category_id: categoryMap['react'],
        question_text: 'What is the purpose of useEffect hook?',
        question_type: 'multiple',
        options: JSON.stringify([
          { id: 'a', text: 'To perform side effects in function components' },
          { id: 'b', text: 'To create state variables' },
          { id: 'c', text: 'To handle routing' },
          { id: 'd', text: 'To optimize performance' }
        ]),
        correct_answer: JSON.stringify(['a']),
        explanation: 'useEffect allows you to perform side effects (data fetching, subscriptions, DOM manipulation) in function components. It runs after render.',
        difficulty: 'easy',
        points: 5,
        time_limit: 60,
        keywords: JSON.stringify(['useeffect', 'hook', 'side effects']),
        tags: JSON.stringify(['hooks', 'side-effects', 'fundamentals']),
        is_active: true,
        times_attempted: 0,
        times_correct: 0,
        created_by: adminId,
        created_at: new Date(),
        updated_at: new Date()
      },
      {
        id: uuidv4(),
        category_id: categoryMap['react'],
        question_text: 'What is prop drilling in React?',
        question_type: 'multiple',
        options: JSON.stringify([
          { id: 'a', text: 'Passing props through multiple component layers' },
          { id: 'b', text: 'Creating new props' },
          { id: 'c', text: 'Validating prop types' },
          { id: 'd', text: 'Drilling holes in components' }
        ]),
        correct_answer: JSON.stringify(['a']),
        explanation: 'Prop drilling is when you pass props through multiple intermediate components that don\'t need them, just to get them to a deeply nested component.',
        difficulty: 'medium',
        points: 10,
        time_limit: 90,
        keywords: JSON.stringify(['props', 'drilling', 'context']),
        tags: JSON.stringify(['props', 'patterns', 'architecture']),
        is_active: true,
        times_attempted: 0,
        times_correct: 0,
        created_by: adminId,
        created_at: new Date(),
        updated_at: new Date()
      },
      {
        id: uuidv4(),
        category_id: categoryMap['react'],
        question_text: 'What is the difference between useMemo and useCallback?',
        question_type: 'multiple',
        options: JSON.stringify([
          { id: 'a', text: 'useMemo memoizes values, useCallback memoizes functions' },
          { id: 'b', text: 'useMemo is for functions, useCallback is for values' },
          { id: 'c', text: 'They are exactly the same' },
          { id: 'd', text: 'useMemo is deprecated' }
        ]),
        correct_answer: JSON.stringify(['a']),
        explanation: 'useMemo returns and memoizes a computed value, while useCallback returns and memoizes a function. Both are used for performance optimization.',
        difficulty: 'medium',
        points: 10,
        time_limit: 90,
        keywords: JSON.stringify(['usememo', 'usecallback', 'memoization', 'performance']),
        tags: JSON.stringify(['hooks', 'performance', 'optimization']),
        is_active: true,
        times_attempted: 0,
        times_correct: 0,
        created_by: adminId,
        created_at: new Date(),
        updated_at: new Date()
      },
      {
        id: uuidv4(),
        category_id: categoryMap['react'],
        question_text: 'What is React Context API used for?',
        question_type: 'multiple',
        options: JSON.stringify([
          { id: 'a', text: 'Sharing data across components without prop drilling' },
          { id: 'b', text: 'Creating routes' },
          { id: 'c', text: 'Managing component lifecycle' },
          { id: 'd', text: 'Optimizing performance' }
        ]),
        correct_answer: JSON.stringify(['a']),
        explanation: 'Context API provides a way to share values between components without explicitly passing props through every level of the tree.',
        difficulty: 'easy',
        points: 5,
        time_limit: 60,
        keywords: JSON.stringify(['context', 'api', 'state management']),
        tags: JSON.stringify(['context', 'state-management', 'fundamentals']),
        is_active: true,
        times_attempted: 0,
        times_correct: 0,
        created_by: adminId,
        created_at: new Date(),
        updated_at: new Date()
      }
    ];

    // Node.js Questions (10 questions)
    const nodejsQuestions = [
      {
        id: uuidv4(),
        category_id: categoryMap['nodejs'],
        question_text: 'What is the event loop in Node.js?',
        question_type: 'multiple',
        options: JSON.stringify([
          { id: 'a', text: 'A mechanism that handles async operations by queuing callbacks' },
          { id: 'b', text: 'A for loop that runs forever' },
          { id: 'c', text: 'A routing system' },
          { id: 'd', text: 'A testing framework' }
        ]),
        correct_answer: JSON.stringify(['a']),
        explanation: 'The event loop is Node.js\'s mechanism for handling async operations. It continuously checks for and executes callbacks from different phases.',
        difficulty: 'medium',
        points: 10,
        time_limit: 90,
        keywords: JSON.stringify(['event loop', 'async', 'callbacks']),
        tags: JSON.stringify(['event-loop', 'async', 'fundamentals']),
        is_active: true,
        times_attempted: 0,
        times_correct: 0,
        created_by: adminId,
        created_at: new Date(),
        updated_at: new Date()
      },
      {
        id: uuidv4(),
        category_id: categoryMap['nodejs'],
        question_text: 'What is middleware in Express.js?',
        question_type: 'multiple',
        options: JSON.stringify([
          { id: 'a', text: 'Functions that have access to request, response, and next in the pipeline' },
          { id: 'b', text: 'Database connection code' },
          { id: 'c', text: 'Front-end components' },
          { id: 'd', text: 'Testing utilities' }
        ]),
        correct_answer: JSON.stringify(['a']),
        explanation: 'Middleware functions have access to request and response objects and the next() function. They can execute code, modify req/res, and control the flow.',
        difficulty: 'easy',
        points: 5,
        time_limit: 60,
        keywords: JSON.stringify(['middleware', 'express', 'request', 'response']),
        tags: JSON.stringify(['express', 'middleware', 'fundamentals']),
        is_active: true,
        times_attempted: 0,
        times_correct: 0,
        created_by: adminId,
        created_at: new Date(),
        updated_at: new Date()
      },
      {
        id: uuidv4(),
        category_id: categoryMap['nodejs'],
        question_text: 'What is the purpose of package.json in Node.js?',
        question_type: 'multiple',
        options: JSON.stringify([
          { id: 'a', text: 'Metadata file containing project info, dependencies, and scripts' },
          { id: 'b', text: 'Configuration for the database' },
          { id: 'c', text: 'Main application entry point' },
          { id: 'd', text: 'Testing configuration' }
        ]),
        correct_answer: JSON.stringify(['a']),
        explanation: 'package.json is the manifest file for Node.js projects. It contains metadata, dependencies, scripts, and configuration.',
        difficulty: 'easy',
        points: 5,
        time_limit: 60,
        keywords: JSON.stringify(['package.json', 'npm', 'dependencies']),
        tags: JSON.stringify(['npm', 'configuration', 'fundamentals']),
        is_active: true,
        times_attempted: 0,
        times_correct: 0,
        created_by: adminId,
        created_at: new Date(),
        updated_at: new Date()
      },
      {
        id: uuidv4(),
        category_id: categoryMap['nodejs'],
        question_text: 'What is the difference between process.nextTick() and setImmediate()?',
        question_type: 'multiple',
        options: JSON.stringify([
          { id: 'a', text: 'nextTick() executes before the event loop continues, setImmediate() after I/O' },
          { id: 'b', text: 'They are exactly the same' },
          { id: 'c', text: 'setImmediate() is synchronous' },
          { id: 'd', text: 'nextTick() is deprecated' }
        ]),
        correct_answer: JSON.stringify(['a']),
        explanation: 'process.nextTick() callbacks execute immediately after the current operation, before the event loop continues. setImmediate() executes in the check phase.',
        difficulty: 'hard',
        points: 15,
        time_limit: 120,
        keywords: JSON.stringify(['nexttick', 'setimmediate', 'event loop']),
        tags: JSON.stringify(['event-loop', 'async', 'advanced']),
        is_active: true,
        times_attempted: 0,
        times_correct: 0,
        created_by: adminId,
        created_at: new Date(),
        updated_at: new Date()
      },
      {
        id: uuidv4(),
        category_id: categoryMap['nodejs'],
        question_text: 'What is clustering in Node.js?',
        question_type: 'multiple',
        options: JSON.stringify([
          { id: 'a', text: 'Running multiple Node.js processes to utilize all CPU cores' },
          { id: 'b', text: 'Grouping related code together' },
          { id: 'c', text: 'Database optimization technique' },
          { id: 'd', text: 'A design pattern' }
        ]),
        correct_answer: JSON.stringify(['a']),
        explanation: 'Clustering allows you to create child processes (workers) that share server ports, enabling Node.js to utilize all available CPU cores.',
        difficulty: 'medium',
        points: 10,
        time_limit: 90,
        keywords: JSON.stringify(['cluster', 'scaling', 'performance']),
        tags: JSON.stringify(['clustering', 'scaling', 'performance']),
        is_active: true,
        times_attempted: 0,
        times_correct: 0,
        created_by: adminId,
        created_at: new Date(),
        updated_at: new Date()
      }
    ];

    // TypeScript Questions (10 questions)
    const tsQuestions = [
      {
        id: uuidv4(),
        category_id: categoryMap['typescript'],
        question_text: 'What is the difference between interface and type in TypeScript?',
        question_type: 'multiple',
        options: JSON.stringify([
          { id: 'a', text: 'Interfaces can be extended/merged, types are more flexible with unions' },
          { id: 'b', text: 'They are exactly the same' },
          { id: 'c', text: 'Types are deprecated' },
          { id: 'd', text: 'Interfaces only work with objects' }
        ]),
        correct_answer: JSON.stringify(['a']),
        explanation: 'Interfaces can be extended and declared multiple times (declaration merging). Types are more flexible with unions, intersections, and primitives.',
        difficulty: 'medium',
        points: 10,
        time_limit: 90,
        keywords: JSON.stringify(['interface', 'type', 'alias']),
        tags: JSON.stringify(['types', 'interfaces', 'fundamentals']),
        is_active: true,
        times_attempted: 0,
        times_correct: 0,
        created_by: adminId,
        created_at: new Date(),
        updated_at: new Date()
      },
      {
        id: uuidv4(),
        category_id: categoryMap['typescript'],
        question_text: 'What is a generic in TypeScript?',
        question_type: 'multiple',
        options: JSON.stringify([
          { id: 'a', text: 'A way to create reusable components that work with multiple types' },
          { id: 'b', text: 'A basic data type' },
          { id: 'c', text: 'A class decorator' },
          { id: 'd', text: 'A testing utility' }
        ]),
        correct_answer: JSON.stringify(['a']),
        explanation: 'Generics allow you to create components that work with any type while maintaining type safety. They\'re like variables for types.',
        difficulty: 'medium',
        points: 10,
        time_limit: 90,
        keywords: JSON.stringify(['generic', 'type parameter', 'reusable']),
        tags: JSON.stringify(['generics', 'types', 'advanced']),
        is_active: true,
        times_attempted: 0,
        times_correct: 0,
        created_by: adminId,
        created_at: new Date(),
        updated_at: new Date()
      },
      {
        id: uuidv4(),
        category_id: categoryMap['typescript'],
        question_text: 'What is the "never" type in TypeScript?',
        question_type: 'multiple',
        options: JSON.stringify([
          { id: 'a', text: 'A type representing values that never occur' },
          { id: 'b', text: 'A deprecated type' },
          { id: 'c', text: 'Same as void' },
          { id: 'd', text: 'A null type' }
        ]),
        correct_answer: JSON.stringify(['a']),
        explanation: 'The never type represents values that never occur - functions that always throw errors or infinite loops. It\'s the bottom type.',
        difficulty: 'hard',
        points: 15,
        time_limit: 120,
        keywords: JSON.stringify(['never', 'bottom type', 'type system']),
        tags: JSON.stringify(['types', 'advanced', 'type-system']),
        is_active: true,
        times_attempted: 0,
        times_correct: 0,
        created_by: adminId,
        created_at: new Date(),
        updated_at: new Date()
      },
      {
        id: uuidv4(),
        category_id: categoryMap['typescript'],
        question_text: 'What is type narrowing in TypeScript?',
        question_type: 'multiple',
        options: JSON.stringify([
          { id: 'a', text: 'Refining types through conditional checks to more specific types' },
          { id: 'b', text: 'Making type names shorter' },
          { id: 'c', text: 'Removing types from code' },
          { id: 'd', text: 'Converting types to primitives' }
        ]),
        correct_answer: JSON.stringify(['a']),
        explanation: 'Type narrowing is when TypeScript refines a broader type to a more specific one based on conditional checks (typeof, instanceof, etc.).',
        difficulty: 'medium',
        points: 10,
        time_limit: 90,
        keywords: JSON.stringify(['narrowing', 'type guards', 'refinement']),
        tags: JSON.stringify(['type-guards', 'narrowing', 'advanced']),
        is_active: true,
        times_attempted: 0,
        times_correct: 0,
        created_by: adminId,
        created_at: new Date(),
        updated_at: new Date()
      },
      {
        id: uuidv4(),
        category_id: categoryMap['typescript'],
        question_text: 'What is the purpose of the "readonly" modifier?',
        question_type: 'multiple',
        options: JSON.stringify([
          { id: 'a', text: 'Makes properties immutable after initialization' },
          { id: 'b', text: 'Hides properties from console.log' },
          { id: 'c', text: 'Marks properties as private' },
          { id: 'd', text: 'Improves performance' }
        ]),
        correct_answer: JSON.stringify(['a']),
        explanation: 'The readonly modifier prevents properties from being reassigned after initialization, providing compile-time immutability.',
        difficulty: 'easy',
        points: 5,
        time_limit: 60,
        keywords: JSON.stringify(['readonly', 'immutable', 'modifier']),
        tags: JSON.stringify(['modifiers', 'immutability', 'fundamentals']),
        is_active: true,
        times_attempted: 0,
        times_correct: 0,
        created_by: adminId,
        created_at: new Date(),
        updated_at: new Date()
      }
    ];

    // SQL Questions (10 questions)
    const sqlQuestions = [
      {
        id: uuidv4(),
        category_id: categoryMap['sql-databases'],
        question_text: 'What is the difference between INNER JOIN and LEFT JOIN?',
        question_type: 'multiple',
        options: JSON.stringify([
          { id: 'a', text: 'INNER returns only matching rows, LEFT returns all left table rows' },
          { id: 'b', text: 'They are exactly the same' },
          { id: 'c', text: 'LEFT JOIN is faster' },
          { id: 'd', text: 'INNER JOIN includes NULL values' }
        ]),
        correct_answer: JSON.stringify(['a']),
        explanation: 'INNER JOIN returns only rows with matches in both tables. LEFT JOIN returns all rows from the left table, with NULLs for non-matching right table rows.',
        difficulty: 'easy',
        points: 5,
        time_limit: 60,
        keywords: JSON.stringify(['join', 'inner', 'left', 'sql']),
        tags: JSON.stringify(['joins', 'queries', 'fundamentals']),
        is_active: true,
        times_attempted: 0,
        times_correct: 0,
        created_by: adminId,
        created_at: new Date(),
        updated_at: new Date()
      },
      {
        id: uuidv4(),
        category_id: categoryMap['sql-databases'],
        question_text: 'What is database normalization?',
        question_type: 'multiple',
        options: JSON.stringify([
          { id: 'a', text: 'Organizing data to reduce redundancy and improve integrity' },
          { id: 'b', text: 'Making all values lowercase' },
          { id: 'c', text: 'Optimizing query performance' },
          { id: 'd', text: 'Backing up the database' }
        ]),
        correct_answer: JSON.stringify(['a']),
        explanation: 'Normalization is the process of organizing database structure to reduce redundancy and dependency by dividing large tables into smaller ones.',
        difficulty: 'medium',
        points: 10,
        time_limit: 90,
        keywords: JSON.stringify(['normalization', 'database design', 'redundancy']),
        tags: JSON.stringify(['design', 'normalization', 'fundamentals']),
        is_active: true,
        times_attempted: 0,
        times_correct: 0,
        created_by: adminId,
        created_at: new Date(),
        updated_at: new Date()
      },
      {
        id: uuidv4(),
        category_id: categoryMap['sql-databases'],
        question_text: 'What is an index in a database?',
        question_type: 'multiple',
        options: JSON.stringify([
          { id: 'a', text: 'A data structure that improves query speed at the cost of write speed' },
          { id: 'b', text: 'A primary key' },
          { id: 'c', text: 'A backup of the table' },
          { id: 'd', text: 'A foreign key relationship' }
        ]),
        correct_answer: JSON.stringify(['a']),
        explanation: 'An index is a data structure (typically B-tree) that speeds up data retrieval operations but requires additional space and slows down writes.',
        difficulty: 'easy',
        points: 5,
        time_limit: 60,
        keywords: JSON.stringify(['index', 'performance', 'query optimization']),
        tags: JSON.stringify(['indexes', 'performance', 'fundamentals']),
        is_active: true,
        times_attempted: 0,
        times_correct: 0,
        created_by: adminId,
        created_at: new Date(),
        updated_at: new Date()
      },
      {
        id: uuidv4(),
        category_id: categoryMap['sql-databases'],
        question_text: 'What is a transaction in SQL?',
        question_type: 'multiple',
        options: JSON.stringify([
          { id: 'a', text: 'A sequence of operations performed as a single unit of work (ACID)' },
          { id: 'b', text: 'A single SQL query' },
          { id: 'c', text: 'A database backup' },
          { id: 'd', text: 'A table relationship' }
        ]),
        correct_answer: JSON.stringify(['a']),
        explanation: 'A transaction is a logical unit of work that follows ACID properties (Atomicity, Consistency, Isolation, Durability) to maintain data integrity.',
        difficulty: 'medium',
        points: 10,
        time_limit: 90,
        keywords: JSON.stringify(['transaction', 'acid', 'commit', 'rollback']),
        tags: JSON.stringify(['transactions', 'acid', 'fundamentals']),
        is_active: true,
        times_attempted: 0,
        times_correct: 0,
        created_by: adminId,
        created_at: new Date(),
        updated_at: new Date()
      },
      {
        id: uuidv4(),
        category_id: categoryMap['sql-databases'],
        question_text: 'What does the GROUP BY clause do in SQL?',
        question_type: 'multiple',
        options: JSON.stringify([
          { id: 'a', text: 'Groups rows with same values for aggregate functions' },
          { id: 'b', text: 'Sorts the result set' },
          { id: 'c', text: 'Filters rows before grouping' },
          { id: 'd', text: 'Joins tables together' }
        ]),
        correct_answer: JSON.stringify(['a']),
        explanation: 'GROUP BY groups rows that have the same values in specified columns, often used with aggregate functions like COUNT, SUM, AVG.',
        difficulty: 'easy',
        points: 5,
        time_limit: 60,
        keywords: JSON.stringify(['group by', 'aggregate', 'sql']),
        tags: JSON.stringify(['grouping', 'aggregates', 'fundamentals']),
        is_active: true,
        times_attempted: 0,
        times_correct: 0,
        created_by: adminId,
        created_at: new Date(),
        updated_at: new Date()
      }
    ];

    // System Design Questions (10 questions)
    const systemDesignQuestions = [
      {
        id: uuidv4(),
        category_id: categoryMap['system-design'],
        question_text: 'What is horizontal scaling vs vertical scaling?',
        question_type: 'multiple',
        options: JSON.stringify([
          { id: 'a', text: 'Horizontal adds more machines, vertical increases single machine resources' },
          { id: 'b', text: 'Vertical adds more machines, horizontal increases resources' },
          { id: 'c', text: 'They are the same' },
          { id: 'd', text: 'Horizontal is always better' }
        ]),
        correct_answer: JSON.stringify(['a']),
        explanation: 'Horizontal scaling (scale out) adds more machines to the pool. Vertical scaling (scale up) adds more resources (CPU, RAM) to a single machine.',
        difficulty: 'easy',
        points: 5,
        time_limit: 60,
        keywords: JSON.stringify(['scaling', 'horizontal', 'vertical', 'architecture']),
        tags: JSON.stringify(['scaling', 'architecture', 'fundamentals']),
        is_active: true,
        times_attempted: 0,
        times_correct: 0,
        created_by: adminId,
        created_at: new Date(),
        updated_at: new Date()
      },
      {
        id: uuidv4(),
        category_id: categoryMap['system-design'],
        question_text: 'What is a load balancer?',
        question_type: 'multiple',
        options: JSON.stringify([
          { id: 'a', text: 'Distributes incoming traffic across multiple servers' },
          { id: 'b', text: 'Stores user sessions' },
          { id: 'c', text: 'Caches database queries' },
          { id: 'd', text: 'Monitors system performance' }
        ]),
        correct_answer: JSON.stringify(['a']),
        explanation: 'A load balancer distributes network traffic across multiple servers to ensure no single server is overwhelmed, improving reliability and performance.',
        difficulty: 'easy',
        points: 5,
        time_limit: 60,
        keywords: JSON.stringify(['load balancer', 'distribution', 'scaling']),
        tags: JSON.stringify(['load-balancing', 'architecture', 'fundamentals']),
        is_active: true,
        times_attempted: 0,
        times_correct: 0,
        created_by: adminId,
        created_at: new Date(),
        updated_at: new Date()
      },
      {
        id: uuidv4(),
        category_id: categoryMap['system-design'],
        question_text: 'What is CAP theorem?',
        question_type: 'multiple',
        options: JSON.stringify([
          { id: 'a', text: 'You can only achieve 2 of 3: Consistency, Availability, Partition tolerance' },
          { id: 'b', text: 'All three can be achieved simultaneously' },
          { id: 'c', text: 'A caching strategy' },
          { id: 'd', text: 'A security principle' }
        ]),
        correct_answer: JSON.stringify(['a']),
        explanation: 'CAP theorem states that a distributed system can only guarantee two of three properties: Consistency, Availability, and Partition tolerance.',
        difficulty: 'medium',
        points: 10,
        time_limit: 90,
        keywords: JSON.stringify(['cap', 'theorem', 'distributed systems']),
        tags: JSON.stringify(['distributed-systems', 'theory', 'fundamentals']),
        is_active: true,
        times_attempted: 0,
        times_correct: 0,
        created_by: adminId,
        created_at: new Date(),
        updated_at: new Date()
      },
      {
        id: uuidv4(),
        category_id: categoryMap['system-design'],
        question_text: 'What is caching and why is it used?',
        question_type: 'multiple',
        options: JSON.stringify([
          { id: 'a', text: 'Storing frequently accessed data in fast storage to reduce latency' },
          { id: 'b', text: 'Backing up data' },
          { id: 'c', text: 'Encrypting sensitive data' },
          { id: 'd', text: 'Compressing files' }
        ]),
        correct_answer: JSON.stringify(['a']),
        explanation: 'Caching stores frequently accessed data in fast storage (memory) to reduce database load and improve response times.',
        difficulty: 'easy',
        points: 5,
        time_limit: 60,
        keywords: JSON.stringify(['cache', 'performance', 'latency']),
        tags: JSON.stringify(['caching', 'performance', 'fundamentals']),
        is_active: true,
        times_attempted: 0,
        times_correct: 0,
        created_by: adminId,
        created_at: new Date(),
        updated_at: new Date()
      },
      {
        id: uuidv4(),
        category_id: categoryMap['system-design'],
        question_text: 'What is a microservices architecture?',
        question_type: 'multiple',
        options: JSON.stringify([
          { id: 'a', text: 'Application composed of small, independent services communicating via APIs' },
          { id: 'b', text: 'A very small application' },
          { id: 'c', text: 'A caching strategy' },
          { id: 'd', text: 'A database design pattern' }
        ]),
        correct_answer: JSON.stringify(['a']),
        explanation: 'Microservices architecture structures an application as a collection of loosely coupled, independently deployable services.',
        difficulty: 'medium',
        points: 10,
        time_limit: 90,
        keywords: JSON.stringify(['microservices', 'architecture', 'distributed']),
        tags: JSON.stringify(['microservices', 'architecture', 'patterns']),
        is_active: true,
        times_attempted: 0,
        times_correct: 0,
        created_by: adminId,
        created_at: new Date(),
        updated_at: new Date()
      }
    ];

    // Combine all questions
    questions.push(
      ...jsQuestions,
      ...angularQuestions,
      ...reactQuestions,
      ...nodejsQuestions,
      ...tsQuestions,
      ...sqlQuestions,
      ...systemDesignQuestions
    );

    await queryInterface.bulkInsert('questions', questions, {});
    console.log(`✅ Seeded ${questions.length} demo questions across all categories`);
  },

  async down(queryInterface, Sequelize) {
    await queryInterface.bulkDelete('questions', null, {});
    console.log('✅ Removed demo questions');
  }
};