const express = require('express');
const helmet = require('helmet');
const cors = require('cors');
const crypto = require('crypto');
const { Pool } = require('pg');
const Joi = require('joi');

const app = express();
const port = process.env.PORT || 3000;

// Database connection
const pool = new Pool({
  connectionString: process.env.DATABASE_URL,
  ssl: process.env.NODE_ENV === 'production' ? { rejectUnauthorized: false } : false
});

// Middleware
app.use(helmet());
app.use(cors());
app.use(express.json({ limit: '10mb' }));

// Load private key
const privateKey = require('fs').readFileSync('./research_private_key.pem', 'utf8');

// Validation schema
const uploadSchema = Joi.object({
  uploadId: Joi.string().uuid().required(),
  participantUuid: Joi.string().uuid().required(),
  researchSite: Joi.string().valid('gauteng').required(),
  encryptedData: Joi.string().base64().required(),
  encryptionMetadata: Joi.object({
    algorithm: Joi.string().required(),
    keySize: Joi.number().required(),
    iv: Joi.string().base64().required(),
    timestamp: Joi.string().isoDate().required()
  }).required(),
  dataPeriod: Joi.object({
    start: Joi.string().isoDate().required(),
    end: Joi.string().isoDate().required()
  }).required()
});

// Upload endpoint
app.post('/api/v1/participant-data', async (req, res) => {
  try {
    // Validate request
    const { error, value } = uploadSchema.validate(req.body);
    if (error) {
      return res.status(400).json({
        success: false,
        error: 'Invalid request format',
        details: error.details
      });
    }

    const { uploadId, participantUuid, researchSite, encryptedData, encryptionMetadata, dataPeriod } = value;

    // Check for duplicate upload
    const existingUpload = await pool.query(
      'SELECT id FROM data_uploads WHERE upload_id = $1',
      [uploadId]
    );
    
    if (existingUpload.rows.length > 0) {
      return res.status(409).json({
        success: false,
        error: 'Upload ID already exists'
      });
    }

    // Store encrypted data
    await pool.query(`
      INSERT INTO data_uploads (
        upload_id, participant_uuid, research_site, encrypted_payload,
        encryption_metadata, data_period_start, data_period_end
      ) VALUES ($1, $2, $3, $4, $5, $6, $7)
    `, [
      uploadId,
      participantUuid,
      researchSite,
      encryptedData,
      JSON.stringify(encryptionMetadata),
      dataPeriod.start,
      dataPeriod.end
    ]);

    // Ensure participant record exists
    await pool.query(`
      INSERT INTO participants (participant_uuid, research_site, last_upload_at)
      VALUES ($1, $2, NOW())
      ON CONFLICT (participant_uuid) 
      DO UPDATE SET last_upload_at = NOW()
    `, [participantUuid, researchSite]);

    res.json({
      success: true,
      uploadId: uploadId,
      receivedAt: new Date().toISOString(),
      message: 'Data uploaded successfully'
    });

  } catch (error) {
    console.error('Upload error:', error);
    res.status(500).json({
      success: false,
      error: 'Internal server error'
    });
  }
});

// Health check endpoint
app.get('/health', (req, res) => {
  res.json({ status: 'healthy', timestamp: new Date().toISOString() });
});

app.listen(port, () => {
  console.log(`Research server listening on port ${port}`);
});

const crypto = require('crypto');
const fs = require('fs');

function decryptUpload(encryptedData, encryptionMetadata, privateKey) {
  try {
    // Parse encrypted payload (format: encrypted_aes_key|encrypted_data)
    const [encryptedAESKey, encryptedPayload] = encryptedData.split('|');
    
    // Decrypt AES key with RSA private key
    const aesKey = crypto.privateDecrypt(
      {
        key: privateKey,
        padding: crypto.constants.RSA_PKCS1_OAEP_PADDING,
        oaepHash: 'sha256'
      },
      Buffer.from(encryptedAESKey, 'base64')
    );

    // Decrypt data with AES key
    const iv = Buffer.from(encryptionMetadata.iv, 'base64');
    const decipher = crypto.createDecipherGCM('aes-256-gcm', aesKey);
    decipher.setIV(iv);
    
    let decrypted = decipher.update(encryptedPayload, 'base64', 'utf8');
    decrypted += decipher.final('utf8');
    
    return JSON.parse(decrypted);
  } catch (error) {
    throw new Error(`Decryption failed: ${error.message}`);
  }
}

// Example usage
async function processUploads() {
  const privateKey = fs.readFileSync('./research_private_key.pem', 'utf8');
  
  const uploads = await pool.query(
    'SELECT * FROM data_uploads WHERE processed = FALSE ORDER BY upload_timestamp'
  );
  
  for (const upload of uploads.rows) {
    try {
      const decryptedData = decryptUpload(
        upload.encrypted_payload,
        upload.encryption_metadata,
        privateKey
      );
      
      // Store surveys
      for (const survey of decryptedData.surveys) {
        await pool.query(`
          INSERT INTO survey_responses (
            participant_uuid, survey_type, response_data, submitted_at, upload_id
          ) VALUES ($1, $2, $3, $4, $5)
        `, [
          upload.participant_uuid,
          survey.type,
          JSON.stringify(survey.responses),
          survey.submittedAt,
          upload.upload_id
        ]);
      }
      
      // Store location tracks
      for (const track of decryptedData.locationTracks) {
        await pool.query(`
          INSERT INTO location_tracks (
            participant_uuid, latitude, longitude, accuracy, recorded_at, upload_id
          ) VALUES ($1, $2, $3, $4, $5, $6)
        `, [
          upload.participant_uuid,
          track.latitude,
          track.longitude,
          track.accuracy,
          track.timestamp,
          upload.upload_id
        ]);
      }
      
      // Mark as processed
      await pool.query(
        'UPDATE data_uploads SET processed = TRUE, processed_at = NOW() WHERE id = $1',
        [upload.id]
      );
      
      console.log(`Processed upload ${upload.upload_id}`);
      
    } catch (error) {
      console.error(`Failed to process upload ${upload.upload_id}:`, error);
    }
  }
}

// scripts/add-participant-codes.js
const crypto = require('crypto');
const { Pool } = require('pg');

const pool = new Pool({
  connectionString: process.env.DATABASE_URL
});

// Function to hash participant codes
function hashCode(code) {
  return crypto.createHash('sha256').update(code.trim().toUpperCase()).digest('hex');
}

// Add a single participant code
async function addParticipantCode(plainCode, studySite, notes = null) {
  const hashedCode = hashCode(plainCode);
  
  try {
    const result = await pool.query(
      'INSERT INTO participant_codes (hashed_code, study_site, notes) VALUES ($1, $2, $3) RETURNING id',
      [hashedCode, studySite, notes]
    );
    
    console.log(`✅ Added participant code for ${studySite}: ${plainCode.substring(0, 3)}*** (ID: ${result.rows[0].id})`);
    return result.rows[0].id;
  } catch (error) {
    if (error.code === '23505') { // Unique violation
      console.log(`⚠️  Code already exists: ${plainCode.substring(0, 3)}***`);
    } else {
      console.error(`❌ Error adding code: ${error.message}`);
    }
    throw error;
  }
}

// Bulk add participant codes from array
async function bulkAddCodes(codes, studySite) {
  const results = {
    added: 0,
    skipped: 0,
    errors: 0
  };
  
  for (const code of codes) {
    try {
      await addParticipantCode(code, studySite);
      results.added++;
    } catch (error) {
      if (error.code === '23505') {
        results.skipped++;
      } else {
        results.errors++;
      }
    }
  }
  
  console.log(`\n📊 Bulk import results:
  ✅ Added: ${results.added}
  ⚠️  Skipped (duplicates): ${results.skipped}
  ❌ Errors: ${results.errors}`);
  
  return results;
}

// Example usage
async function main() {
  // Add individual codes
  await addParticipantCode('GTNG001', 'gauteng', 'Pilot participant');
  await addParticipantCode('GTNG002', 'gauteng', 'Recruitment batch 1');
  
  // Bulk add codes
  const gautengCodes = [
    'GTNG003', 'GTNG004', 'GTNG005', 'GTNG006', 'GTNG007',
    'GTNG008', 'GTNG009', 'GTNG010', 'GTNG011', 'GTNG012'
  ];
  
  await bulkAddCodes(gautengCodes, 'gauteng');
  
  await pool.end();
}

// Run if called directly
if (require.main === module) {
  main().catch(console.error);
}

module.exports = { addParticipantCode, bulkAddCodes, hashCode };

// scripts/manage-codes.js
const { Pool } = require('pg');

const pool = new Pool({
  connectionString: process.env.DATABASE_URL
});

// List all participant codes
async function listCodes(studySite = null, activeOnly = true) {
  let query = 'SELECT id, hashed_code, study_site, created_at, is_active, notes FROM participant_codes';
  let params = [];
  
  const conditions = [];
  if (studySite) {
    conditions.push('study_site = $' + (params.length + 1));
    params.push(studySite);
  }
  if (activeOnly) {
    conditions.push('is_active = $' + (params.length + 1));
    params.push(true);
  }
  
  if (conditions.length > 0) {
    query += ' WHERE ' + conditions.join(' AND ');
  }
  
  query += ' ORDER BY created_at DESC';
  
  const result = await pool.query(query, params);
  return result.rows;
}

// Deactivate a participant code
async function deactivateCode(hashedCode) {
  const result = await pool.query(
    'UPDATE participant_codes SET is_active = FALSE WHERE hashed_code = $1 RETURNING id',
    [hashedCode]
  );
  
  if (result.rows.length > 0) {
    console.log(`✅ Deactivated code (ID: ${result.rows[0].id})`);
  } else {
    console.log('❌ Code not found');
  }
}

// Get participant statistics
async function getParticipantStats() {
  const stats = await pool.query(`
    SELECT 
      pc.study_site,
      COUNT(pc.id) as total_codes,
      COUNT(CASE WHEN pc.is_active THEN 1 END) as active_codes,
      COUNT(cr.id) as consented_participants,
      ROUND(
        (COUNT(cr.id)::float / COUNT(CASE WHEN pc.is_active THEN 1 END)) * 100, 
        2
      ) as consent_rate_percent
    FROM participant_codes pc
    LEFT JOIN consent_records cr ON pc.hashed_code = cr.hashed_participant_code
    GROUP BY pc.study_site
    ORDER BY pc.study_site
  `);
  
  return stats.rows;
}

// Recent consent activity
async function getRecentActivity(days = 7) {
  const activity = await pool.query(`
    SELECT 
      DATE(consent_timestamp) as consent_date,
      COUNT(*) as consents_given
    FROM consent_records 
    WHERE consent_timestamp >= NOW() - INTERVAL '${days} days'
    GROUP BY DATE(consent_timestamp)
    ORDER BY consent_date DESC
  `);
  
  return activity.rows;
}

module.exports = {
  listCodes,
  deactivateCode,
  getParticipantStats,
  getRecentActivity
};