reason-flow/server/utils/databaseManager.js

const { initializeDatabase, resetDatabase, checkDatabaseStatus } = require('./databaseInit');
const { sequelize } = require('../config/database');
const logger = require('./logger');

// Import seeders
const createAdminUser = require('../seeders/001_create_admin_user');
const createSampleTrainingData = require('../seeders/002_create_sample_training_data');

const runMigrations = async () => {
  try {
    console.log('🔄 Running database migrations...');
    
    // Import all migration files
    const migrations = [
      require('../migrations/001_create_users'),
      require('../migrations/002_create_conversations'),
      require('../migrations/003_create_plans'),
      require('../migrations/004_create_messages'),
      require('../migrations/005_create_documents'),
      require('../migrations/006_create_feedback'),
      require('../migrations/007_create_model_versions'),
      require('../migrations/008_create_training_data'),
      require('../migrations/009_create_tool_executions')
    ];

    for (const migration of migrations) {
      console.log(`   Running migration: ${migration.up.name || 'unnamed'}`);
      await migration.up(sequelize.getQueryInterface(), sequelize.constructor);
    }

    console.log('✅ All migrations completed successfully');
    return true;
  } catch (error) {
    console.error('❌ Migration failed:', error);
    logger.error('Migration error:', error);
    return false;
  }
};

const runSeeders = async () => {
  try {
    console.log('🌱 Running database seeders...');
    
    // Run seeders
    await createAdminUser.up(sequelize.getQueryInterface(), sequelize.constructor);
    await createSampleTrainingData.up(sequelize.getQueryInterface(), sequelize.constructor);
    
    console.log('✅ All seeders completed successfully');
    return true;
  } catch (error) {
    console.error('❌ Seeding failed:', error);
    logger.error('Seeding error:', error);
    return false;
  }
};

const setupDatabase = async (options = {}) => {
  try {
    console.log('🚀 Setting up database...');
    
    const { 
      force = false, 
      seed = true, 
      migrations = true 
    } = options;

    // Check database status
    const status = await checkDatabaseStatus();
    if (!status) {
      throw new Error('Database connection failed');
    }

    // Run migrations if requested
    if (migrations) {
      const migrated = await runMigrations();
      if (!migrated) {
        throw new Error('Migrations failed');
      }
    }

    // Run seeders if requested
    if (seed) {
      const seeded = await runSeeders();
      if (!seeded) {
        throw new Error('Seeding failed');
      }
    }

    console.log('🎉 Database setup completed successfully!');
    return true;
  } catch (error) {
    console.error('❌ Database setup failed:', error.message);
    logger.error('Database setup error:', error);
    return false;
  }
};

const getDatabaseInfo = async () => {
  try {
    console.log('📊 Database Information:');
    
    // Get table information
    const [results] = await sequelize.query(`
      SELECT 
        schemaname,
        tablename,
        tableowner
      FROM pg_tables 
      WHERE schemaname = 'public'
      ORDER BY tablename;
    `);

    console.log(`   Tables: ${results.length}`);
    results.forEach(table => {
      console.log(`   - ${table.tablename}`);
    });

    // Get database size
    const [sizeResult] = await sequelize.query(`
      SELECT pg_size_pretty(pg_database_size(current_database())) as size;
    `);
    
    console.log(`   Database size: ${sizeResult[0].size}`);

    return {
      tables: results,
      size: sizeResult[0].size
    };
  } catch (error) {
    console.error('❌ Error getting database info:', error);
    return null;
  }
};

const backupDatabase = async (backupPath) => {
  try {
    console.log('💾 Creating database backup...');
    
    // This would typically use pg_dump in a real implementation
    console.log(`   Backup path: ${backupPath}`);
    console.log('   Note: Implement actual backup logic with pg_dump');
    
    return true;
  } catch (error) {
    console.error('❌ Backup failed:', error);
    return false;
  }
};

// Command line interface
if (require.main === module) {
  const args = process.argv.slice(2);
  const command = args[0] || 'help';
  
  const runCommand = async () => {
    switch (command) {
      case 'init':
        await setupDatabase({ force: false, seed: true, migrations: true });
        break;
      case 'reset':
        await resetDatabase();
        break;
      case 'migrate':
        await runMigrations();
        break;
      case 'seed':
        await runSeeders();
        break;
      case 'status':
        await checkDatabaseStatus();
        break;
      case 'info':
        await getDatabaseInfo();
        break;
      case 'backup':
        const backupPath = args[1] || './backup.sql';
        await backupDatabase(backupPath);
        break;
      case 'help':
      default:
        console.log(`
Database Manager Commands:
  init     - Initialize database with migrations and seeders
  reset    - Reset database (drop and recreate)
  migrate  - Run migrations only
  seed     - Run seeders only
  status   - Check database connection status
  info     - Show database information
  backup   - Create database backup
  help     - Show this help message

Usage: node databaseManager.js [command]
        `);
        break;
    }
  };

  runCommand().then(() => {
    process.exit(0);
  }).catch(error => {
    console.error('Command failed:', error);
    process.exit(1);
  });
}

module.exports = {
  runMigrations,
  runSeeders,
  setupDatabase,
  getDatabaseInfo,
  backupDatabase
};