const express = require('express');
const bodyParser = require('body-parser');
const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost:27017/lovable_medical_records', {
  useNewUrlParser: true,
  useUnifiedTopology: true
});

const patientSchema = new mongoose.Schema({
  firstName: String,
  lastName: String,
  dob: Date,
  medicalHistory: [{
    date: Date,
    description: String,
    doctor: String,
    notes: String
  }],
  createdAt: { type: Date, default: Date.now }
});

const Patient = mongoose.model('Patient', patientSchema);

const app = express();
app.use(bodyParser.json());

app.post('/api/patients', async (req, res) => {
  try {
    const newPatient = new Patient(req.body);
    await newPatient.save();
    res.status(201).json(newPatient);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

app.get('/api/patients/:id', async (req, res) => {
  try {
    const patient = await Patient.findById(req.params.id);
    if (!patient) {
      return res.status(404).json({ error: 'Patient not found' });
    }
    patient.medicalHistory.sort((a, b) => b.date - a.date);
    res.json(patient);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

app.put('/api/patients/:id/medicalHistory', async (req, res) => {
  try {
    const patient = await Patient.findById(req.params.id);
    if (!patient) {
      return res.status(404).json({ error: 'Patient not found' });
    }
    patient.medicalHistory.push(req.body);
    await patient.save();
    res.json(patient);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => console.log(`Server running on port ${PORT}`));

const express = require('express');
const axios = require('axios');

const app = express();
app.use(express.json());

// Endpoint to verify a patient's insurance and update their record on Lovable platform.
app.post('/api/verify-insurance', async (req, res) => {
  try {
    const { patientId, insuranceNumber } = req.body;
    
    // Call an external Insurance API to verify the provided insurance number.
    const insuranceResponse = await axios.post('https://api.externalinsurance.com/verify', {
      insuranceNumber
    });
    
    if (insuranceResponse.data && insuranceResponse.data.status === 'verified') {
      // After successful verification, update the patient's record on Lovable via its external API.
      const updateResponse = await axios.put(`https://api.lovable.com/patients/${patientId}/insurance`, {
        verified: true,
        provider: insuranceResponse.data.provider,
        planDetails: insuranceResponse.data.planDetails
      });
      
      return res.json({
        success: true,
        message: 'Insurance verified and patient record updated successfully.',
        data: updateResponse.data
      });
    } else {
      return res.status(400).json({
        success: false,
        message: 'Insurance verification failed.'
      });
    }
  } catch (error) {
    return res.status(500).json({
      success: false,
      message: 'An error occurred during the verification process.',
      error: error.message
    });
  }
});

const PORT = process.env.PORT || 4000;
app.listen(PORT, () => console.log(`Server is running on port ${PORT}`));

const express = require('express');
const axios = require('axios');
const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost:27017/lovable_medical_records', {
  useNewUrlParser: true,
  useUnifiedTopology: true
});

const patientSchema = new mongoose.Schema({
  firstName: String,
  lastName: String,
  dob: Date,
  medicalHistory: [{
    date: Date,
    description: String,
    doctor: String
  }],
  lovId: String,
  createdAt: { type: Date, default: Date.now }
});

const Patient = mongoose.model('Patient', patientSchema);

const app = express();
app.use(express.json());

app.post('/api/merge-patients', async (req, res) => {
  try {
    const { primaryId, duplicateId } = req.body;
    const primaryPatient = await Patient.findById(primaryId);
    const duplicatePatient = await Patient.findById(duplicateId);
    
    if (!primaryPatient || !duplicatePatient) {
      return res.status(404).json({ error: 'One or both patients not found' });
    }
    
    // Merge medical histories by avoiding duplicate entries.
    const historyMap = new Map();
    primaryPatient.medicalHistory.forEach(record => {
      historyMap.set(record.date.toISOString() + record.description, record);
    });
    
    duplicatePatient.medicalHistory.forEach(record => {
      const key = record.date.toISOString() + record.description;
      if (!historyMap.has(key)) {
        primaryPatient.medicalHistory.push(record);
      }
    });
    
    await primaryPatient.save();
    await Patient.findByIdAndDelete(duplicateId);
    
    // Notify the Lovable central system about the merge.
    await axios.post('https://api.lovable.com/patients/merge', {
      primaryLovId: primaryPatient.lovId,
      mergedLovId: duplicatePatient.lovId
    });
    
    res.json(primaryPatient);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

const PORT = process.env.PORT || 5000;
app.listen(PORT, () => console.log(`Server running on port ${PORT}`));