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);
    }
  }
}