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

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

const DirectorySchema = new mongoose.Schema({
  name: { type: String, required: true },
  category: { type: String, required: true },
  location: { type: String, required: true },
  lovableScore: { type: Number, default: 0 },
  contact: {
    email: { type: String },
    phone: { type: String }
  },
  metadata: { type: mongoose.Schema.Types.Mixed }
});

const Directory = mongoose.model('Directory', DirectorySchema);

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

app.post('/api/directory', async (req, res) => {
  try {
    const entry = new Directory(req.body);
    await entry.save();
    res.status(201).json(entry);
  } catch (error) {
    res.status(400).json({ error: error.message });
  }
});

app.get('/api/directory/top', async (req, res) => {
  try {
    const { category, location } = req.query;
    const matchFilter = {};
    if (category) matchFilter.category = category;
    if (location) matchFilter.location = location;

    const topEntries = await Directory.aggregate([
      { $match: matchFilter },
      { $sort: { lovableScore: -1 } },
      { $limit: 10 }
    ]);
    res.json(topEntries);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

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

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

app.use(express.json());

// Endpoint to retrieve a directory entry enriched by data from an external Lovable API
app.get('/api/directory/:id/lovable', async (req, res) => {
  try {
    const { id } = req.params;
    
    // Simulate a local directory entry retrieval (in a real scenario, fetch from your database)
    const localEntry = {
      id,
      name: 'Artisan Cafe',
      category: 'Food & Beverage',
      location: 'Downtown'
    };

    // Connect to external Lovable API service to fetch detailed lovable metrics
    const externalApiUrl = `https://api.lovableinfo.com/ratings/${id}`;
    const externalResponse = await axios.get(externalApiUrl, { timeout: 5000 });
    const externalData = externalResponse.data;

    // Combine local and external data into a cohesive entry
    const enrichedEntry = {
      ...localEntry,
      lovableRating: externalData.rating,
      reviews: externalData.reviews
    };

    res.json(enrichedEntry);
  } catch (error) {
    res.status(500).json({ message: 'Error fetching external data', details: error.message });
  }
});

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

const express = require('express');
const { graphqlHTTP } = require('express-graphql');
const { GraphQLSchema, GraphQLObjectType, GraphQLString, GraphQLFloat, GraphQLID } = require('graphql');
const axios = require('axios');

const memoryCache = new Map();

const fetchLovableData = async (id) => {
  if (memoryCache.has(id)) {
    return memoryCache.get(id);
  }
  const res = await axios.get(`https://api.lovableinfo.com/ratings/${id}`, { timeout: 5000 });
  const data = res.data;
  memoryCache.set(id, data);
  return data;
};

const directoryData = {
  "1": { id: "1", name: "Sunrise Bakery", category: "Food & Beverage", location: "Midtown" },
  "2": { id: "2", name: "Urban Studio", category: "Art & Design", location: "Downtown" }
};

const DirectoryType = new GraphQLObjectType({
  name: "Directory",
  fields: {
    id: { type: GraphQLID },
    name: { type: GraphQLString },
    category: { type: GraphQLString },
    location: { type: GraphQLString },
    lovableRating: {
      type: GraphQLFloat,
      resolve: async (parent) => {
        const external = await fetchLovableData(parent.id);
        return external.rating;
      }
    },
    reviewCount: {
      type: GraphQLString,
      resolve: async (parent) => {
        const external = await fetchLovableData(parent.id);
        return external.reviews ? external.reviews.length.toString() : "0";
      }
    }
  }
});

const RootQuery = new GraphQLObjectType({
  name: "RootQueryType",
  fields: {
    directory: {
      type: DirectoryType,
      args: { id: { type: GraphQLID } },
      resolve(parent, args) {
        return directoryData[args.id];
      }
    }
  }
});

const schema = new GraphQLSchema({
  query: RootQuery
});

const app = express();
app.use("/graphql", graphqlHTTP({
  schema,
  graphiql: true
}));

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