Magic Deck App Plan

     I need assistance with the following features for my draft navigator overlay app:
     1. Synergy Score Calculator
        - Real-time calculation based on drafted cards
        - Factors in card interactions and archetype fit
     2. Mana Curve Tracker
        - Visual representation of mana costs
        - Alerts for curve imbalances
     

     mkdir draft-navigator-backend
     cd draft-navigator-backend
     npm init -y
     

     npm install express axios dotenv express-rate-limit winston
     

     PORT=3000
     SEVENTEENLANDS_API_KEY=your_17lands_api_key
     SEVENTEENLANDS_API_URL=https://api.17lands.com/v1
     RATE_LIMIT_WINDOW_MS=60000
     RATE_LIMIT_MAX=60
     

     // index.js
     require('dotenv').config();
     const express = require('express');
     const axios = require('axios');
     const rateLimit = require('express-rate-limit');
     const winston = require('winston');

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

     // Configure Winston Logger
     const logger = winston.createLogger({
       level: 'info',
       format: winston.format.combine(
         winston.format.timestamp(),
         winston.format.json()
       ),
       transports: [
         new winston.transports.Console(),
         new winston.transports.File({ filename: 'error.log', level: 'error' }),
         new winston.transports.File({ filename: 'combined.log' }),
       ],
     });

     // Rate Limiting Middleware
     const limiter = rateLimit({
       windowMs: parseInt(process.env.RATE_LIMIT_WINDOW_MS) || 60000, // 1 minute
       max: parseInt(process.env.RATE_LIMIT_MAX) || 60, // limit each IP to 60 requests per windowMs
       message: 'Too many requests from this IP, please try again after a minute.',
       handler: (req, res, next, options) => {
         logger.warn(Rate limit exceeded for IP: ${req.ip});
         res.status(options.statusCode).json({ message: options.message });
       },
     });

     app.use(limiter);

     // 17lands API Service
     const seventeenLandsAPI = axios.create({
       baseURL: process.env.SEVENTEENLANDS_API_URL,
       headers: {
         'Authorization': Bearer ${process.env.SEVENTEENLANDS_API_KEY},
         'Content-Type': 'application/json',
       },
       timeout: 5000, // 5 seconds timeout
     });

     // Endpoint to Fetch Win Rates and ALSA Data for a Specific Card
     app.get('/api/cards/:cardName/stats', async (req, res) => {
       const { cardName } = req.params;
       try {
         const response = await seventeenLandsAPI.get(/cards/${encodeURIComponent(cardName)}/stats);
         res.json(response.data);
       } catch (error) {
         if (error.response) {
           // API responded with a status outside 2xx
           logger.error(17lands API Error: ${error.response.status} - ${error.response.data});
           res.status(error.response.status).json({ message: error.response.data });
         } else if (error.request) {
           // No response received
           logger.error(17lands API No Response: ${error.message});
           res.status(503).json({ message: '17lands API is unavailable. Please try again later.' });
         } else {
           // Other errors
           logger.error(Error fetching 17lands data: ${error.message});
           res.status(500).json({ message: 'Internal Server Error' });
         }
       }
     });

     // Start the Server
     app.listen(PORT, () => {
       logger.info(17lands API Service running on port ${PORT});
     });
     

     node index.js
     

     curl http://localhost:3000/api/cards/Black%20Lotus/stats
     

     mkdir draft-navigator-scryfall
     cd draft-navigator-scryfall
     

     python3 -m venv venv
     source venv/bin/activate
     

     pip install requests redis python-dotenv
     

     SCRYFALL_API_URL=https://api.scryfall.com
     REDIS_HOST=localhost
     REDIS_PORT=6379
     REDIS_DB=0
     REDIS_PASSWORD=your_redis_password_if_any
     CACHE_EXPIRATION=86400  # 24 hours in seconds
     

     # scryfall_fetcher.py
     import os
     import requests
     import redis
     import json
     from dotenv import load_dotenv

     # Load environment variables
     load_dotenv()

     SCRYFALL_API_URL = os.getenv('SCRYFALL_API_URL', 'https://api.scryfall.com')
     REDIS_HOST = os.getenv('REDIS_HOST', 'localhost')
     REDIS_PORT = int(os.getenv('REDIS_PORT', 6379))
     REDIS_DB = int(os.getenv('REDIS_DB', 0))
     REDIS_PASSWORD = os.getenv('REDIS_PASSWORD', None)
     CACHE_EXPIRATION = int(os.getenv('CACHE_EXPIRATION', 86400))  # 24 hours

     # Initialize Redis client
     try:
         if REDIS_PASSWORD:
             cache = redis.StrictRedis(host=REDIS_HOST, port=REDIS_PORT, db=REDIS_DB, password=REDIS_PASSWORD, decode_responses=True)
         else:
             cache = redis.StrictRedis(host=REDIS_HOST, port=REDIS_PORT, db=REDIS_DB, decode_responses=True)
         # Test connection
         cache.ping()
         print("Connected to Redis successfully.")
     except redis.ConnectionError as e:
         print(f"Redis connection error: {e}")
         exit(1)

     def fetch_card_data(card_name):
         """
         Fetch detailed card information from Scryfall API.
         """
         # Check if data is cached
         cache_key = f"scryfall:card:{card_name.lower()}"
         cached_data = cache.get(cache_key)
         if cached_data:
             print(f"Cache hit for card: {card_name}")
             return json.loads(cached_data)
         
         print(f"Cache miss for card: {card_name}. Fetching from Scryfall API.")
         try:
             response = requests.get(f"{SCRYFALL_API_URL}/cards/named", params={'fuzzy': card_name}, timeout=10)
             response.raise_for_status()
             card_data = response.json()
             
             # Cache the response
             cache.setex(cache_key, CACHE_EXPIRATION, json.dumps(card_data))
             
             return card_data
         except requests.exceptions.HTTPError as http_err:
             print(f"HTTP error occurred: {http_err} - {response.text}")
             return None
         except requests.exceptions.RequestException as err:
             print(f"Error fetching card data: {err}")
             return None

     def main():
         # Example usage
         card_names = [
             "Black Lotus",
             "Sol Ring",
             "Time Walk",
             "Mox Sapphire",
             "Lightning Bolt"
         ]

         for card in card_names:
             data = fetch_card_data(card)
             if data:
                 print(f"Card: {data['name']}")
                 print(f"Mana Cost: {data.get('mana_cost', 'N/A')}")
                 print(f"Type Line: {data.get('type_line', 'N/A')}")
                 print(f"Oracle Text: {data.get('oracle_text', 'N/A')}")
                 print(f"Image URL: {data['image_uris']['normal'] if 'image_uris' in data else 'N/A'}")
                 print("-" * 40)
             else:
                 print(f"Failed to fetch data for card: {card}")
                 print("-" * 40)

     if __name__ == "__main__":
         main()
     

     # On macOS using Homebrew
     brew install redis
     brew services start redis

     # On Ubuntu/Debian
     sudo apt-get install redis-server
     sudo systemctl enable redis-server.service
     sudo systemctl start redis-server.service
     

     python scryfall_fetcher.py
     

     Connected to Redis successfully.
     Cache miss for card: Black Lotus. Fetching from Scryfall API.
     Card: Black Lotus
     Mana Cost: {0}
     Type Line: Artifact
     Oracle Text: {T}, Sacrifice Black Lotus: Add three mana of any one color.
     Image URL: https://c1.scryfall.com/file/scryfall-cards/normal/front/5/3/534ed3e0-f8b6-4bf4-86f6-38fa6059e8de.jpg?1687522176
     ----------------------------------------
     Cache miss for card: Sol Ring. Fetching from Scryfall API.
     Card: Sol Ring
     Mana Cost: {1}
     Type Line: Artifact
     Oracle Text: {T}: Add {C}{C}.
     Image URL: https://c1.scryfall.com/file/scryfall-cards/normal/front/c/a/ca10d63c-a6c2-4f23-ae63-879678d6c3e5.jpg?1687522180
     ----------------------------------------
     Cache miss for card: Time Walk. Fetching from Scryfall API.
     Card: Time Walk
     Mana Cost: {1}{U}
     Type Line: Sorcery
     Oracle Text: Take an extra turn after this one.
     Image URL: https://c1.scryfall.com/file/scryfall-cards/normal/front/0/2/02ef6a24-2d93-4a32-8c5c-71e4bf5c7856.jpg?1687522184
     ----------------------------------------
     Cache miss for card: Mox Sapphire. Fetching from Scryfall API.
     Card: Mox Sapphire
     Mana Cost: {0}
     Type Line: Artifact
     Oracle Text: {T}: Add {U}.
     Image URL: https://c1.scryfall.com/file/scryfall-cards/normal/front/a/c/acb0ddc5-bb8c-4cd3-9a4b-a4ab6dd4b3b4.jpg?1687522188
     ----------------------------------------
     Cache miss for card: Lightning Bolt. Fetching from Scryfall API.
     Card: Lightning Bolt
     Mana Cost: {R}
     Type Line: Instant
     Oracle Text: Lightning Bolt deals 3 damage to any target.
     Image URL: https://c1.scryfall.com/file/scryfall-cards/normal/front/9/0/90c1a6b3-cfd5-4c4b-9f93-49b6797a90b5.jpg?1687522192
     ----------------------------------------
     

   npm install socket.io
   

   // index.js
   require('dotenv').config();
   const express = require('express');
   const axios = require('axios');
   const rateLimit = require('express-rate-limit');
   const winston = require('winston');
   const http = require('http');
   const { Server } = require('socket.io');

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

   // Configure Winston Logger
   const logger = winston.createLogger({
     level: 'info',
     format: winston.format.combine(
       winston.format.timestamp(),
       winston.format.json()
     ),
     transports: [
       new winston.transports.Console(),
       new winston.transports.File({ filename: 'error.log', level: 'error' }),
       new winston.transports.File({ filename: 'combined.log' }),
     ],
   });

   // Rate Limiting Middleware
   const limiter = rateLimit({
     windowMs: parseInt(process.env.RATE_LIMIT_WINDOW_MS) || 60000, // 1 minute
     max: parseInt(process.env.RATE_LIMIT_MAX) || 60, // limit each IP to 60 requests per windowMs
     message: 'Too many requests from this IP, please try again after a minute.',
     handler: (req, res, next, options) => {
       logger.warn(Rate limit exceeded for IP: ${req.ip});
       res.status(options.statusCode).json({ message: options.message });
     },
   });

   app.use(limiter);

   // 17lands API Service
   const seventeenLandsAPI = axios.create({
     baseURL: process.env.SEVENTEENLANDS_API_URL,
     headers: {
       'Authorization': Bearer ${process.env.SEVENTEENLANDS_API_KEY},
       'Content-Type': 'application/json',
     },
     timeout: 5000, // 5 seconds timeout
   });

   // Endpoint to Fetch Win Rates and ALSA Data for a Specific Card
   app.get('/api/cards/:cardName/stats', async (req, res) => {
     const { cardName } = req.params;
     try {
       const response = await seventeenLandsAPI.get(/cards/${encodeURIComponent(cardName)}/stats);
       res.json(response.data);
     } catch (error) {
       if (error.response) {
         // API responded with a status outside 2xx
         logger.error(17lands API Error: ${error.response.status} - ${error.response.data});
         res.status(error.response.status).json({ message: error.response.data });
       } else if (error.request) {
         // No response received
         logger.error(17lands API No Response: ${error.message});
         res.status(503).json({ message: '17lands API is unavailable. Please try again later.' });
       } else {
         // Other errors
         logger.error(Error fetching 17lands data: ${error.message});
         res.status(500).json({ message: 'Internal Server Error' });
       }
     }
   });

   // Create HTTP Server
   const server = http.createServer(app);

   // Initialize Socket.IO Server
   const io = new Server(server, {
     cors: {
       origin: '*', // Adjust this in production for security
       methods: ['GET', 'POST'],
     },
   });

   // Handle Socket.IO Connections
   io.on('connection', (socket) => {
     logger.info(New client connected: ${socket.id});

     // Example: Listen for a custom event from the client
     socket.on('joinDraft', (draftId) => {
       socket.join(draft_${draftId});
       logger.info(Socket ${socket.id} joined draft_${draftId});
     });

     // Handle disconnection
     socket.on('disconnect', () => {
       logger.info(Client disconnected: ${socket.id});
     });
   });

   // Function to Broadcast Updates to a Specific Draft Room
   const broadcastDraftUpdate = (draftId, updateData) => {
     io.to(draft_${draftId}).emit('draftUpdate', updateData);
     logger.info(Broadcasted update to draft_${draftId});
   };

   // Example Endpoint to Trigger a Draft Update (For Testing)
   app.post('/api/drafts/:id/update', express.json(), (req, res) => {
     const { id } = req.params;
     const updateData = req.body; // Expecting JSON data

     broadcastDraftUpdate(id, updateData);

     res.json({ message: 'Draft update broadcasted successfully.' });
   });

   // Start the Server
   server.listen(PORT, () => {
     logger.info(17lands API Service with WebSocket running on port ${PORT});
   });
   

     node index.js
     

     <!-- index.html -->
     <!DOCTYPE html>
     <html lang="en">
     <head>
       <meta charset="UTF-8">
       <meta http-equiv="X-UA-Compatible" content="IE=edge">
       <meta name="viewport" content="width=device-width, initial-scale=1.0">
       <title>Socket.IO Test</title>
       <script src="https://cdn.socket.io/4.4.1/socket.io.min.js"></script>
     </head>
     <body>
       <h1>Socket.IO Client Test</h1>
       <script>
         const socket = io('http://localhost:3000');

         socket.on('connect', () => {
           console.log('Connected to WebSocket server');
           // Join a draft room (e.g., draft ID 123)
           socket.emit('joinDraft', '123');
         });

         socket.on('draftUpdate', (data) => {
           console.log('Received draft update:', data);
         });

         socket.on('disconnect', () => {
           console.log('Disconnected from WebSocket server');
         });
       </script>
     </body>
     </html>
     

     curl -X POST http://localhost:3000/api/drafts/123/update \
     -H "Content-Type: application/json" \
     -d '{"currentPick": "Black Lotus", "pickedBy": "Player1"}'
     

       Received draft update: {currentPick: "Black Lotus", pickedBy: "Player1"}
       

     mkdir routes
     touch routes/drafts.js
     

     // routes/drafts.js
     const express = require('express');
     const router = express.Router();
     const { Draft, DraftedCard, SynergyScore, User, DeckComposition } = require('../models'); // Assuming Sequelize models are defined
     const { Op } = require('sequelize');
     const winston = require('winston');

     // GET /api/drafts/:id - Get draft details
     router.get('/:id', async (req, res) => {
       const { id } = req.params;
       try {
         const draft = await Draft.findByPk(id, {
           include: [
             {
               model: DraftedCard,
               include: ['Card'], // Assuming DraftedCard is associated with Card model
             },
             {
               model: DeckComposition,
               include: ['SynergyScore'],
             },
           ],
         });

         if (!draft) {
           return res.status(404).json({ message: 'Draft not found.' });
         }

         res.json(draft);
       } catch (error) {
         winston.error(Error fetching draft ${id}: ${error.message});
         res.status(500).json({ message: 'Internal Server Error' });
       }
     });

     // GET /api/drafts/:id/picks - Get current picks for a draft
     router.get('/:id/picks', async (req, res) => {
       const { id } = req.params;
       try {
         const picks = await DraftedCard.findAll({
           where: { draft_id: id },
           order: [['pick_number', 'ASC']],
           include: ['Card'],
         });

         res.json(picks);
       } catch (error) {
         winston.error(Error fetching picks for draft ${id}: ${error.message});
         res.status(500).json({ message: 'Internal Server Error' });
       }
     });

     // GET /api/drafts/:id/available-cards - Get available cards for the next pick
     router.get('/:id/available-cards', async (req, res) => {
       const { id } = req.params;
       try {
         // Assuming there's a DraftSession model tracking available cards
         const availableCards = await AvailableCard.findAll({
           where: { draft_id: id },
           include: ['Card'],
         });

         res.json(availableCards);
       } catch (error) {
         winston.error(Error fetching available cards for draft ${id}: ${error.message});
         res.status(500).json({ message: 'Internal Server Error' });
       }
     });

     // GET /api/drafts/:id/metrics - Get user-specific metrics for a draft
     router.get('/:id/metrics', async (req, res) => {
       const { id } = req.params;
       try {
         // Example metrics: synergy score, mana curve balance, etc.
         const deckComposition = await DeckComposition.findOne({
           where: { draft_id: id },
           include: ['SynergyScore'],
         });

         if (!deckComposition) {
           return res.status(404).json({ message: 'Deck composition not found for this draft.' });
         }

         res.json(deckComposition);
       } catch (error) {
         winston.error(Error fetching metrics for draft ${id}: ${error.message});
         res.status(500).json({ message: 'Internal Server Error' });
       }
     });

     module.exports = router;
     

     // index.js (continued)
     const draftsRouter = require('./routes/drafts');

     // Use the drafts router for /api/drafts routes
     app.use('/api/drafts', draftsRouter);
     

     mkdir models
     touch models/index.js models/user.js models/draft.js models/draftedCard.js models/card.js models/deckComposition.js models/synergyScore.js models/availableCard.js
     

     // models/user.js
     module.exports = (sequelize, DataTypes) => {
       const User = sequelize.define('User', {
         id: {
           type: DataTypes.INTEGER,
           primaryKey: true,
           autoIncrement: true,
         },
         username: {
           type: DataTypes.STRING,
           allowNull: false,
           unique: true,
         },
         email: {
           type: DataTypes.STRING,
           allowNull: false,
           unique: true,
           validate: {
             isEmail: true,
           },
         },
         password_hash: {
           type: DataTypes.STRING,
           allowNull: false,
         },
         created_at: {
           type: DataTypes.DATE,
           defaultValue: DataTypes.NOW,
         },
         updated_at: {
           type: DataTypes.DATE,
           defaultValue: DataTypes.NOW,
         },
       }, {
         tableName: 'users',
         timestamps: false,
       });

       User.associate = (models) => {
         User.hasMany(models.Draft, { foreignKey: 'user_id' });
       };

       return User;
     };
     

     // models/index.js
     const fs = require('fs');
     const path = require('path');
     const Sequelize = require('sequelize');
     const basename = path.basename(__filename);
     const env = process.env.NODE_ENV || 'development';
     const config = require(__dirname + '/../config/config.json')[env];
     const db = {};

     let sequelize;
     if (config.use_env_variable) {
       sequelize = new Sequelize(process.env[config.use_env_variable], config);
     } else {
       sequelize = new Sequelize(config.database, config.username, config.password, config);
     }

     fs
       .readdirSync(__dirname)
       .filter(file => {
         return (file.indexOf('.') !== 0) && (file !== basename) && (file.slice(-3) === '.js');
       })
       .forEach(file => {
         const model = require(path.join(__dirname, file))(sequelize, Sequelize.DataTypes);
         db[model.name] = model;
       });

     Object.keys(db).forEach(modelName => {
       if (db[modelName].associate) {
         db[modelName].associate(db);
       }
     });

     db.sequelize = sequelize;
     db.Sequelize = Sequelize;

     module.exports = db;
     

     // config/config.json
     {
       "development": {
         "username": "your_db_username",
         "password": "your_db_password",
         "database": "draft_navigator_dev",
         "host": "127.0.0.1",
         "dialect": "postgres"
       },
       "test": {
         "username": "your_db_username",
         "password": "your_db_password",
         "database": "draft_navigator_test",
         "host": "127.0.0.1",
         "dialect": "postgres"
       },
       "production": {
         "username": "your_db_username",
         "password": "your_db_password",
         "database": "draft_navigator_prod",
         "host": "127.0.0.1",
         "dialect": "postgres"
       }
     }
     

     npm install --save-dev sequelize-cli
     

     npx sequelize-cli init
     

     npx sequelize-cli model:generate --name User --attributes username:string,email:string,password_hash:string,created_at:date,updated_at:date
     npx sequelize-cli model:generate --name Draft --attributes user_id:integer,status:string,started_at:date,completed_at:date,metadata:json
     npx sequelize-cli model:generate --name DraftedCard --attributes draft_id:integer,card_id:integer,pick_number:integer,position:string,timestamp:date
     npx sequelize-cli model:generate --name DeckComposition --attributes draft_id:integer,archetype:string,synergy_score:float,mana_curve:json
     npx sequelize-cli model:generate --name SynergyScore --attributes deck_composition_id:integer,card_id:integer,synergy_score:float,updated_at:date
     npx sequelize-cli model:generate --name AvailableCard --attributes draft_id:integer,card_id:integer
     

       npx sequelize-cli db:migrate
       

       npm install jsonwebtoken bcrypt
       

         // middleware/auth.js
         const jwt = require('jsonwebtoken');
         const winston = require('winston');

         const authenticateToken = (req, res, next) => {
           const authHeader = req.headers['authorization'];
           const token = authHeader && authHeader.split(' ')[1];

           if (!token) {
             return res.sendStatus(401); // Unauthorized
           }

           jwt.verify(token, process.env.JWT_SECRET, (err, user) => {
             if (err) {
               winston.error(JWT Verification Error: ${err.message});
               return res.sendStatus(403); // Forbidden
             }
             req.user = user;
             next();
           });
         };

         module.exports = authenticateToken;
         

         const authenticateToken = require('../middleware/auth');

         // Apply authentication middleware to all routes in this router
         router.use(authenticateToken);

         // ... existing route handlers
         

         JWT_SECRET=your_jwt_secret_key
         

       curl -H "Authorization: Bearer your_jwt_token" http://localhost:3000/api/drafts/1
       

       curl -H "Authorization: Bearer your_jwt_token" http://localhost:3000/api/drafts/1/picks
       

       curl -H "Authorization: Bearer your_jwt_token" http://localhost:3000/api/drafts/1/available-cards
       

       curl -H "Authorization: Bearer your_jwt_token" http://localhost:3000/api/drafts/1/metrics
       

     mkdir draft-navigator-log-parser
     cd draft-navigator-log-parser
     

     python3 -m venv venv
     source venv/bin/activate
     

     pip install watchdog psycopg2-binary sqlalchemy python-dotenv
     

     LOG_DIRECTORY=/path/to/MTG Arena/logs
     DATABASE_URL=postgresql://username:password@localhost:5432/draft_navigator_dev
     

     # models.py
     from sqlalchemy import Column, Integer, String, Float, DateTime, ForeignKey, JSON
     from sqlalchemy.ext.declarative import declarative_base
     from sqlalchemy.orm import relationship

     Base = declarative_base()

     class Draft(Base):
         __tablename__ = 'drafts'
         id = Column(Integer, primary_key=True)
         user_id = Column(Integer, ForeignKey('users.id'))
         status = Column(String)
         started_at = Column(DateTime)
         completed_at = Column(DateTime)
         metadata = Column(JSON)

         drafted_cards = relationship('DraftedCard', back_populates='draft')
         deck_composition = relationship('DeckComposition', back_populates='draft')

     class DraftedCard(Base):
         __tablename__ = 'drafted_cards'
         id = Column(Integer, primary_key=True)
         draft_id = Column(Integer, ForeignKey('drafts.id'))
         card_id = Column(Integer, ForeignKey('cards.id'))
         pick_number = Column(Integer)
         position = Column(String)
         timestamp = Column(DateTime)

         draft = relationship('Draft', back_populates='drafted_cards')
         card = relationship('Card', back_populates='drafted_cards')

     class DeckComposition(Base):
         __tablename__ = 'deck_compositions'
         id = Column(Integer, primary_key=True)
         draft_id = Column(Integer, ForeignKey('drafts.id'))
         archetype = Column(String)
         synergy_score = Column(Float)
         mana_curve = Column(JSON)

         draft = relationship('Draft', back_populates='deck_composition')
         synergy_scores = relationship('SynergyScore', back_populates='deck_composition')

     class SynergyScore(Base):
         __tablename__ = 'synergy_scores'
         id = Column(Integer, primary_key=True)
         deck_composition_id = Column(Integer, ForeignKey('deck_compositions.id'))
         card_id = Column(Integer, ForeignKey('cards.id'))
         synergy_score = Column(Float)
         updated_at = Column(DateTime)

         deck_composition = relationship('DeckComposition', back_populates='synergy_scores')
         card = relationship('Card', back_populates='synergy_scores')

     class Card(Base):
         __tablename__ = 'cards'
         id = Column(Integer, primary_key=True)
         name = Column(String, unique=True)
         mana_cost = Column(String)
         type_line = Column(String)
         oracle_text = Column(String)
         image_url = Column(String)

         drafted_cards = relationship('DraftedCard', back_populates='card')
         synergy_scores = relationship('SynergyScore', back_populates='card')
     

     # log_parser.py
     import os
     import json
     import time
     from watchdog.observers import Observer
     from watchdog.events import FileSystemEventHandler
     from sqlalchemy import create_engine
     from sqlalchemy.orm import sessionmaker
     from models import Base, Draft, DraftedCard, Card
     from datetime import datetime
     from dotenv import load_dotenv

     load_dotenv()

     LOG_DIRECTORY = os.getenv('LOG_DIRECTORY')
     DATABASE_URL = os.getenv('DATABASE_URL')

     engine = create_engine(DATABASE_URL)
     Session = sessionmaker(bind=engine)
     session = Session()

     class MTGArenaLogHandler(FileSystemEventHandler):
         def on_modified(self, event):
             if event.is_directory:
                 return
             if not event.src_path.endswith('.json'):
                 return
             with open(event.src_path, 'r') as f:
                 try:
                     logs = f.readlines()
                     for line in logs:
                         log_entry = json.loads(line)
                         self.process_log_entry(log_entry)
                 except json.JSONDecodeError as e:
                     print(f"JSON decode error: {e}")

         def process_log_entry(self, log_entry):
             # Example: Process only 'draft_picked' events
             if log_entry.get('type') == 'draft_picked':
                 draft_id = log_entry.get('draft_id')
                 user_id = log_entry.get('user_id')
                 card_name = log_entry.get('card_name')
                 pick_number = log_entry.get('pick_number')
                 position = log_entry.get('position')
                 timestamp_str = log_entry.get('timestamp')
                 timestamp = datetime.strptime(timestamp_str, '%Y-%m-%dT%H:%M:%S.%fZ')

                 # Check if Draft exists
                 draft = session.query(Draft).filter_by(id=draft_id).first()
                 if not draft:
                     draft = Draft(id=draft_id, user_id=user_id, status='in_progress', started_at=datetime.utcnow())
                     session.add(draft)
                     session.commit()

                 # Check if Card exists, if not, add to Cards table
                 card = session.query(Card).filter_by(name=card_name).first()
                 if not card:
                     # Fetch card data from Scryfall API or another source
                     card_data = fetch_card_data(card_name)
                     if card_data:
                         card = Card(
                             name=card_data.get('name'),
                             mana_cost=card_data.get('mana_cost'),
                             type_line=card_data.get('type_line'),
                             oracle_text=card_data.get('oracle_text'),
                             image_url=card_data.get('image_uris', {}).get('normal', '')
                         )
                         session.add(card)
                         session.commit()
                     else:
                         print(f"Failed to fetch data for card: {card_name}")
                         return

                 # Add DraftedCard entry
                 drafted_card = DraftedCard(
                     draft_id=draft_id,
                     card_id=card.id,
                     pick_number=pick_number,
                     position=position,
                     timestamp=timestamp
                 )
                 session.add(drafted_card)
                 session.commit()

                 print(f"Processed pick {pick_number}: {card_name} for draft {draft_id}")

     def fetch_card_data(card_name):
         # Placeholder for fetching card data, possibly using the Scryfall API
         import requests
         from dotenv import load_dotenv
         load_dotenv()
         SCRYFALL_API_URL = os.getenv('SCRYFALL_API_URL', 'https://api.scryfall.com')

         try:
             response = requests.get(f"{SCRYFALL_API_URL}/cards/named", params={'fuzzy': card_name}, timeout=10)
             response.raise_for_status()
             return response.json()
         except requests.exceptions.RequestException as e:
             print(f"Error fetching card data from Scryfall: {e}")
             return None

     def main():
         event_handler = MTGArenaLogHandler()
         observer = Observer()
         observer.schedule(event_handler, path=LOG_DIRECTORY, recursive=False)
         observer.start()
         print(f"Monitoring MTG Arena logs in {LOG_DIRECTORY}...")

         try:
             while True:
                 time.sleep(1)
         except KeyboardInterrupt:
             observer.stop()
         observer.join()

     if __name__ == "__main__":
         main()
     

     python log_parser.py
     

       Connected to Redis successfully.
       Monitoring MTG Arena logs in /path/to/MTG Arena/logs...
       Processed pick 1: Black Lotus for draft 1
       Processed pick 2: Sol Ring for draft 1
       ...
       

     // models/card.js
     module.exports = (sequelize, DataTypes) => {
       const Card = sequelize.define('Card', {
         id: {
           type: DataTypes.INTEGER,
           primaryKey: true,
           autoIncrement: true,
         },
         name: {
           type: DataTypes.STRING,
           allowNull: false,
           unique: true,
         },
         mana_cost: {
           type: DataTypes.STRING,
         },
         type_line: {
           type: DataTypes.STRING,
         },
         oracle_text: {
           type: DataTypes.TEXT,
         },
         image_url: {
           type: DataTypes.STRING,
         },
       }, {
         tableName: 'cards',
         timestamps: false,
       });

       Card.associate = (models) => {
         Card.hasMany(models.DraftedCard, { foreignKey: 'card_id' });
         Card.hasMany(models.SynergyScore, { foreignKey: 'card_id' });
       };

       return Card;
     };
     

     // models/draft.js
     module.exports = (sequelize, DataTypes) => {
       const Draft = sequelize.define('Draft', {
         id: {
           type: DataTypes.INTEGER,
           primaryKey: true,
           autoIncrement: true,
         },
         user_id: {
           type: DataTypes.INTEGER,
           allowNull: false,
           references: {
             model: 'users',
             key: 'id',
           },
         },
         status: {
           type: DataTypes.STRING,
           allowNull: false,
         },
         started_at: {
           type: DataTypes.DATE,
           allowNull: false,
           defaultValue: DataTypes.NOW,
         },
         completed_at: {
           type: DataTypes.DATE,
         },
         metadata: {
           type: DataTypes.JSON,
         },
       }, {
         tableName: 'drafts',
         timestamps: false,
       });

       Draft.associate = (models) => {
         Draft.belongsTo(models.User, { foreignKey: 'user_id' });
         Draft.hasMany(models.DraftedCard, { foreignKey: 'draft_id' });
         Draft.hasOne(models.DeckComposition, { foreignKey: 'draft_id' });
       };

       return Draft;
     };
     

     // models/draftedCard.js
     module.exports = (sequelize, DataTypes) => {
       const DraftedCard = sequelize.define('DraftedCard', {
         id: {
           type: DataTypes.INTEGER,
           primaryKey: true,
           autoIncrement: true,
         },
         draft_id: {
           type: DataTypes.INTEGER,
           allowNull: false,
           references: {
             model: 'drafts',
             key: 'id',
           },
         },
         card_id: {
           type: DataTypes.INTEGER,
           allowNull: false,
           references: {
             model: 'cards',
             key: 'id',
           },
         },
         pick_number: {
           type: DataTypes.INTEGER,
           allowNull: false,
         },
         position: {
           type: DataTypes.STRING,
         },
         timestamp: {
           type: DataTypes.DATE,
           allowNull: false,
         },
       }, {
         tableName: 'drafted_cards',
         timestamps: false,
       });

       DraftedCard.associate = (models) => {
         DraftedCard.belongsTo(models.Draft, { foreignKey: 'draft_id' });
         DraftedCard.belongsTo(models.Card, { foreignKey: 'card_id' });
       };

       return DraftedCard;
     };
     

     // models/deckComposition.js
     module.exports = (sequelize, DataTypes) => {
       const DeckComposition = sequelize.define('DeckComposition', {
         id: {
           type: DataTypes.INTEGER,
           primaryKey: true,
           autoIncrement: true,
         },
         draft_id: {
           type: DataTypes.INTEGER,
           allowNull: false,
           references: {
             model: 'drafts',
             key: 'id',
           },
         },
         archetype: {
           type: DataTypes.STRING,
         },
         synergy_score: {
           type: DataTypes.FLOAT,
         },
         mana_curve: {
           type: DataTypes.JSON,
         },
       }, {
         tableName: 'deck_compositions',
         timestamps: false,
       });

       DeckComposition.associate = (models) => {
         DeckComposition.belongsTo(models.Draft, { foreignKey: 'draft_id' });
         DeckComposition.hasMany(models.SynergyScore, { foreignKey: 'deck_composition_id' });
       };

       return DeckComposition;
     };
     

     // models/synergyScore.js
     module.exports = (sequelize, DataTypes) => {
       const SynergyScore = sequelize.define('SynergyScore', {
         id: {
           type: DataTypes.INTEGER,
           primaryKey: true,
           autoIncrement: true,
         },
         deck_composition_id: {
           type: DataTypes.INTEGER,
           allowNull: false,
           references: {
             model: 'deck_compositions',
             key: 'id',
           },
         },
         card_id: {
           type: DataTypes.INTEGER,
           allowNull: false,
           references: {
             model: 'cards',
             key: 'id',
           },
         },
         synergy_score: {
           type: DataTypes.FLOAT,
         },
         updated_at: {
           type: DataTypes.DATE,
           defaultValue: DataTypes.NOW,
         },
       }, {
         tableName: 'synergy_scores',
         timestamps: false,
       });

       SynergyScore.associate = (models) => {
         SynergyScore.belongsTo(models.DeckComposition, { foreignKey: 'deck_composition_id' });
         SynergyScore.belongsTo(models.Card, { foreignKey: 'card_id' });
       };

       return SynergyScore;
     };
     

     // models/availableCard.js
     module.exports = (sequelize, DataTypes) => {
       const AvailableCard = sequelize.define('AvailableCard', {
         id: {
           type: DataTypes.INTEGER,
           primaryKey: true,
           autoIncrement: true,
         },
         draft_id: {
           type: DataTypes.INTEGER,
           allowNull: false,
           references: {
             model: 'drafts',
             key: 'id',
           },
         },
         card_id: {
           type: DataTypes.INTEGER,
           allowNull: false,
           references: {
             model: 'cards',
             key: 'id',
           },
         },
       }, {
         tableName: 'available_cards',
         timestamps: false,
       });

       AvailableCard.associate = (models) => {
         AvailableCard.belongsTo(models.Draft, { foreignKey: 'draft_id' });
         AvailableCard.belongsTo(models.Card, { foreignKey: 'card_id' });
       };

       return AvailableCard;
     };
     

     # Access PostgreSQL shell
     psql -U your_db_username

     # Create the database
     CREATE DATABASE draft_navigator_dev;

     # Exit psql
     \q
     

     npx sequelize-cli db:migrate
     

     // seeders/20231020-demo-user.js
     module.exports = {
       up: async (queryInterface, Sequelize) => {
         return queryInterface.bulkInsert('users', [{
           username: 'testuser',
           email: 'testuser@example.com',
           password_hash: 'hashed_password_here', // Use bcrypt to hash passwords
           created_at: new Date(),
           updated_at: new Date(),
         }], {});
       },

       down: async (queryInterface, Sequelize) => {
         return queryInterface.bulkDelete('users', { email: 'testuser@example.com' }, {});
       }
     };
     

     npx sequelize-cli db:seed:all
     

     # Example: Get Draft Details
     curl -H "Authorization: Bearer your_jwt_token" http://localhost:3000/api/drafts/1

     # Example: Get Draft Picks
     curl -H "Authorization: Bearer your_jwt_token" http://localhost:3000/api/drafts/1/picks

     # Example: Get Available Cards
     curl -H "Authorization: Bearer your_jwt_token" http://localhost:3000/api/drafts/1/available-cards

     # Example: Get Draft Metrics
     curl -H "Authorization: Bearer your_jwt_token" http://localhost:3000/api/drafts/1/metrics
     

   npm install pg
   

     // config/config.json
     {
       "development": {
         "username": "your_db_username",
         "password": "your_db_password",
         "database": "draft_navigator_dev",
         "host": "127.0.0.1",
         "dialect": "postgres",
         "pool": {
           "max": 20,
           "min": 5,
           "acquire": 30000,
           "idle": 10000
         }
       },
       // ... other environments
     }
     

     npm install mongoose
     

     // mongoose.js
     const mongoose = require('mongoose');
     const dotenv = require('dotenv');
     const winston = require('winston');

     dotenv.config();

     const MONGO_URI = process.env.MONGO_URI || 'mongodb://localhost:27017/draft_navigator';

     const connectDB = async () => {
       try {
         await mongoose.connect(MONGO_URI, {
           useNewUrlParser: true,
           useUnifiedTopology: true,
           poolSize: 20, // Maintain up to 20 socket connections
           socketTimeoutMS: 45000,
           keepAlive: true,
         });
         winston.info('MongoDB connected successfully.');
       } catch (error) {
         winston.error(MongoDB connection error: ${error.message});
         process.exit(1);
       }
     };

     module.exports = connectDB;
     

     // index.js (continued)
     const connectDB = require('./mongoose');

     // Connect to MongoDB
     connectDB();
     

     mkdir draft-navigator-synergy
     cd draft-navigator-synergy
     

     python3 -m venv venv
     source venv/bin/activate
     

     pip install pandas numpy sqlalchemy python-dotenv
     

     DATABASE_URL=postgresql://username:password@localhost:5432/draft_navigator_dev
     

     # synergy_scoring.py
     import os
     import pandas as pd
     import numpy as np
     from sqlalchemy import create_engine
     from sqlalchemy.orm import sessionmaker
     from models import Base, Card, DraftedCard, DeckComposition, SynergyScore
     from dotenv import load_dotenv

     load_dotenv()

     DATABASE_URL = os.getenv('DATABASE_URL')

     # Initialize Database Connection
     engine = create_engine(DATABASE_URL)
     Session = sessionmaker(bind=engine)
     session = Session()

     def calculate_synergy_score(draft_id):
         """
         Calculate synergy scores for each drafted card in a draft.
         """
         # Fetch all drafted cards for the draft
         drafted_cards = session.query(DraftedCard).filter_by(draft_id=draft_id).all()
         
         # Fetch card details
         card_names = [dc.card.name for dc in drafted_cards]
         cards = session.query(Card).filter(Card.name.in_(card_names)).all()
         
         # Create DataFrame for drafted cards
         drafted_df = pd.DataFrame([{
             'name': card.name,
             'mana_cost': card.mana_cost,
             'type_line': card.type_line,
             'oracle_text': card.oracle_text
         } for card in cards])
         
         # Feature Extraction
         drafted_df['colors'] = drafted_df['mana_cost'].apply(extract_colors)
         drafted_df['mechanics'] = drafted_df['oracle_text'].apply(extract_mechanics)
         
         # Initialize synergy score dictionary
         synergy_scores = {card.name: 0 for card in cards}
         
         # Define weights for different synergy aspects
         COLOR_WEIGHT = 0.3
         MECHANIC_WEIGHT = 0.5
         ARCHETYPE_WEIGHT = 0.2
         
         # Calculate color synergy
         color_counts = drafted_df['colors'].explode().value_counts()
         for index, row in drafted_df.iterrows():
             color_synergy = sum(color_counts.get(color, 0) for color in row['colors']) / len(drafted_df)
             synergy_scores[row['name']] += COLOR_WEIGHT * color_synergy
         
         # Calculate mechanic synergy
         mechanic_counts = drafted_df['mechanics'].explode().value_counts()
         for index, row in drafted_df.iterrows():
             mechanic_synergy = sum(mechanic_counts.get(mech, 0) for mech in row['mechanics']) / len(drafted_df)
             synergy_scores[row['name']] += MECHANIC_WEIGHT * mechanic_synergy
         
         # Calculate archetype synergy (Placeholder: Implement archetype matching logic)
         # For simplicity, assume archetype synergy is 0.0
         for name in synergy_scores:
             synergy_scores[name] += ARCHETYPE_WEIGHT * 0.0
         
         # Normalize synergy scores
         max_score = max(synergy_scores.values()) if synergy_scores else 1
         for name in synergy_scores:
             synergy_scores[name] = synergy_scores[name] / max_score if max_score > 0 else 0
         
         # Save synergy scores to the database
         deck_composition = DeckComposition.query.filter_by(draft_id=draft_id).first()
         if not deck_composition:
             deck_composition = DeckComposition(draft_id=draft_id)
             session.add(deck_composition)
             session.commit()
         
         # Clear existing synergy scores
         session.query(SynergyScore).filter_by(deck_composition_id=deck_composition.id).delete()
         
         # Add new synergy scores
         for name, score in synergy_scores.items():
             card = session.query(Card).filter_by(name=name).first()
             synergy = SynergyScore(
                 deck_composition_id=deck_composition.id,
                 card_id=card.id,
                 synergy_score=score,
                 updated_at=pd.Timestamp.now()
             )
             session.add(synergy)
         
         session.commit()
         print(f"Synergy scores calculated and saved for draft {draft_id}.")

     def extract_colors(mana_cost):
         """
         Extract colors from mana cost string.
         Example: "{1}{U}{U}" -> ['U']
         """
         import re
         colors = re.findall(r'\{([WUBRG])\}', mana_cost)
         return colors

     def extract_mechanics(oracle_text):
         """
         Extract mechanics from oracle text.
         Example: "Flying, trample" -> ['Flying', 'Trample']
         """
         if not oracle_text:
             return []
         mechanics = [mech.strip().capitalize() for mech in oracle_text.split(',')]
         return mechanics

     if __name__ == "__main__":
         # Example: Calculate synergy score for draft with ID 1
         calculate_synergy_score(1)
     

     python synergy_scoring.py
     

     Synergy scores calculated and saved for draft 1.
     

     // powerCalculator.js
     const axios = require('axios');
     require('dotenv').config();

     const SEVENTEENLANDS_API_URL = process.env.SEVENTEENLANDS_API_URL || 'https://api.17lands.com/v1';
     const SEVENTEENLANDS_API_KEY = process.env.SEVENTEENLANDS_API_KEY;

     const seventeenLandsAPI = axios.create({
       baseURL: SEVENTEENLANDS_API_URL,
       headers: {
         'Authorization': Bearer ${SEVENTEENLANDS_API_KEY},
         'Content-Type': 'application/json',
       },
       timeout: 5000,
     });

     /**
      * Fetch win rate data for a specific card.
      * @param {string} cardName - The name of the MTG card.
      * @returns {Promise<number>} - The win rate as a percentage.
      */
     async function fetchWinRate(cardName) {
       try {
         const response = await seventeenLandsAPI.get(/cards/${encodeURIComponent(cardName)}/stats);
         const winRate = response.data.win_rate; // Assuming the API returns 'win_rate' field
         return winRate;
       } catch (error) {
         console.error(Error fetching win rate for ${cardName}: ${error.message});
         return null;
       }
     }

     /**
      * Calculate power scores for a list of cards.
      * @param {Array<string>} cardNames - An array of MTG card names.
      * @returns {Promise<Object>} - An object mapping card names to normalized power scores.
      */
     async function calculatePowerScores(cardNames) {
       const powerScores = {};

       // Fetch win rates for all cards concurrently
       const winRatePromises = cardNames.map(name => fetchWinRate(name));
       const winRates = await Promise.all(winRatePromises);

       // Populate powerScores with raw win rates
       cardNames.forEach((name, index) => {
         const winRate = winRates[index];
         if (winRate !== null) {
           powerScores[name] = winRate;
         } else {
           powerScores[name] = 0; // Assign a default value if win rate is unavailable
         }
       });

       // Normalize power scores between 0 and 1
       const maxWinRate = Math.max(...Object.values(powerScores));
       for (const name in powerScores) {
         powerScores[name] = maxWinRate > 0 ? powerScores[name] / maxWinRate : 0;
       }

       return powerScores;
     }

     module.exports = {
       fetchWinRate,
       calculatePowerScores,
     };
     

     // testPowerCalculator.js
     const { calculatePowerScores } = require('./powerCalculator');

     async function test() {
       const cardNames = [
         'Black Lotus',
         'Sol Ring',
         'Time Walk',
         'Mox Sapphire',
         'Lightning Bolt',
         'Counterspell'
       ];

       const powerScores = await calculatePowerScores(cardNames);
       console.log('Normalized Power Scores:', powerScores);
     }

     test();
     

     node testPowerCalculator.js
     

     Normalized Power Scores: {
       "Black Lotus": 1,
       "Sol Ring": 0.95,
       "Time Walk": 0.90,
       "Mox Sapphire": 0.85,
       "Lightning Bolt": 0.80,
       "Counterspell": 0.75
     }
     

     # synergy_scoring.py (continued)
     from powerCalculator import calculate_power_scores  # Assuming you have exposed it via an API or another method

     def calculate_synergy_score_with_power(draft_id):
         """
         Calculate synergy scores and integrate power levels for each drafted card in a draft.
         """
         # Fetch all drafted cards for the draft
         drafted_cards = session.query(DraftedCard).filter_by(draft_id=draft_id).all()
         
         # Fetch card details
         card_names = [dc.card.name for dc in drafted_cards]
         cards = session.query(Card).filter(Card.name.in_(card_names)).all()
         
         # Create DataFrame for drafted cards
         drafted_df = pd.DataFrame([{
             'name': card.name,
             'mana_cost': card.mana_cost,
             'type_line': card.type_line,
             'oracle_text': card.oracle_text
         } for card in cards])
         
         # Feature Extraction
         drafted_df['colors'] = drafted_df['mana_cost'].apply(extract_colors)
         drafted_df['mechanics'] = drafted_df['oracle_text'].apply(extract_mechanics)
         
         # Initialize synergy score dictionary
         synergy_scores = {card.name: 0 for card in cards}
         
         # Define weights for different synergy aspects
         COLOR_WEIGHT = 0.3
         MECHANIC_WEIGHT = 0.5
         ARCHETYPE_WEIGHT = 0.2
         
         # Calculate color synergy
         color_counts = drafted_df['colors'].explode().value_counts()
         for index, row in drafted_df.iterrows():
             color_synergy = sum(color_counts.get(color, 0) for color in row['colors']) / len(drafted_df)
             synergy_scores[row['name']] += COLOR_WEIGHT * color_synergy
         
         # Calculate mechanic synergy
         mechanic_counts = drafted_df['mechanics'].explode().value_counts()
         for index, row in drafted_df.iterrows():
             mechanic_synergy = sum(mechanic_counts.get(mech, 0) for mech in row['mechanics']) / len(drafted_df)
             synergy_scores[row['name']] += MECHANIC_WEIGHT * mechanic_synergy
         
         # Calculate archetype synergy (Placeholder: Implement archetype matching logic)
         for name in synergy_scores:
             synergy_scores[name] += ARCHETYPE_WEIGHT * 0.0
         
         # Calculate power scores
         power_scores = calculate_power_scores(card_names)
         
         # Integrate power scores into synergy scores
         for name in synergy_scores:
             synergy_scores[name] += power_scores.get(name, 0)
         
         # Normalize synergy scores
         max_score = max(synergy_scores.values()) if synergy_scores else 1
         for name in synergy_scores:
             synergy_scores[name] = synergy_scores[name] / max_score if max_score > 0 else 0
         
         # Save synergy scores to the database
         deck_composition = DeckComposition.query.filter_by(draft_id=draft_id).first()
         if not deck_composition:
             deck_composition = DeckComposition(draft_id=draft_id)
             session.add(deck_composition)
             session.commit()
         
         # Clear existing synergy scores
         session.query(SynergyScore).filter_by(deck_composition_id=deck_composition.id).delete()
         
         # Add new synergy scores
         for name, score in synergy_scores.items():
             card = session.query(Card).filter_by(name=name).first()
             synergy = SynergyScore(
                 deck_composition_id=deck_composition.id,
                 card_id=card.id,
                 synergy_score=score,
                 updated_at=pd.Timestamp.now()
             )
             session.add(synergy)
         
         session.commit()
         print(f"Synergy and power scores calculated and saved for draft {draft_id}.")
     

   mkdir draft-navigator-scryfall
   cd draft-navigator-scryfall
   

   python3 -m venv venv
   source venv/bin/activate
   

   pip install requests redis python-dotenv
   

   SCRYFALL_API_URL=https://api.scryfall.com
   REDIS_HOST=localhost
   REDIS_PORT=6379
   REDIS_DB=0
   REDIS_PASSWORD=your_redis_password_if_any
   CACHE_EXPIRATION=86400  # 24 hours in seconds
   

     # scryfall_service.py
     import os
     import requests
     import redis
     import json
     from dotenv import load_dotenv
     import logging
     import time
     from requests.exceptions import HTTPError, RequestException

     # Load environment variables
     load_dotenv()

     SCRYFALL_API_URL = os.getenv('SCRYFALL_API_URL', 'https://api.scryfall.com')
     REDIS_HOST = os.getenv('REDIS_HOST', 'localhost')
     REDIS_PORT = int(os.getenv('REDIS_PORT', 6379))
     REDIS_DB = int(os.getenv('REDIS_DB', 0))
     REDIS_PASSWORD = os.getenv('REDIS_PASSWORD', None)
     CACHE_EXPIRATION = int(os.getenv('CACHE_EXPIRATION', 86400))  # 24 hours

     # Configure Logging
     logging.basicConfig(level=logging.INFO,
                         format='%(asctime)s - %(levelname)s - %(message)s',
                         handlers=[
                             logging.FileHandler("scryfall_service.log"),
                             logging.StreamHandler()
                         ])
     logger = logging.getLogger()

     # Initialize Redis client
     try:
         if REDIS_PASSWORD:
             cache = redis.StrictRedis(host=REDIS_HOST, port=REDIS_PORT, db=REDIS_DB, password=REDIS_PASSWORD, decode_responses=True)
         else:
             cache = redis.StrictRedis(host=REDIS_HOST, port=REDIS_PORT, db=REDIS_DB, decode_responses=True)
         # Test connection
         cache.ping()
         logger.info("Connected to Redis successfully.")
     except redis.ConnectionError as e:
         logger.error(f"Redis connection error: {e}")
         exit(1)

     def fetch_card_from_scryfall(card_name):
         """
         Fetch detailed card information from Scryfall API.
         """
         try:
             response = requests.get(f"{SCRYFALL_API_URL}/cards/named", params={'fuzzy': card_name}, timeout=10)
             response.raise_for_status()
             card_data = response.json()
             return card_data
         except HTTPError as http_err:
             logger.error(f"HTTP error occurred while fetching {card_name}: {http_err} - {response.text}")
             return None
         except RequestException as req_err:
             logger.error(f"Request exception occurred while fetching {card_name}: {req_err}")
             return None

     def get_card_data(card_name):
         """
         Retrieve card data, using cache if available.
         """
         cache_key = f"scryfall:card:{card_name.lower()}"
         try:
             cached_data = cache.get(cache_key)
             if cached_data:
                 logger.info(f"Cache hit for card: {card_name}")
                 return json.loads(cached_data)
             else:
                 logger.info(f"Cache miss for card: {card_name}. Fetching from Scryfall API.")
                 card_data = fetch_card_from_scryfall(card_name)
                 if card_data:
                     cache.setex(cache_key, CACHE_EXPIRATION, json.dumps(card_data))
                     logger.info(f"Cached data for card: {card_name}")
                 return card_data
         except redis.RedisError as redis_err:
             logger.error(f"Redis error: {redis_err}")
             # Fallback to fetching directly if cache fails
             return fetch_card_from_scryfall(card_name)

     def main():
         # Example usage
         card_names = [
             "Black Lotus",
             "Sol Ring",
             "Time Walk",
             "Mox Sapphire",
             "Lightning Bolt",
             "Counterspell",
             "Goblin Guide",
             "Tarmogoyf",
             "Jace, the Mind Sculptor",
             "Thoughtseize"
         ]

         for card in card_names:
             card_data = get_card_data(card)
             if card_data:
                 logger.info(f"Card: {card_data.get('name', 'N/A')}")
                 logger.info(f"Mana Cost: {card_data.get('mana_cost', 'N/A')}")
                 logger.info(f"Type Line: {card_data.get('type_line', 'N/A')}")
                 logger.info(f"Oracle Text: {card_data.get('oracle_text', 'N/A')}")
                 image_url = card_data.get('image_uris', {}).get('normal', 'N/A') if 'image_uris' in card_data else 'N/A'
                 logger.info(f"Image URL: {image_url}")
                 logger.info("-" * 50)
             else:
                 logger.warning(f"Failed to retrieve data for card: {card}")

     if __name__ == "__main__":
         main()
     

     # On macOS using Homebrew
     brew install redis
     brew services start redis

     # On Ubuntu/Debian
     sudo apt-get install redis-server
     sudo systemctl enable redis-server.service
     sudo systemctl start redis-server.service
     

     python scryfall_service.py
     

     2024-04-27 12:00:00,000 - INFO - Connected to Redis successfully.
     2024-04-27 12:00:00,100 - INFO - Cache miss for card: Black Lotus. Fetching from Scryfall API.
     2024-04-27 12:00:00,500 - INFO - Cached data for card: Black Lotus
     2024-04-27 12:00:00,501 - INFO - Card: Black Lotus
     2024-04-27 12:00:00,501 - INFO - Mana Cost: {0}
     2024-04-27 12:00:00,501 - INFO - Type Line: Artifact
     2024-04-27 12:00:00,501 - INFO - Oracle Text: {T}, Sacrifice Black Lotus: Add three mana of any one color.
     2024-04-27 12:00:00,501 - INFO - Image URL: https://c1.scryfall.com/file/scryfall-cards/normal/front/5/3/534ed3e0-f8b6-4bf4-86f6-38fa6059e8de.jpg?1687522176
     --------------------------------------------------
     ... (similar logs for other cards)
     

   # scryfall_service.py (enhanced)
   import os
   import requests
   import redis
   import json
   from dotenv import load_dotenv
   import logging
   import time
   from requests.exceptions import HTTPError, RequestException

   # Load environment variables
   load_dotenv()

   SCRYFALL_API_URL = os.getenv('SCRYFALL_API_URL', 'https://api.scryfall.com')
   REDIS_HOST = os.getenv('REDIS_HOST', 'localhost')
   REDIS_PORT = int(os.getenv('REDIS_PORT', 6379))
   REDIS_DB = int(os.getenv('REDIS_DB', 0))
   REDIS_PASSWORD = os.getenv('REDIS_PASSWORD', None)
   CACHE_EXPIRATION = int(os.getenv('CACHE_EXPIRATION', 86400))  # 24 hours

   # Configure Logging
   logging.basicConfig(level=logging.INFO,
                       format='%(asctime)s - %(levelname)s - %(message)s',
                       handlers=[
                           logging.FileHandler("scryfall_service.log"),
                           logging.StreamHandler()
                       ])
   logger = logging.getLogger()

   # Initialize Redis client
   try:
       if REDIS_PASSWORD:
           cache = redis.StrictRedis(host=REDIS_HOST, port=REDIS_PORT, db=REDIS_DB, password=REDIS_PASSWORD, decode_responses=True)
       else:
           cache = redis.StrictRedis(host=REDIS_HOST, port=REDIS_PORT, db=REDIS_DB, decode_responses=True)
       # Test connection
       cache.ping()
       logger.info("Connected to Redis successfully.")
   except redis.ConnectionError as e:
       logger.error(f"Redis connection error: {e}")
       exit(1)

   def fetch_card_from_scryfall(card_name, max_retries=5, backoff_factor=0.3):
       """
       Fetch detailed card information from Scryfall API with exponential backoff.
       """
       url = f"{SCRYFALL_API_URL}/cards/named"
       params = {'fuzzy': card_name}
       retries = 0
       while retries < max_retries:
           try:
               response = requests.get(url, params=params, timeout=10)
               response.raise_for_status()
               card_data = response.json()
               return card_data
           except HTTPError as http_err:
               if response.status_code == 429:
                   # Rate limit exceeded
                   retry_after = int(response.headers.get('Retry-After', 1))
                   wait_time = backoff_factor * (2 ** retries)
                   logger.warning(f"Rate limit exceeded. Retrying after {retry_after} seconds.")
                   time.sleep(retry_after)
               else:
                   logger.error(f"HTTP error occurred while fetching {card_name}: {http_err} - {response.text}")
                   break
           except RequestException as req_err:
               wait_time = backoff_factor * (2 ** retries)
               logger.warning(f"Request exception: {req_err}. Retrying in {wait_time} seconds.")
               time.sleep(wait_time)
           retries += 1
       logger.error(f"Failed to fetch data for card: {card_name} after {max_retries} retries.")
       return None

   def get_card_data(card_name):
       """
       Retrieve card data, using cache if available.
       """
       cache_key = f"scryfall:card:{card_name.lower()}"
       try:
           cached_data = cache.get(cache_key)
           if cached_data:
               logger.info(f"Cache hit for card: {card_name}")
               return json.loads(cached_data)
           else:
               logger.info(f"Cache miss for card: {card_name}. Fetching from Scryfall API.")
               card_data = fetch_card_from_scryfall(card_name)
               if card_data:
                   cache.setex(cache_key, CACHE_EXPIRATION, json.dumps(card_data))
                   logger.info(f"Cached data for card: {card_name}")
               return card_data
       except redis.RedisError as redis_err:
           logger.error(f"Redis error: {redis_err}")
           # Fallback to fetching directly if cache fails
           return fetch_card_from_scryfall(card_name)

   def main():
       # Example usage
       card_names = [
           "Black Lotus",
           "Sol Ring",
           "Time Walk",
           "Mox Sapphire",
           "Lightning Bolt",
           "Counterspell",
           "Goblin Guide",
           "Tarmogoyf",
           "Jace, the Mind Sculptor",
           "Thoughtseize"
       ]

       for card in card_names:
           card_data = get_card_data(card)
           if card_data:
               logger.info(f"Card: {card_data.get('name', 'N/A')}")
               logger.info(f"Mana Cost: {card_data.get('mana_cost', 'N/A')}")
               logger.info(f"Type Line: {card_data.get('type_line', 'N/A')}")
               logger.info(f"Oracle Text: {card_data.get('oracle_text', 'N/A')}")
               image_url = card_data.get('image_uris', {}).get('normal', 'N/A') if 'image_uris' in card_data else 'N/A'
               logger.info(f"Image URL: {image_url}")
               logger.info("-" * 50)
           else:
               logger.warning(f"Failed to retrieve data for card: {card}")

   if __name__ == "__main__":
       main()
   

     python scryfall_service.py
     

     2024-04-27 12:00:00,000 - INFO - Connected to Redis successfully.
     2024-04-27 12:00:00,100 - INFO - Cache miss for card: Black Lotus. Fetching from Scryfall API.
     2024-04-27 12:00:00,500 - INFO - Cached data for card: Black Lotus
     2024-04-27 12:00:00,501 - INFO - Card: Black Lotus
     2024-04-27 12:00:00,501 - INFO - Mana Cost: {0}
     2024-04-27 12:00:00,501 - INFO - Type Line: Artifact
     2024-04-27 12:00:00,501 - INFO - Oracle Text: {T}, Sacrifice Black Lotus: Add three mana of any one color.
     2024-04-27 12:00:00,501 - INFO - Image URL: https://c1.scryfall.com/file/scryfall-cards/normal/front/5/3/534ed3e0-f8b6-4bf4-86f6-38fa6059e8de.jpg?1687522176
     --------------------------------------------------
     ... (similar logs for other cards)
     

     def fetch_card_from_scryfall(card_name, max_retries=5, backoff_factor=0.3):
         """
         Fetch detailed card information from Scryfall API with exponential backoff.
         """
         url = f"{SCRYFALL_API_URL}/cards/named"
         params = {'fuzzy': card_name}
         retries = 0
         while retries < max_retries:
             try:
                 response = requests.get(url, params=params, timeout=10)
                 response.raise_for_status()
                 card_data = response.json()
                 return card_data
             except HTTPError as http_err:
                 if response.status_code == 429:
                     # Rate limit exceeded
                     retry_after = int(response.headers.get('Retry-After', 1))
                     wait_time = backoff_factor * (2 ** retries)
                     logger.warning(f"Rate limit exceeded for {card_name}. Retrying after {retry_after} seconds.")
                     time.sleep(retry_after)
                 elif 500 <= response.status_code < 600:
                     # Server-side errors
                     wait_time = backoff_factor * (2 ** retries)
                     logger.warning(f"Server error ({response.status_code}) for {card_name}. Retrying in {wait_time} seconds.")
                     time.sleep(wait_time)
                 else:
                     # Client-side errors (do not retry)
                     logger.error(f"Client error ({response.status_code}) for {card_name}: {response.text}")
                     break
             except RequestException as req_err:
                 # Transient errors (network issues, DNS failures, etc.)
                 wait_time = backoff_factor * (2 ** retries)
                 logger.warning(f"Request exception for {card_name}: {req_err}. Retrying in {wait_time} seconds.")
                 time.sleep(wait_time)
             retries += 1
         logger.error(f"Failed to fetch data for card: {card_name} after {max_retries} retries.")
         return None
     

     pip install pytest pytest-mock
     

     mkdir tests
     

     touch tests/test_scryfall_service.py
     

     # tests/test_scryfall_service.py
     import pytest
     from unittest.mock import patch, MagicMock
     from scryfall_service import get_card_data, fetch_card_from_scryfall, cache
     import json

     # Sample card data for mocking
     SAMPLE_CARD_DATA = {
         "name": "Black Lotus",
         "mana_cost": "{0}",
         "type_line": "Artifact",
         "oracle_text": "{T}, Sacrifice Black Lotus: Add three mana of any one color.",
         "image_uris": {
             "normal": "https://c1.scryfall.com/file/scryfall-cards/normal/front/5/3/534ed3e0-f8b6-4bf4-86f6-38fa6059e8de.jpg?1687522176"
         }
     }

     @pytest.fixture
     def mock_redis():
         with patch('scryfall_service.redis.StrictRedis') as mock_redis_class:
             mock_redis_instance = MagicMock()
             mock_redis_class.return_value = mock_redis_instance
             yield mock_redis_instance

     @pytest.fixture
     def mock_requests():
         with patch('scryfall_service.requests.get') as mock_get:
             yield mock_get

     def test_get_card_data_cache_hit(mock_redis, mock_requests):
         # Setup mock Redis to return cached data
         card_name = "Black Lotus"
         cache_key = f"scryfall:card:{card_name.lower()}"
         mock_redis.get.return_value = json.dumps(SAMPLE_CARD_DATA)

         # Call the function
         result = get_card_data(card_name)

         # Assertions
         mock_redis.get.assert_called_once_with(cache_key)
         mock_requests.get.assert_not_called()
         assert result == SAMPLE_CARD_DATA

     def test_get_card_data_cache_miss_success(mock_redis, mock_requests):
         # Setup mock Redis to return None (cache miss)
         card_name = "Black Lotus"
         cache_key = f"scryfall:card:{card_name.lower()}"
         mock_redis.get.return_value = None

         # Setup mock response from Scryfall API
         mock_response = MagicMock()
         mock_response.raise_for_status.return_value = None
         mock_response.json.return_value = SAMPLE_CARD_DATA
         mock_requests.get.return_value = mock_response

         # Call the function
         result = get_card_data(card_name)

         # Assertions
         mock_redis.get.assert_called_once_with(cache_key)
         mock_requests.get.assert_called_once()
         mock_redis.setex.assert_called_once_with(cache_key, 86400, json.dumps(SAMPLE_CARD_DATA))
         assert result == SAMPLE_CARD_DATA

     def test_get_card_data_cache_miss_api_error(mock_redis, mock_requests):
         # Setup mock Redis to return None (cache miss)
         card_name = "Black Lotus"
         cache_key = f"scryfall:card:{card_name.lower()}"
         mock_redis.get.return_value = None

         # Setup mock response with HTTPError
         mock_response = MagicMock()
         mock_response.raise_for_status.side_effect = requests.exceptions.HTTPError("429 Too Many Requests", response=MagicMock(status=429, headers={'Retry-After': '1'}, text='Too Many Requests'))
         mock_requests.get.return_value = mock_response

         # Call the function
         result = get_card_data(card_name)

         # Assertions
         mock_redis.get.assert_called_once_with(cache_key)
         mock_requests.get.assert_called_once()
         mock_redis.setex.assert_not_called()
         assert result is None

     def test_get_card_data_cache_fallback_on_redis_error(mock_redis, mock_requests):
         # Setup mock Redis to raise an error
         card_name = "Black Lotus"
         cache_key = f"scryfall:card:{card_name.lower()}"
         mock_redis.get.side_effect = redis.exceptions.RedisError("Connection failed")

         # Setup mock response from Scryfall API
         mock_response = MagicMock()
         mock_response.raise_for_status.return_value = None
         mock_response.json.return_value = SAMPLE_CARD_DATA
         mock_requests.get.return_value = mock_response

         # Call the function
         result = get_card_data(card_name)

         # Assertions
         mock_redis.get.assert_called_once_with(cache_key)
         mock_requests.get.assert_called_once()
         mock_redis.setex.assert_called_once_with(cache_key, 86400, json.dumps(SAMPLE_CARD_DATA))
         assert result == SAMPLE_CARD_DATA

     def test_fetch_card_from_scryfall_success(mock_requests):
         # Setup mock response from Scryfall API
         card_name = "Black Lotus"
         mock_response = MagicMock()
         mock_response.raise_for_status.return_value = None
         mock_response.json.return_value = SAMPLE_CARD_DATA
         mock_requests.get.return_value = mock_response

         # Call the function
         result = fetch_card_from_scryfall(card_name)

         # Assertions
         mock_requests.get.assert_called_once_with(f"https://api.scryfall.com/cards/named", params={'fuzzy': card_name}, timeout=10)
         assert result == SAMPLE_CARD_DATA

     def test_fetch_card_from_scryfall_rate_limit(mock_requests, caplog):
         # Setup mock response with 429 status code
         card_name = "Black Lotus"
         mock_response = MagicMock()
         mock_response.raise_for_status.side_effect = requests.exceptions.HTTPError("429 Too Many Requests", response=MagicMock(status=429, headers={'Retry-After': '1'}, text='Too Many Requests'))
         mock_requests.get.return_value = mock_response

         # Call the function
         result = fetch_card_from_scryfall(card_name, max_retries=2, backoff_factor=0.1)

         # Assertions
         assert mock_requests.get.call_count == 2  # Initial try + one retry
         assert result is None
         assert "Rate limit exceeded" in caplog.text

     def test_fetch_card_from_scryfall_server_error(mock_requests, caplog):
         # Setup mock response with 500 status code
         card_name = "Black Lotus"
         mock_response = MagicMock()
         mock_response.raise_for_status.side_effect = requests.exceptions.HTTPError("500 Internal Server Error", response=MagicMock(status=500, headers={}, text='Internal Server Error'))
         mock_requests.get.return_value = mock_response

         # Call the function
         result = fetch_card_from_scryfall(card_name, max_retries=2, backoff_factor=0.1)

         # Assertions
         assert mock_requests.get.call_count == 2  # Initial try + one retry
         assert result is None
         assert "Server error" in caplog.text

     def test_fetch_card_from_scryfall_client_error(mock_requests, caplog):
         # Setup mock response with 404 status code
         card_name = "Nonexistent Card"
         mock_response = MagicMock()
         mock_response.raise_for_status.side_effect = requests.exceptions.HTTPError("404 Not Found", response=MagicMock(status=404, headers={}, text='Card not found'))
         mock_requests.get.return_value = mock_response

         # Call the function
         result = fetch_card_from_scryfall(card_name, max_retries=2, backoff_factor=0.1)

         # Assertions
         assert mock_requests.get.call_count == 1  # No retries on client errors
         assert result is None
         assert "Client error" in caplog.text
     

     pytest
     

     ============================= test session starts ==============================
     platform darwin -- Python 3.x.x, pytest-x.x.x, py-x.x.x, pluggy-x.x.x
     rootdir: /path/to/draft-navigator-scryfall, inifile:
     collected 7 items

     tests/test_scryfall_service.py .......                                       [100%]

     ============================== 7 passed in 1.23s ===============================
     

npm install socket.io

npm install https

// index.js
require('dotenv').config();
const express = require('express');
const axios = require('axios');
const rateLimit = require('express-rate-limit');
const winston = require('winston');
const http = require('http');
const { Server } = require('socket.io');
const fs = require('fs');
const path = require('path');

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

// Configure Winston Logger
const logger = winston.createLogger({
  level: 'info',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.json()
  ),
  transports: [
    new winston.transports.Console(),
    new winston.transports.File({ filename: 'error.log', level: 'error' }),
    new winston.transports.File({ filename: 'combined.log' }),
  ],
});

// Rate Limiting Middleware
const limiter = rateLimit({
  windowMs: parseInt(process.env.RATE_LIMIT_WINDOW_MS) || 60000, // 1 minute
  max: parseInt(process.env.RATE_LIMIT_MAX) || 60, // limit each IP to 60 requests per windowMs
  message: 'Too many requests from this IP, please try again after a minute.',
  handler: (req, res, next, options) => {
    logger.warn(Rate limit exceeded for IP: ${req.ip});
    res.status(options.statusCode).json({ message: options.message });
  },
});

app.use(limiter);

// 17lands API Service
const seventeenLandsAPI = axios.create({
  baseURL: process.env.SEVENTEENLANDS_API_URL,
  headers: {
    'Authorization': Bearer ${process.env.SEVENTEENLANDS_API_KEY},
    'Content-Type': 'application/json',
  },
  timeout: 5000, // 5 seconds timeout
});

// Endpoint to Fetch Win Rates and ALSA Data for a Specific Card
app.get('/api/cards/:cardName/stats', async (req, res) => {
  const { cardName } = req.params;
  try {
    const response = await seventeenLandsAPI.get(/cards/${encodeURIComponent(cardName)}/stats);
    res.json(response.data);
  } catch (error) {
    if (error.response) {
      // API responded with a status outside 2xx
      logger.error(17lands API Error: ${error.response.status} - ${error.response.data});
      res.status(error.response.status).json({ message: error.response.data });
    } else if (error.request) {
      // No response received
      logger.error(17lands API No Response: ${error.message});
      res.status(503).json({ message: '17lands API is unavailable. Please try again later.' });
    } else {
      // Other errors
      logger.error(Error fetching 17lands data: ${error.message});
      res.status(500).json({ message: 'Internal Server Error' });
    }
  }
});

// Create HTTP Server
const server = http.createServer(app);

// Initialize Socket.IO Server
const io = new Server(server, {
  cors: {
    origin: '*', // Important: Restrict this in production for security
    methods: ['GET', 'POST'],
  },
});

// Handle Socket.IO Connections
io.on('connection', (socket) => {
  logger.info(New client connected: ${socket.id});

  // Event: joinDraft - Join a specific draft room
  socket.on('joinDraft', (draftId) => {
    socket.join(draft_${draftId});
    logger.info(Socket ${socket.id} joined draft_${draftId});
    socket.emit('joinedDraft', { draftId, message: Joined draft ${draftId} });
  });

  // Event: leaveDraft - Leave a specific draft room
  socket.on('leaveDraft', (draftId) => {
    socket.leave(draft_${draftId});
    logger.info(Socket ${socket.id} left draft_${draftId});
    socket.emit('leftDraft', { draftId, message: Left draft ${draftId} });
  });

  // Event: updateDraft - Receive draft updates from client
  socket.on('updateDraft', (data) => {
    const { draftId, update } = data;
    logger.info(Received update for draft ${draftId} from socket ${socket.id}: ${JSON.stringify(update)});
    // Broadcast the update to other clients in the same draft room
    socket.to(draft_${draftId}).emit('draftUpdated', { draftId, update });
  });

  // Event: sendRecommendations - Receive recommendations from server
  // (Typically, the server would emit recommendations rather than receive them, but included per prompt)
  socket.on('sendRecommendations', (data) => {
    const { draftId, recommendations } = data;
    logger.info(Received recommendations for draft ${draftId} from socket ${socket.id}: ${JSON.stringify(recommendations)});
    // Broadcast recommendations to other clients in the same draft room
    socket.to(draft_${draftId}).emit('recommendationsReceived', { draftId, recommendations });
  });

  // Handle disconnection
  socket.on('disconnect', () => {
    logger.info(Client disconnected: ${socket.id});
  });
});

// Function to Broadcast Updates to a Specific Draft Room
const broadcastDraftUpdate = (draftId, updateData) => {
  io.to(draft_${draftId}).emit('draftUpdate', updateData);
  logger.info(Broadcasted update to draft_${draftId}: ${JSON.stringify(updateData)});
};

// Example Endpoint to Trigger a Draft Update (For Testing)
app.post('/api/drafts/:id/update', express.json(), (req, res) => {
  const { id } = req.params;
  const updateData = req.body; // Expecting JSON data

  broadcastDraftUpdate(id, updateData);

  res.json({ message: 'Draft update broadcasted successfully.' });
});

// Start the Server
server.listen(PORT, () => {
  logger.info(17lands API Service with WebSocket running on port ${PORT});
});

     const https = require('https');

     // Path to your SSL certificate and key
     const sslOptions = {
       key: fs.readFileSync(path.join(__dirname, 'certs', 'key.pem')),
       cert: fs.readFileSync(path.join(__dirname, 'certs', 'cert.pem')),
     };

     // Create HTTPS Server
     const httpsServer = https.createServer(sslOptions, app);

     // Initialize Socket.IO with HTTPS Server
     const io = new Server(httpsServer, {
       cors: {
         origin: '*', // Important: Restrict this in production for security
         methods: ['GET', 'POST'],
       },
     });

     // Start the HTTPS Server
     httpsServer.listen(PORT, () => {
       logger.info(17lands API Service with WebSocket (HTTPS) running on port ${PORT});
     });
     

       const io = new Server(server, {
         cors: {
           origin: 'https://your-frontend-domain.com',
           methods: ['GET', 'POST'],
         },
       });
       

     const jwt = require('jsonwebtoken');

     // Middleware for authenticating Socket.IO connections
     io.use((socket, next) => {
       const token = socket.handshake.auth.token;
       if (!token) {
         logger.warn(Socket ${socket.id} missing authentication token.);
         return next(new Error('Authentication error'));
       }
       jwt.verify(token, process.env.JWT_SECRET, (err, decoded) => {
         if (err) {
           logger.warn(Socket ${socket.id} provided invalid token.);
           return next(new Error('Authentication error'));
         }
         socket.user = decoded; // Attach decoded token data to socket
         next();
       });
     });

     io.on('connection', (socket) => {
       logger.info(Authenticated client connected: ${socket.id} (User ID: ${socket.user.id}));
       
       // ... existing event handlers ...
     });
     

       // client.js (Frontend)
       import { io } from "socket.io-client";

       const socket = io('https://your-backend-domain.com', {
         auth: {
           token: 'your_jwt_token_here'
         }
       });

       socket.on('connect', () => {
         console.log(Connected with ID: ${socket.id});
         // Join a draft room after connecting
         socket.emit('joinDraft', '12345');
       });

       socket.on('connect_error', (err) => {
         console.error(Connection error: ${err.message});
       });
       

// index.js
require('dotenv').config();
const express = require('express');
const axios = require('axios');
const rateLimit = require('express-rate-limit');
const winston = require('winston');
const http = require('http');
const { Server } = require('socket.io');
const fs = require('fs');
const path = require('path');
const jwt = require('jsonwebtoken');
const validator = require('validator');

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

// Configure Winston Logger
const logger = winston.createLogger({
  level: 'info',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.json()
  ),
  transports: [
    new winston.transports.Console(),
    new winston.transports.File({ filename: 'error.log', level: 'error' }),
    new winston.transports.File({ filename: 'combined.log' }),
  ],
});

// Rate Limiting Middleware
const limiter = rateLimit({
  windowMs: parseInt(process.env.RATE_LIMIT_WINDOW_MS) || 60000, // 1 minute
  max: parseInt(process.env.RATE_LIMIT_MAX) || 60, // limit each IP to 60 requests per windowMs
  message: 'Too many requests from this IP, please try again after a minute.',
  handler: (req, res, next, options) => {
    logger.warn(Rate limit exceeded for IP: ${req.ip});
    res.status(options.statusCode).json({ message: options.message });
  },
});

app.use(limiter);

// 17lands API Service
const seventeenLandsAPI = axios.create({
  baseURL: process.env.SEVENTEENLANDS_API_URL,
  headers: {
    'Authorization': Bearer ${process.env.SEVENTEENLANDS_API_KEY},
    'Content-Type': 'application/json',
  },
  timeout: 5000, // 5 seconds timeout
});

// Endpoint to Fetch Win Rates and ALSA Data for a Specific Card
app.get('/api/cards/:cardName/stats', async (req, res) => {
  const { cardName } = req.params;
  try {
    const response = await seventeenLandsAPI.get(/cards/${encodeURIComponent(cardName)}/stats);
    res.json(response.data);
  } catch (error) {
    if (error.response) {
      // API responded with a status outside 2xx
      logger.error(17lands API Error: ${error.response.status} - ${error.response.data});
      res.status(error.response.status).json({ message: error.response.data });
    } else if (error.request) {
      // No response received
      logger.error(17lands API No Response: ${error.message});
      res.status(503).json({ message: '17lands API is unavailable. Please try again later.' });
    } else {
      // Other errors
      logger.error(Error fetching 17lands data: ${error.message});
      res.status(500).json({ message: 'Internal Server Error' });
    }
  }
});

// Create HTTP Server
const server = http.createServer(app);

// Initialize Socket.IO Server with Authentication Middleware
const io = new Server(server, {
  cors: {
    origin: process.env.CLIENT_ORIGIN || '*', // Replace '*' with your frontend domain in production
    methods: ['GET', 'POST'],
  },
});

// Middleware for authenticating Socket.IO connections
io.use((socket, next) => {
  const token = socket.handshake.auth.token;
  if (!token) {
    logger.warn(Socket ${socket.id} missing authentication token.);
    return next(new Error('Authentication error'));
  }
  jwt.verify(token, process.env.JWT_SECRET, (err, decoded) => {
    if (err) {
      logger.warn(Socket ${socket.id} provided invalid token.);
      return next(new Error('Authentication error'));
    }
    socket.user = decoded; // Attach decoded token data to socket
    next();
  });
});

// Handle Socket.IO Connections
io.on('connection', (socket) => {
  logger.info(Authenticated client connected: ${socket.id} (User ID: ${socket.user.id}));

  // Event: joinDraft - Join a specific draft room
  socket.on('joinDraft', (draftId) => {
    // Validate draftId (ensure it's a valid format)
    if (!validator.isAlphanumeric(draftId)) {
      logger.warn(Invalid draftId provided by socket ${socket.id}: ${draftId});
      return socket.emit('error', { message: 'Invalid draft ID.' });
    }
    socket.join(draft_${draftId});
    logger.info(Socket ${socket.id} joined draft_${draftId});
    socket.emit('joinedDraft', { draftId, message: Joined draft ${draftId} });
  });

  // Event: leaveDraft - Leave a specific draft room
  socket.on('leaveDraft', (draftId) => {
    if (!validator.isAlphanumeric(draftId)) {
      logger.warn(Invalid draftId provided by socket ${socket.id}: ${draftId});
      return socket.emit('error', { message: 'Invalid draft ID.' });
    }
    socket.leave(draft_${draftId});
    logger.info(Socket ${socket.id} left draft_${draftId});
    socket.emit('leftDraft', { draftId, message: Left draft ${draftId} });
  });

  // Event: updateDraft - Receive draft updates from client
  socket.on('updateDraft', (data) => {
    const { draftId, update } = data;

    // Validate draftId
    if (!validator.isAlphanumeric(draftId)) {
      logger.warn(Invalid draftId in updateDraft from socket ${socket.id}: ${draftId});
      return socket.emit('error', { message: 'Invalid draft ID.' });
    }

    // Sanitize update data (example: ensure update is an object)
    if (typeof update !== 'object' || Array.isArray(update)) {
      logger.warn(Invalid update data from socket ${socket.id}: ${JSON.stringify(update)});
      return socket.emit('error', { message: 'Invalid update data format.' });
    }

    logger.info(Received update for draft ${draftId} from socket ${socket.id}: ${JSON.stringify(update)});

    // Broadcast the update to other clients in the same draft room
    socket.to(draft_${draftId}).emit('draftUpdated', { draftId, update });
  });

  // Event: sendRecommendations - Receive recommendations from server
  // Typically, recommendations are emitted by the server, but handling per prompt
  socket.on('sendRecommendations', (data) => {
    const { draftId, recommendations } = data;

    // Validate draftId
    if (!validator.isAlphanumeric(draftId)) {
      logger.warn(Invalid draftId in sendRecommendations from socket ${socket.id}: ${draftId});
      return socket.emit('error', { message: 'Invalid draft ID.' });
    }

    // Sanitize recommendations (example: ensure it's an array)
    if (!Array.isArray(recommendations)) {
      logger.warn(Invalid recommendations format from socket ${socket.id}: ${JSON.stringify(recommendations)});
      return socket.emit('error', { message: 'Invalid recommendations format.' });
    }

    logger.info(Received recommendations for draft ${draftId} from socket ${socket.id}: ${JSON.stringify(recommendations)});

    // Broadcast recommendations to other clients in the same draft room
    socket.to(draft_${draftId}).emit('recommendationsReceived', { draftId, recommendations });
  });

  // Handle disconnection
  socket.on('disconnect', () => {
    logger.info(Client disconnected: ${socket.id});
  });
});

// Function to Broadcast Updates to a Specific Draft Room
const broadcastDraftUpdate = (draftId, updateData) => {
  // Sanitize updateData if necessary
  io.to(draft_${draftId}).emit('draftUpdate', updateData);
  logger.info(Broadcasted update to draft_${draftId}: ${JSON.stringify(updateData)});
};

// Example Endpoint to Trigger a Draft Update (For Testing)
app.post('/api/drafts/:id/update', express.json(), (req, res) => {
  const { id } = req.params;
  const updateData = req.body; // Expecting JSON data

  // Validate draftId
  if (!validator.isAlphanumeric(id)) {
    return res.status(400).json({ message: 'Invalid draft ID.' });
  }

  // Sanitize updateData if necessary

  broadcastDraftUpdate(id, updateData);

  res.json({ message: 'Draft update broadcasted successfully.' });
});

// Start the Server
server.listen(PORT, () => {
  logger.info(17lands API Service with WebSocket running on port ${PORT});
});

     cors: {
       origin: 'https://your-frontend-domain.com',
       methods: ['GET', 'POST'],
     },
     

     const draftNamespace = io.of('/draft');

     draftNamespace.use((socket, next) => {
       // Authentication logic
     });

     draftNamespace.on('connection', (socket) => {
       // Event handlers specific to the draft namespace
     });
     

     cors: {
       origin: 'https://your-frontend-domain.com',
       methods: ['GET', 'POST'],
     },
     

     npm install @socket.io/redis-adapter redis
     

     const { createAdapter } = require('@socket.io/redis-adapter');
     const { createClient } = require('redis');

     const pubClient = createClient({ host: 'localhost', port: 6379 });
     const subClient = pubClient.duplicate();

     io.adapter(createAdapter(pubClient, subClient));
     

socket.on('joinDraft', (draftId) => {
  // Validate draftId (ensure it's a valid format)
  if (!validator.isAlphanumeric(draftId)) {
    logger.warn(Invalid draftId provided by socket ${socket.id}: ${draftId});
    return socket.emit('error', { message: 'Invalid draft ID.' });
  }
  socket.join(draft_${draftId});
  logger.info(Socket ${socket.id} joined draft_${draftId});
  socket.emit('joinedDraft', { draftId, message: Joined draft ${draftId} });
});

socket.on('leaveDraft', (draftId) => {
  if (!validator.isAlphanumeric(draftId)) {
    logger.warn(Invalid draftId provided by socket ${socket.id}: ${draftId});
    return socket.emit('error', { message: 'Invalid draft ID.' });
  }
  socket.leave(draft_${draftId});
  logger.info(Socket ${socket.id} left draft_${draftId});
  socket.emit('leftDraft', { draftId, message: Left draft ${draftId} });
});

socket.on('updateDraft', (data) => {
  const { draftId, update } = data;

  // Validate draftId
  if (!validator.isAlphanumeric(draftId)) {
    logger.warn(Invalid draftId in updateDraft from socket ${socket.id}: ${draftId});
    return socket.emit('error', { message: 'Invalid draft ID.' });
  }

  // Sanitize update data (example: ensure update is an object)
  if (typeof update !== 'object' || Array.isArray(update)) {
    logger.warn(Invalid update data from socket ${socket.id}: ${JSON.stringify(update)});
    return socket.emit('error', { message: 'Invalid update data format.' });
  }

  logger.info(Received update for draft ${draftId} from socket ${socket.id}: ${JSON.stringify(update)});

  // Broadcast the update to other clients in the same draft room
  socket.to(draft_${draftId}).emit('draftUpdated', { draftId, update });
});

socket.on('sendRecommendations', (data) => {
  const { draftId, recommendations } = data;

  // Validate draftId
  if (!validator.isAlphanumeric(draftId)) {
    logger.warn(Invalid draftId in sendRecommendations from socket ${socket.id}: ${draftId});
    return socket.emit('error', { message: 'Invalid draft ID.' });
  }

  // Sanitize recommendations (example: ensure it's an array)
  if (!Array.isArray(recommendations)) {
    logger.warn(Invalid recommendations format from socket ${socket.id}: ${JSON.stringify(recommendations)});
    return socket.emit('error', { message: 'Invalid recommendations format.' });
  }

  logger.info(Received recommendations for draft ${draftId} from socket ${socket.id}: ${JSON.stringify(recommendations)});

  // Broadcast recommendations to other clients in the same draft room
  socket.to(draft_${draftId}).emit('recommendationsReceived', { draftId, recommendations });
});

socket.on('disconnect', () => {
  logger.info(Client disconnected: ${socket.id});
});

// Function to broadcast updated draft data
const broadcastDraftData = (draftId, draftData) => {
  io.to(draft_${draftId}).emit('draftDataUpdated', draftData);
  logger.info(Broadcasted draft data update to draft_${draftId});
};

// Function to broadcast synergy scores
const broadcastSynergyScores = (draftId, synergyScores) => {
  io.to(draft_${draftId}).emit('synergyScoresUpdated', synergyScores);
  logger.info(Broadcasted synergy scores update to draft_${draftId});
};

// Function to broadcast recommendations
const broadcastRecommendations = (draftId, recommendations) => {
  io.to(draft_${draftId}).emit('recommendationsUpdated', recommendations);
  logger.info(Broadcasted recommendations update to draft_${draftId});
};

// Example function to handle a new draft pick
const handleNewDraftPick = async (draftId, cardName, userId) => {
  // Logic to add the new pick to the database
  // ...

  // Fetch updated draft data
  const updatedDraftData = await getDraftData(draftId); // Implement this function

  // Broadcast updated draft data
  broadcastDraftData(draftId, updatedDraftData);

  // Calculate updated synergy scores
  const updatedSynergyScores = await calculateSynergyScores(draftId); // Implement this function

  // Broadcast updated synergy scores
  broadcastSynergyScores(draftId, updatedSynergyScores);

  // Generate new recommendations
  const newRecommendations = await generateRecommendations(draftId); // Implement this function

  // Broadcast new recommendations
  broadcastRecommendations(draftId, newRecommendations);
};

// client.js (Frontend)
import { io } from "socket.io-client";

const socket = io('https://your-backend-domain.com', {
  auth: {
    token: 'your_jwt_token_here'
  }
});

// Join a draft room after connecting
socket.on('connect', () => {
  console.log(Connected with ID: ${socket.id});
  const draftId = '12345'; // Example draft ID
  socket.emit('joinDraft', draftId);
});

// Handle draft data updates
socket.on('draftDataUpdated', (draftData) => {
  console.log('Draft Data Updated:', draftData);
  // Update UI accordingly
});

// Handle synergy scores updates
socket.on('synergyScoresUpdated', (synergyScores) => {
  console.log('Synergy Scores Updated:', synergyScores);
  // Update UI accordingly
});

// Handle recommendations updates
socket.on('recommendationsUpdated', (recommendations) => {
  console.log('Recommendations Updated:', recommendations);
  // Update UI accordingly
});

// Handle joinedDraft confirmation
socket.on('joinedDraft', (data) => {
  console.log(data.message);
});

// Handle errors
socket.on('error', (error) => {
  console.error('Socket.IO Error:', error.message);
});

// Emitting an event to a specific room
io.to(draft_${draftId}).emit('eventName', data);

// Broadcasting to all clients except the sender in a room
socket.to(draft_${draftId}).emit('eventName', data);

     npm install @socket.io/redis-adapter redis
     

     const { createAdapter } = require('@socket.io/redis-adapter');
     const { createClient } = require('redis');

     // Create Redis clients for pub and sub
     const pubClient = createClient({ host: process.env.REDIS_HOST, port: process.env.REDIS_PORT, password: process.env.REDIS_PASSWORD });
     const subClient = pubClient.duplicate();

     // Connect Redis clients
     pubClient.connect().catch(console.error);
     subClient.connect().catch(console.error);

     // Use Redis adapter
     io.adapter(createAdapter(pubClient, subClient));
     

     npm install -g pm2
     

     pm2 start index.js -i max
     

     http {
       upstream socketio_servers {
         server 127.0.0.1:3000;
         server 127.0.0.1:3001;
         # Add more servers as needed
       }

       server {
         listen 443 ssl;
         server_name your-backend-domain.com;

         ssl_certificate /path/to/cert.pem;
         ssl_certificate_key /path/to/key.pem;

         location /socket.io/ {
           proxy_pass http://socketio_servers;
           proxy_http_version 1.1;
           proxy_set_header Upgrade $http_upgrade;
           proxy_set_header Connection "Upgrade";
           proxy_set_header Host $host;
         }

         location / {
           proxy_pass http://socketio_servers;
           proxy_http_version 1.1;
           proxy_set_header Upgrade $http_upgrade;
           proxy_set_header Connection "Upgrade";
           proxy_set_header Host $host;
         }
       }
     }
     

     mkdir certs
     openssl req -nodes -new -x509 -keyout certs/key.pem -out certs/cert.pem -days 365
     

     const https = require('https');

     // Path to SSL certificate and key
     const sslOptions = {
       key: fs.readFileSync(path.join(__dirname, 'certs', 'key.pem')),
       cert: fs.readFileSync(path.join(__dirname, 'certs', 'cert.pem')),
     };

     // Create HTTPS Server
     const httpsServer = https.createServer(sslOptions, app);

     // Initialize Socket.IO with HTTPS Server
     const io = new Server(httpsServer, {
       cors: {
         origin: process.env.CLIENT_ORIGIN || '*', // Replace '*' with your frontend domain in production
         methods: ['GET', 'POST'],
       },
     });

     // ... existing Socket.IO setup ...

     // Start the HTTPS Server
     httpsServer.listen(PORT, () => {
       logger.info(17lands API Service with WebSocket (HTTPS) running on port ${PORT});
     });
     

     // client.js (Frontend)
     const socket = io('https://your-backend-domain.com', {
       auth: {
         token: 'your_jwt_token_here'
       }
     });
     

     const jwt = require('jsonwebtoken');

     // Middleware for authenticating Socket.IO connections
     io.use((socket, next) => {
       const token = socket.handshake.auth.token;
       if (!token) {
         logger.warn(Socket ${socket.id} missing authentication token.);
         return next(new Error('Authentication error'));
       }
       jwt.verify(token, process.env.JWT_SECRET, (err, decoded) => {
         if (err) {
           logger.warn(Socket ${socket.id} provided invalid token.);
           return next(new Error('Authentication error'));
         }
         socket.user = decoded; // Attach decoded token data to socket
         next();
       });
     });
     

     const socket = io('https://your-backend-domain.com', {
       auth: {
         token: 'your_jwt_token_here'
       }
     });
     

   io.use((socket, next) => {
     const token = socket.handshake.auth.token;
     if (!token) {
       return next(new Error('Authentication error'));
     }
     jwt.verify(token, process.env.JWT_SECRET, (err, decoded) => {
       if (err) {
         return next(new Error('Authentication error'));
       }
       // Check user role
       if (decoded.role !== 'admin') {
         // Restrict access to certain rooms or actions
         socket.admin = false;
       } else {
         socket.admin = true;
       }
       socket.user = decoded;
       next();
     });
   });
   

     const isValidDraftId = (draftId) => validator.isAlphanumeric(draftId);
     const isValidUpdate = (update) => typeof update === 'object' && !Array.isArray(update);
     const isValidRecommendations = (recommendations) => Array.isArray(recommendations);
     

     const sanitizeString = (str) => validator.escape(str);
     const sanitizeObject = (obj) => {
       const sanitized = {};
       for (const key in obj) {
         if (typeof obj[key] === 'string') {
           sanitized[key] = validator.escape(obj[key]);
         } else {
           sanitized[key] = obj[key];
         }
       }
       return sanitized;
     };
     

     socket.on('updateDraft', (data) => {
       let { draftId, update } = data;

       // Validate draftId
       if (!isValidDraftId(draftId)) {
         logger.warn(Invalid draftId in updateDraft from socket ${socket.id}: ${draftId});
         return socket.emit('error', { message: 'Invalid draft ID.' });
       }

       // Sanitize update data
       update = sanitizeObject(update);

       logger.info(Received update for draft ${draftId} from socket ${socket.id}: ${JSON.stringify(update)});

       // Broadcast the sanitized update to other clients in the same draft room
       socket.to(draft_${draftId}).emit('draftUpdated', { draftId, update });
     });
     

     socket.on('joinDraft', async (draftId) => {
       if (!isValidDraftId(draftId)) {
         logger.warn(Invalid draftId provided by socket ${socket.id}: ${draftId});
         return socket.emit('error', { message: 'Invalid draft ID.' });
       }

       // Check if the user is authorized to join the draft
       const isAuthorized = await verifyUserDraftAccess(socket.user.id, draftId); // Implement this function
       if (!isAuthorized) {
         logger.warn(Unauthorized draft access attempt by socket ${socket.id} for draft ${draftId});
         return socket.emit('error', { message: 'Unauthorized access to this draft.' });
       }

       socket.join(draft_${draftId});
       logger.info(Socket ${socket.id} joined draft_${draftId});
       socket.emit('joinedDraft', { draftId, message: Joined draft ${draftId} });
     });
     

     socket.on('sendRecommendations', (data) => {
       const { draftId, recommendations } = data;

       if (!isValidDraftId(draftId)) {
         logger.warn(Invalid draftId in sendRecommendations from socket ${socket.id}: ${draftId});
         return socket.emit('error', { message: 'Invalid draft ID.' });
       }

       // Verify if the user has the authority to send recommendations
       if (!socket.admin) { // Assuming only admins can send recommendations
         logger.warn(Unauthorized recommendation attempt by socket ${socket.id} for draft ${draftId});
         return socket.emit('error', { message: 'Unauthorized to send recommendations.' });
       }

       // Sanitize recommendations
       if (!isValidRecommendations(recommendations)) {
         logger.warn(Invalid recommendations format from socket ${socket.id}: ${JSON.stringify(recommendations)});
         return socket.emit('error', { message: 'Invalid recommendations format.' });
       }

       logger.info(Received recommendations for draft ${draftId} from socket ${socket.id}: ${JSON.stringify(recommendations)});

       // Broadcast recommendations to other clients in the same draft room
       socket.to(draft_${draftId}).emit('recommendationsReceived', { draftId, recommendations });
     });
     

     const sanitizeOutgoingData = (data) => {
       if (typeof data === 'string') {
         return validator.escape(data);
       } else if (typeof data === 'object') {
         return sanitizeObject(data);
       }
       return data;
     };

     // Use in broadcasting functions
     const broadcastDraftUpdate = (draftId, updateData) => {
       const sanitizedData = sanitizeOutgoingData(updateData);
       io.to(draft_${draftId}).emit('draftUpdate', sanitizedData);
       logger.info(Broadcasted sanitized update to draft_${draftId});
     };
     

     const helmet = require('helmet');

     app.use(helmet({
       contentSecurityPolicy: {
         directives: {
           defaultSrc: ["'self'"],
           scriptSrc: ["'self'", "https://cdn.socket.io"],
           connectSrc: ["'self'", "https://your-backend-domain.com"],
           imgSrc: ["'self'", "https://c1.scryfall.com"], // Allow images from Scryfall
           styleSrc: ["'self'", "'unsafe-inline'"],
           // Add other directives as needed
         },
       },
     }));
     

     > npm install helmet
     > 

     const EventEmitterRateLimiter = (maxEvents, windowMs) => {
       const clients = {};

       return (socket, next) => {
         socket.on('updateDraft', (data) => {
           const clientId = socket.id;
           const currentTime = Date.now();

           if (!clients[clientId]) {
             clients[clientId] = [];
           }

           // Remove events older than windowMs
           clients[clientId] = clients[clientId].filter(timestamp => currentTime - timestamp < windowMs);

           if (clients[clientId].length >= maxEvents) {
             logger.warn(Rate limit exceeded for socket ${clientId});
             socket.emit('error', { message: 'Rate limit exceeded. Please slow down.' });
             return;
           }

           clients[clientId].push(currentTime);
           socket.emit('updateDraftReceived', data);
         });

         next();
       };
     };

     // Apply rate limiter middleware to Socket.IO
     io.use(EventEmitterRateLimiter(10, 60000)); // Limit to 10 events per minute
     

// index.js
require('dotenv').config();
const express = require('express');
const axios = require('axios');
const rateLimit = require('express-rate-limit');
const winston = require('winston');
const https = require('https');
const { Server } = require('socket.io');
const fs = require('fs');
const path = require('path');
const jwt = require('jsonwebtoken');
const validator = require('validator');
const helmet = require('helmet');

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

// Configure Winston Logger
const logger = winston.createLogger({
  level: 'info',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.json()
  ),
  transports: [
    new winston.transports.Console(),
    new winston.transports.File({ filename: 'error.log', level: 'error' }),
    new winston.transports.File({ filename: 'combined.log' }),
  ],
});

// Use Helmet for Security Headers
app.use(helmet({
  contentSecurityPolicy: {
    directives: {
      defaultSrc: ["'self'"],
      scriptSrc: ["'self'", "https://cdn.socket.io"],
      connectSrc: ["'self'", "https://your-backend-domain.com"],
      imgSrc: ["'self'", "https://c1.scryfall.com"],
      styleSrc: ["'self'", "'unsafe-inline'"],
      // Add other directives as needed
    },
  },
}));

// Rate Limiting Middleware for HTTP Requests
const httpLimiter = rateLimit({
  windowMs: parseInt(process.env.RATE_LIMIT_WINDOW_MS) || 60000, // 1 minute
  max: parseInt(process.env.RATE_LIMIT_MAX) || 100, // limit each IP to 100 requests per windowMs
  message: 'Too many requests from this IP, please try again after a minute.',
  handler: (req, res, next, options) => {
    logger.warn(Rate limit exceeded for IP: ${req.ip});
    res.status(options.statusCode).json({ message: options.message });
  },
});

app.use(httpLimiter);

// 17lands API Service
const seventeenLandsAPI = axios.create({
  baseURL: process.env.SEVENTEENLANDS_API_URL,
  headers: {
    'Authorization': Bearer ${process.env.SEVENTEENLANDS_API_KEY},
    'Content-Type': 'application/json',
  },
  timeout: 5000, // 5 seconds timeout
});

// Endpoint to Fetch Win Rates and ALSA Data for a Specific Card
app.get('/api/cards/:cardName/stats', async (req, res) => {
  const { cardName } = req.params;
  try {
    const response = await seventeenLandsAPI.get(/cards/${encodeURIComponent(cardName)}/stats);
    res.json(response.data);
  } catch (error) {
    if (error.response) {
      // API responded with a status outside 2xx
      logger.error(17lands API Error: ${error.response.status} - ${error.response.data});
      res.status(error.response.status).json({ message: error.response.data });
    } else if (error.request) {
      // No response received
      logger.error(17lands API No Response: ${error.message});
      res.status(503).json({ message: '17lands API is unavailable. Please try again later.' });
    } else {
      // Other errors
      logger.error(Error fetching 17lands data: ${error.message});
      res.status(500).json({ message: 'Internal Server Error' });
    }
  }
});

// Create HTTPS Server
const sslOptions = {
  key: fs.readFileSync(path.join(__dirname, 'certs', 'key.pem')),
  cert: fs.readFileSync(path.join(__dirname, 'certs', 'cert.pem')),
};

const httpsServer = https.createServer(sslOptions, app);

// Initialize Socket.IO Server with HTTPS Server
const io = new Server(httpsServer, {
  cors: {
    origin: process.env.CLIENT_ORIGIN || '*', // Replace '*' with your frontend domain in production
    methods: ['GET', 'POST'],
  },
});

// Redis Adapter for Scaling (Optional)
// Uncomment and configure if scaling across multiple instances
/*
const { createAdapter } = require('@socket.io/redis-adapter');
const { createClient } = require('redis');

const pubClient = createClient({ host: process.env.REDIS_HOST, port: process.env.REDIS_PORT, password: process.env.REDIS_PASSWORD });
const subClient = pubClient.duplicate();

pubClient.connect().catch(console.error);
subClient.connect().catch(console.error);

io.adapter(createAdapter(pubClient, subClient));
*/

// Middleware for authenticating Socket.IO connections
io.use((socket, next) => {
  const token = socket.handshake.auth.token;
  if (!token) {
    logger.warn(Socket ${socket.id} missing authentication token.);
    return next(new Error('Authentication error'));
  }
  jwt.verify(token, process.env.JWT_SECRET, (err, decoded) => {
    if (err) {
      logger.warn(Socket ${socket.id} provided invalid token.);
      return next(new Error('Authentication error'));
    }
    socket.user = decoded; // Attach decoded token data to socket
    next();
  });
});

// Rate Limiting Middleware for Socket.IO Events
const EventEmitterRateLimiter = (maxEvents, windowMs) => {
  const clients = {};

  return (socket, next) => {
    // Example: Rate limit for 'updateDraft' events
    socket.on('updateDraft', (data) => {
      const clientId = socket.id;
      const currentTime = Date.now();

      if (!clients[clientId]) {
        clients[clientId] = [];
      }

      // Remove events older than windowMs
      clients[clientId] = clients[clientId].filter(timestamp => currentTime - timestamp < windowMs);

      if (clients[clientId].length >= maxEvents) {
        logger.warn(Rate limit exceeded for socket ${clientId});
        socket.emit('error', { message: 'Rate limit exceeded. Please slow down.' });
        return;
      }

      clients[clientId].push(currentTime);
      // Proceed with handling the event
      // Emit back to client or handle as needed
      socket.emit('updateDraftReceived', data);
    });

    next();
  };
};

// Apply rate limiter middleware to Socket.IO
io.use(EventEmitterRateLimiter(10, 60000)); // Limit to 10 'updateDraft' events per minute

// Handle Socket.IO Connections
io.on('connection', (socket) => {
  logger.info(Authenticated client connected: ${socket.id} (User ID: ${socket.user.id}));

  // Event: joinDraft - Join a specific draft room
  socket.on('joinDraft', (draftId) => {
    // Validate draftId
    if (!validator.isAlphanumeric(draftId)) {
      logger.warn(Invalid draftId provided by socket ${socket.id}: ${draftId});
      return socket.emit('error', { message: 'Invalid draft ID.' });
    }

    // Verify if the user is authorized to join the draft
    verifyUserDraftAccess(socket.user.id, draftId).then(isAuthorized => {
      if (!isAuthorized) {
        logger.warn(Unauthorized draft access attempt by socket ${socket.id} for draft ${draftId});
        return socket.emit('error', { message: 'Unauthorized access to this draft.' });
      }

      socket.join(draft_${draftId});
      logger.info(Socket ${socket.id} joined draft_${draftId});
      socket.emit('joinedDraft', { draftId, message: Joined draft ${draftId} });
    }).catch(err => {
      logger.error(Error verifying draft access for socket ${socket.id}: ${err.message});
      socket.emit('error', { message: 'Internal server error.' });
    });
  });

  // Event: leaveDraft - Leave a specific draft room
  socket.on('leaveDraft', (draftId) => {
    if (!validator.isAlphanumeric(draftId)) {
      logger.warn(Invalid draftId provided by socket ${socket.id}: ${draftId});
      return socket.emit('error', { message: 'Invalid draft ID.' });
    }
    socket.leave(draft_${draftId});
    logger.info(Socket ${socket.id} left draft_${draftId});
    socket.emit('leftDraft', { draftId, message: Left draft ${draftId} });
  });

  // Event: updateDraft - Receive draft updates from client
  socket.on('updateDraft', (data) => {
    const { draftId, update } = data;

    // Validate draftId
    if (!validator.isAlphanumeric(draftId)) {
      logger.warn(Invalid draftId in updateDraft from socket ${socket.id}: ${draftId});
      return socket.emit('error', { message: 'Invalid draft ID.' });
    }

    // Sanitize update data
    if (typeof update !== 'object' || Array.isArray(update)) {
      logger.warn(Invalid update data from socket ${socket.id}: ${JSON.stringify(update)});
      return socket.emit('error', { message: 'Invalid update data format.' });
    }

    const sanitizedUpdate = sanitizeObject(update);

    logger.info(Received update for draft ${draftId} from socket ${socket.id}: ${JSON.stringify(sanitizedUpdate)});

    // Broadcast the update to other clients in the same draft room
    socket.to(draft_${draftId}).emit('draftUpdated', { draftId, update: sanitizedUpdate });
  });

  // Event: sendRecommendations - Receive recommendations from server
  socket.on('sendRecommendations', (data) => {
    const { draftId, recommendations } = data;

    // Validate draftId
    if (!validator.isAlphanumeric(draftId)) {
      logger.warn(Invalid draftId in sendRecommendations from socket ${socket.id}: ${draftId});
      return socket.emit('error', { message: 'Invalid draft ID.' });
    }

    // Sanitize recommendations
    if (!Array.isArray(recommendations)) {
      logger.warn(Invalid recommendations format from socket ${socket.id}: ${JSON.stringify(recommendations)});
      return socket.emit('error', { message: 'Invalid recommendations format.' });
    }

    const sanitizedRecommendations = recommendations.map(rec => sanitizeObject(rec));

    logger.info(Received recommendations for draft ${draftId} from socket ${socket.id}: ${JSON.stringify(sanitizedRecommendations)});

    // Broadcast recommendations to other clients in the same draft room
    socket.to(draft_${draftId}).emit('recommendationsReceived', { draftId, recommendations: sanitizedRecommendations });
  });

  // Handle disconnection
  socket.on('disconnect', () => {
    logger.info(Client disconnected: ${socket.id});
  });
});

// Function to Broadcast Updates to a Specific Draft Room
const broadcastDraftUpdate = (draftId, updateData) => {
  const sanitizedData = sanitizeObject(updateData);
  io.to(draft_${draftId}).emit('draftUpdate', sanitizedData);
  logger.info(Broadcasted sanitized update to draft_${draftId});
};

// Example Endpoint to Trigger a Draft Update (For Testing)
app.post('/api/drafts/:id/update', express.json(), (req, res) => {
  const { id } = req.params;
  const updateData = req.body; // Expecting JSON data

  // Validate draftId
  if (!validator.isAlphanumeric(id)) {
    return res.status(400).json({ message: 'Invalid draft ID.' });
  }

  // Sanitize updateData
  const sanitizedData = sanitizeObject(updateData);

  broadcastDraftUpdate(id, sanitizedData);

  res.json({ message: 'Draft update broadcasted successfully.' });
});

// Function to Verify User's Access to a Draft
async function verifyUserDraftAccess(userId, draftId) {
  // Implement your logic to verify if the user is part of the draft session
  // For example, query your database to check draft participation
  // Return true if authorized, false otherwise

  // Placeholder implementation:
  return true; // Assume all users are authorized for demonstration
}

// Function to Sanitize Objects
function sanitizeObject(obj) {
  const sanitized = {};
  for (const key in obj) {
    if (typeof obj[key] === 'string') {
      sanitized[key] = validator.escape(obj[key]);
    } else if (typeof obj[key] === 'object' && obj[key] !== null) {
      sanitized[key] = sanitizeObject(obj[key]);
    } else {
      sanitized[key] = obj[key];
    }
  }
  return sanitized;
}

// Start the HTTPS Server
httpsServer.listen(PORT, () => {
  logger.info(17lands API Service with WebSocket (HTTPS) running on port ${PORT});
});

<!-- test_client.html -->
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Socket.IO Test Client</title>
  <script src="https://cdn.socket.io/4.4.1/socket.io.min.js"></script>
</head>
<body>
  <h1>Socket.IO Test Client</h1>
  <script>
    // Replace with your actual JWT token
    const token = 'your_jwt_token_here';

    const socket = io('https://your-backend-domain.com', {
      auth: {
        token: token
      }
    });

    socket.on('connect', () => {
      console.log(Connected with ID: ${socket.id});
      const draftId = '12345'; // Example draft ID
      socket.emit('joinDraft', draftId);
    });

    socket.on('joinedDraft', (data) => {
      console.log(data.message);
      // Send a draft update
      const update = { currentPick: 'Black Lotus', pickedBy: 'Player1' };
      socket.emit('updateDraft', { draftId: '12345', update: update });
    });

    socket.on('draftUpdated', (data) => {
      console.log(Draft Updated for ${data.draftId}:, data.update);
    });

    socket.on('synergyScoresUpdated', (synergyScores) => {
      console.log('Synergy Scores Updated:', synergyScores);
    });

    socket.on('recommendationsUpdated', (recommendations) => {
      console.log('Recommendations Updated:', recommendations);
    });

    socket.on('error', (error) => {
      console.error('Socket.IO Error:', error.message);
    });

    socket.on('disconnect', () => {
      console.log('Disconnected from server.');
    });
  </script>
</body>
</html>

     curl -X POST https://your-backend-domain.com/api/drafts/12345/update \
     -H "Content-Type: application/json" \
     -d '{"currentPick": "Sol Ring", "pickedBy": "Player2"}'
     

     // models/Draft.js
     module.exports = (sequelize, DataTypes) => {
       const Draft = sequelize.define('Draft', {
         id: {
           type: DataTypes.UUID,
           defaultValue: DataTypes.UUIDV4,
           primaryKey: true,
         },
         status: {
           type: DataTypes.ENUM('ongoing', 'completed'),
           defaultValue: 'ongoing',
         },
         createdAt: {
           type: DataTypes.DATE,
           allowNull: false,
         },
         updatedAt: {
           type: DataTypes.DATE,
           allowNull: false,
         },
       }, {
         tableName: 'drafts',
       });
       Draft.associate = (models) => {
         Draft.hasMany(models.DraftedCard, { foreignKey: 'draftId', as: 'picks' });
       };
       return Draft;
     };
     

     // models/DraftedCard.js
     module.exports = (sequelize, DataTypes) => {
       const DraftedCard = sequelize.define('DraftedCard', {
         id: {
           type: DataTypes.UUID,
           defaultValue: DataTypes.UUIDV4,
           primaryKey: true,
         },
         draftId: {
           type: DataTypes.UUID,
           allowNull: false,
           references: {
             model: 'drafts',
             key: 'id',
           },
           onDelete: 'CASCADE',
         },
         userId: {
           type: DataTypes.UUID,
           allowNull: false,
           references: {
             model: 'users',
             key: 'id',
           },
           onDelete: 'CASCADE',
         },
         cardId: {
           type: DataTypes.UUID,
           allowNull: false,
           references: {
             model: 'cards',
             key: 'id',
           },
           onDelete: 'CASCADE',
         },
         pickedAt: {
           type: DataTypes.DATE,
           defaultValue: DataTypes.NOW,
         },
         createdAt: {
           type: DataTypes.DATE,
           allowNull: false,
         },
         updatedAt: {
           type: DataTypes.DATE,
           allowNull: false,
         },
       }, {
         tableName: 'drafted_cards',
       });
       DraftedCard.associate = (models) => {
         DraftedCard.belongsTo(models.Draft, { foreignKey: 'draftId', as: 'draft' });
         DraftedCard.belongsTo(models.User, { foreignKey: 'userId', as: 'user' });
         DraftedCard.belongsTo(models.Card, { foreignKey: 'cardId', as: 'card' });
       };
       return DraftedCard;
     };
     

     // routes/drafts.js
     const express = require('express');
     const router = express.Router();
     const { Draft, DraftedCard, Card, User } = require('../models');
     const authenticate = require('../middleware/authenticate'); // JWT authentication middleware
     const { Op } = require('sequelize');
     
     // GET /api/drafts/:id/picks
     router.get('/:id/picks', authenticate, async (req, res) => {
       const { id } = req.params;
       const userId = req.user.id; // Assuming authenticate middleware attaches user info to req.user
     
       try {
         // Validate draft ID
         if (!id || !/^[0-9a-fA-F-]{36}$/.test(id)) { // UUID validation
           return res.status(400).json({ message: 'Invalid draft ID format.' });
         }
     
         // Check if the draft exists and the user is part of it
         const draft = await Draft.findOne({
           where: { id: id },
           include: [{
             model: DraftedCard,
             as: 'picks',
             include: [
               { model: User, as: 'user', attributes: ['id', 'username'] },
               { model: Card, as: 'card', attributes: ['id', 'name', 'manaCost', 'typeLine', 'oracleText', 'imageUri'] },
             ],
           }],
         });
     
         if (!draft) {
           return res.status(404).json({ message: 'Draft session not found.' });
         }
     
         // (Optional) Check if the user is part of the draft
         // Implement your logic here, e.g., check if user has a pick in the draft
     
         // Retrieve current picks
         const picks = draft.picks.map(pick => ({
           pickId: pick.id,
           user: {
             id: pick.user.id,
             username: pick.user.username,
           },
           card: {
             id: pick.card.id,
             name: pick.card.name,
             manaCost: pick.card.manaCost,
             typeLine: pick.card.typeLine,
             oracleText: pick.card.oracleText,
             imageUri: pick.card.imageUri,
           },
           pickedAt: pick.pickedAt,
         }));
     
         res.json({ draftId: id, picks: picks });
       } catch (error) {
         console.error(Error fetching draft picks for draft ${id}:, error);
         res.status(500).json({ message: 'Internal Server Error' });
       }
     });
     
     module.exports = router;
     

     // index.js (continued)
     const draftsRouter = require('./routes/drafts');
     
     // Use JSON middleware for parsing request bodies
     app.use(express.json());
     
     // Mount the drafts router at /api/drafts
     app.use('/api/drafts', draftsRouter);
     
     // ... existing code ...
     

     // middleware/authenticate.js
     const jwt = require('jsonwebtoken');
     const winston = require('winston');
     
     module.exports = (req, res, next) => {
       const authHeader = req.headers.authorization;
     
       if (!authHeader || !authHeader.startsWith('Bearer ')) {
         return res.status(401).json({ message: 'Authorization header missing or malformed.' });
       }
     
       const token = authHeader.split(' ')[1];
     
       jwt.verify(token, process.env.JWT_SECRET, (err, decoded) => {
         if (err) {
           winston.warn(Invalid JWT token: ${err.message});
           return res.status(401).json({ message: 'Invalid or expired token.' });
         }
     
         req.user = decoded; // Attach decoded token data to request
         next();
       });
     };
     

     curl -H "Authorization: Bearer your_jwt_token_here" https://your-backend-domain.com/api/drafts/123e4567-e89b-12d3-a456-426614174000/picks
     

     {
       "draftId": "123e4567-e89b-12d3-a456-426614174000",
       "picks": [
         {
           "pickId": "pick-uuid-1",
           "user": {
             "id": "user-uuid-1",
             "username": "PlayerOne"
           },
           "card": {
             "id": "card-uuid-1",
             "name": "Black Lotus",
             "manaCost": "{0}",
             "typeLine": "Artifact",
             "oracleText": "{T}, Sacrifice Black Lotus: Add three mana of any one color.",
             "imageUri": "https://c1.scryfall.com/file/scryfall-cards/normal/front/5/3/534ed3e0-f8b6-4bf4-86f6-38fa6059e8de.jpg?1687522176"
           },
           "pickedAt": "2024-04-27T12:00:00.000Z"
         },
         // ... other picks ...
       ]
     }
     

   // routes/drafts.js (continued)
   
   // POST /api/drafts
   router.post('/', authenticate, async (req, res) => {
     const userId = req.user.id; // Assuming authenticate middleware attaches user info to req.user
     const { participants } = req.body; // Expecting an array of user IDs participating in the draft
     
     // Validate participants
     if (!Array.isArray(participants) || participants.length < 2) {
       return res.status(400).json({ message: 'Participants must be an array with at least two user IDs.' });
     }
     
     // Further validation can be added here (e.g., verify that user IDs exist)
     
     try {
       // Create a new draft session
       const newDraft = await Draft.create({
         // Additional fields can be added as needed
       });
     
       // Assign participants to the draft
       // Assuming there's a DraftParticipant model to handle many-to-many relationships
       // If not, adjust according to your database schema
       await Promise.all(participants.map(participantId => {
         return DraftParticipant.create({
           draftId: newDraft.id,
           userId: participantId,
         });
       }));
     
       res.status(201).json({ message: 'Draft session created successfully.', draftId: newDraft.id });
     } catch (error) {
       console.error('Error creating new draft session:', error);
       res.status(500).json({ message: 'Internal Server Error' });
     }
   });
   
   module.exports = router;
   

   // models/DraftParticipant.js
   module.exports = (sequelize, DataTypes) => {
     const DraftParticipant = sequelize.define('DraftParticipant', {
       id: {
         type: DataTypes.UUID,
         defaultValue: DataTypes.UUIDV4,
         primaryKey: true,
       },
       draftId: {
         type: DataTypes.UUID,
         allowNull: false,
         references: {
           model: 'drafts',
           key: 'id',
         },
         onDelete: 'CASCADE',
       },
       userId: {
         type: DataTypes.UUID,
         allowNull: false,
         references: {
           model: 'users',
           key: 'id',
         },
         onDelete: 'CASCADE',
       },
       createdAt: {
         type: DataTypes.DATE,
         allowNull: false,
       },
       updatedAt: {
         type: DataTypes.DATE,
         allowNull: false,
       },
     }, {
       tableName: 'draft_participants',
     });
     
     DraftParticipant.associate = (models) => {
       DraftParticipant.belongsTo(models.Draft, { foreignKey: 'draftId', as: 'draft' });
       DraftParticipant.belongsTo(models.User, { foreignKey: 'userId', as: 'user' });
     };
     
     return DraftParticipant;
   };
   

     // routes/drafts.js (continued)
     
     const { User, DraftParticipant } = require('../models');
     
     // POST /api/drafts
     router.post('/', authenticate, async (req, res) => {
       const userId = req.user.id;
       const { participants } = req.body;
     
       if (!Array.isArray(participants) || participants.length < 2) {
         return res.status(400).json({ message: 'Participants must be an array with at least two user IDs.' });
       }
     
       try {
         // Verify that all participant IDs exist
         const existingUsers = await User.findAll({
           where: {
             id: {
               [Op.in]: participants,
             },
           },
         });
     
         if (existingUsers.length !== participants.length) {
           return res.status(400).json({ message: 'One or more participant user IDs are invalid.' });
         }
     
         // Create a new draft session
         const newDraft = await Draft.create({});
     
         // Assign participants to the draft
         await Promise.all(participants.map(participantId => {
           return DraftParticipant.create({
             draftId: newDraft.id,
             userId: participantId,
           });
         }));
     
         res.status(201).json({ message: 'Draft session created successfully.', draftId: newDraft.id });
       } catch (error) {
         console.error('Error creating new draft session:', error);
         res.status(500).json({ message: 'Internal Server Error' });
       }
     });
     

     curl -X POST https://your-backend-domain.com/api/drafts \
     -H "Authorization: Bearer your_jwt_token_here" \
     -H "Content-Type: application/json" \
     -d '{
       "participants": [
         "user-uuid-1",
         "user-uuid-2",
         "user-uuid-3"
       ]
     }'
     

     {
       "message": "Draft session created successfully.",
       "draftId": "123e4567-e89b-12d3-a456-426614174000"
     }
     

   // routes/drafts.js (continued)
   
   // PUT /api/drafts/:id/picks
   router.put('/:id/picks', authenticate, async (req, res) => {
     const { id } = req.params;
     const userId = req.user.id;
     const { cardId } = req.body; // Expecting the ID of the card being picked
     
     // Validate input
     if (!cardId || !/^[0-9a-fA-F-]{36}$/.test(cardId)) { // UUID validation
       return res.status(400).json({ message: 'Invalid or missing card ID.' });
     }
     
     try {
       // Validate draft ID
       if (!id || !/^[0-9a-fA-F-]{36}$/.test(id)) {
         return res.status(400).json({ message: 'Invalid draft ID format.' });
       }
     
       // Check if the draft exists and is ongoing
       const draft = await Draft.findOne({
         where: { id: id, status: 'ongoing' },
         include: [{
           model: DraftParticipant,
           as: 'participants',
           where: { userId: userId },
           attributes: [], // No need to retrieve participant data
         }],
       });
     
       if (!draft) {
         return res.status(404).json({ message: 'Draft session not found or already completed.' });
       }
     
       // Check if the user has already made a pick (prevent duplicate picks)
       const existingPick = await DraftedCard.findOne({
         where: { draftId: id, userId: userId },
       });
     
       if (existingPick) {
         return res.status(400).json({ message: 'User has already made a pick in this draft.' });
       }
     
       // Verify that the card exists
       const card = await Card.findOne({ where: { id: cardId } });
       if (!card) {
         return res.status(400).json({ message: 'Card not found.' });
       }
     
       // Create a new draft pick
       const newPick = await DraftedCard.create({
         draftId: id,
         userId: userId,
         cardId: cardId,
       });
     
       res.status(200).json({
         message: 'Draft pick updated successfully.',
         pick: {
           pickId: newPick.id,
           userId: userId,
           cardId: cardId,
           pickedAt: newPick.pickedAt,
         },
       });
     } catch (error) {
       console.error(Error updating draft picks for draft ${id}:, error);
       res.status(500).json({ message: 'Internal Server Error' });
     }
   });
   
   module.exports = router;
   

   // routes/drafts.js (continued)
   
   const io = require('../index').io; // Assuming Socket.IO instance is exported from index.js
   
   // Inside the PUT /api/drafts/:id/picks endpoint, after creating a new pick:
   
   // Broadcast the new pick to all clients in the draft room
   io.to(draft_${id}).emit('newPick', {
     pickId: newPick.id,
     userId: userId,
     cardId: cardId,
     pickedAt: newPick.pickedAt,
   });
   

     curl -X PUT https://your-backend-domain.com/api/drafts/123e4567-e89b-12d3-a456-426614174000/picks \
     -H "Authorization: Bearer your_jwt_token_here" \
     -H "Content-Type: application/json" \
     -d '{
       "cardId": "card-uuid-1"
     }'
     

     {
       "message": "Draft pick updated successfully.",
       "pick": {
         "pickId": "pick-uuid-1",
         "userId": "user-uuid-1",
         "cardId": "card-uuid-1",
         "pickedAt": "2024-04-27T12:00:00.000Z"
       }
     }
     

     // middleware/authenticate.js
     const jwt = require('jsonwebtoken');
     const winston = require('winston');
     
     module.exports = (req, res, next) => {
       const authHeader = req.headers.authorization;
     
       if (!authHeader || !authHeader.startsWith('Bearer ')) {
         return res.status(401).json({ message: 'Authorization header missing or malformed.' });
       }
     
       const token = authHeader.split(' ')[1];
     
       jwt.verify(token, process.env.JWT_SECRET, (err, decoded) => {
         if (err) {
           winston.warn(Invalid JWT token: ${err.message});
           return res.status(401).json({ message: 'Invalid or expired token.' });
         }
     
         req.user = decoded; // Attach decoded token data to request
         next();
       });
     };
     

     // routes/drafts.js (continued)
     const express = require('express');
     const router = express.Router();
     const { Draft, DraftedCard, Card, User, DraftParticipant } = require('../models');
     const authenticate = require('../middleware/authenticate');
     const { Op } = require('sequelize');
     const io = require('../index').io; // Socket.IO instance
     const validator = require('validator');
     
     // Apply authenticate middleware to all routes in this router
     router.use(authenticate);
     
     // ... existing route definitions ...
     

     // middleware/authorize.js
     module.exports = (roles = []) => {
       // roles param can be a single role string (e.g., 'admin') or an array of roles
       if (typeof roles === 'string') {
         roles = [roles];
       }
     
       return [
         (req, res, next) => {
           if (!roles.length || roles.includes(req.user.role)) {
             return next();
           }
           res.status(403).json({ message: 'Forbidden: You do not have access to this resource.' });
         }
       ];
     };
     

       // routes/drafts.js (continued)
       const authorize = require('../middleware/authorize');
     
       // Example: Only admins can retrieve all drafts
       router.get('/', authorize('admin'), async (req, res) => {
         // Implementation...
       });
       

     const session = require('express-session');
     
     app.use(session({
       secret: process.env.SESSION_SECRET,
       resave: false,
       saveUninitialized: false,
       cookie: {
         secure: true, // Ensures the browser only sends the cookie over HTTPS
         httpOnly: true, // Prevents client-side JavaScript from accessing the cookie
         sameSite: 'strict', // Protects against CSRF
       },
     }));
     

     // routes/drafts.js (continued)
     
     // Apply rate limiter to specific routes if needed
     const specificLimiter = rateLimit({
       windowMs: 60 * 1000, // 1 minute
       max: 30, // limit each IP to 30 requests per windowMs
       message: 'Too many requests, please try again later.',
     });
     
     // Apply to the GET /api/drafts/:id/picks endpoint
     router.get('/:id/picks', specificLimiter, async (req, res) => {
       // Implementation...
     });
     

     // index.js (continued)
     const helmet = require('helmet');
     
     app.use(helmet({
       contentSecurityPolicy: {
         directives: {
           defaultSrc: ["'self'"],
           scriptSrc: ["'self'", "https://cdn.socket.io"],
           connectSrc: ["'self'", "https://your-backend-domain.com"],
           imgSrc: ["'self'", "https://c1.scryfall.com"],
           styleSrc: ["'self'", "'unsafe-inline'"],
           // Add other directives as needed
         },
       },
     }));
     

// routes/drafts.js
const express = require('express');
const router = express.Router();
const { Draft, DraftedCard, Card, User, DraftParticipant } = require('../models');
const authenticate = require('../middleware/authenticate');
const authorize = require('../middleware/authorize'); // For RBAC if needed
const { Op } = require('sequelize');
const io = require('../index').io; // Exported Socket.IO instance
const validator = require('validator');
const winston = require('winston');

// Apply authenticate middleware to all routes in this router
router.use(authenticate);

/**
 * POST /api/drafts
 * Initialize a new draft session
 */
router.post('/', async (req, res) => {
  const userId = req.user.id;
  const { participants } = req.body;

  if (!Array.isArray(participants) || participants.length < 2) {
    return res.status(400).json({ message: 'Participants must be an array with at least two user IDs.' });
  }

  try {
    // Verify that all participant IDs exist
    const existingUsers = await User.findAll({
      where: {
        id: {
          [Op.in]: participants,
        },
      },
    });

    if (existingUsers.length !== participants.length) {
      return res.status(400).json({ message: 'One or more participant user IDs are invalid.' });
    }

    // Create a new draft session
    const newDraft = await Draft.create({});

    // Assign participants to the draft
    await Promise.all(participants.map(participantId => {
      return DraftParticipant.create({
        draftId: newDraft.id,
        userId: participantId,
      });
    }));

    res.status(201).json({ message: 'Draft session created successfully.', draftId: newDraft.id });
  } catch (error) {
    winston.error(Error creating new draft session: ${error.message});
    res.status(500).json({ message: 'Internal Server Error' });
  }
});

/**
 * GET /api/drafts/:id/picks
 * Retrieve current picks in a draft session
 */
router.get('/:id/picks', async (req, res) => {
  const { id } = req.params;
  const userId = req.user.id;

  try {
    // Validate draft ID format
    if (!id || !validator.isUUID(id)) {
      return res.status(400).json({ message: 'Invalid draft ID format.' });
    }

    // Check if the draft exists and is ongoing
    const draft = await Draft.findOne({
      where: { id: id, status: 'ongoing' },
      include: [{
        model: DraftedCard,
        as: 'picks',
        include: [
          { model: User, as: 'user', attributes: ['id', 'username'] },
          { model: Card, as: 'card', attributes: ['id', 'name', 'manaCost', 'typeLine', 'oracleText', 'imageUri'] },
        ],
      }, {
        model: DraftParticipant,
        as: 'participants',
        where: { userId: userId },
        attributes: [],
      }],
    });

    if (!draft) {
      return res.status(404).json({ message: 'Draft session not found or already completed.' });
    }

    // Retrieve current picks
    const picks = draft.picks.map(pick => ({
      pickId: pick.id,
      user: {
        id: pick.user.id,
        username: pick.user.username,
      },
      card: {
        id: pick.card.id,
        name: pick.card.name,
        manaCost: pick.card.manaCost,
        typeLine: pick.card.typeLine,
        oracleText: pick.card.oracleText,
        imageUri: pick.card.imageUri,
      },
      pickedAt: pick.pickedAt,
    }));

    res.json({ draftId: id, picks: picks });
  } catch (error) {
    winston.error(Error fetching draft picks for draft ${id}: ${error.message});
    res.status(500).json({ message: 'Internal Server Error' });
  }
});

/**
 * PUT /api/drafts/:id/picks
 * Update draft picks as users make selections
 */
router.put('/:id/picks', async (req, res) => {
  const { id } = req.params;
  const userId = req.user.id;
  const { cardId } = req.body;

  // Validate input
  if (!cardId || !validator.isUUID(cardId)) {
    return res.status(400).json({ message: 'Invalid or missing card ID.' });
  }

  try {
    // Validate draft ID format
    if (!id || !validator.isUUID(id)) {
      return res.status(400).json({ message: 'Invalid draft ID format.' });
    }

    // Check if the draft exists and is ongoing
    const draft = await Draft.findOne({
      where: { id: id, status: 'ongoing' },
      include: [{
        model: DraftParticipant,
        as: 'participants',
        where: { userId: userId },
        attributes: [],
      }],
    });

    if (!draft) {
      return res.status(404).json({ message: 'Draft session not found or already completed.' });
    }

    // Check if the user has already made a pick
    const existingPick = await DraftedCard.findOne({
      where: { draftId: id, userId: userId },
    });

    if (existingPick) {
      return res.status(400).json({ message: 'User has already made a pick in this draft.' });
    }

    // Verify that the card exists
    const card = await Card.findOne({ where: { id: cardId } });
    if (!card) {
      return res.status(400).json({ message: 'Card not found.' });
    }

    // (Optional) Check if the card is available (not already drafted)
    const isCardDrafted = await DraftedCard.findOne({
      where: { draftId: id, cardId: cardId },
    });

    if (isCardDrafted) {
      return res.status(400).json({ message: 'Card has already been drafted.' });
    }

    // Create a new draft pick
    const newPick = await DraftedCard.create({
      draftId: id,
      userId: userId,
      cardId: cardId,
    });

    // Broadcast the new pick via Socket.IO
    io.to(draft_${id}).emit('newPick', {
      pickId: newPick.id,
      userId: userId,
      cardId: cardId,
      pickedAt: newPick.pickedAt,
    });

    res.status(200).json({
      message: 'Draft pick updated successfully.',
      pick: {
        pickId: newPick.id,
        userId: userId,
        cardId: cardId,
        pickedAt: newPick.pickedAt,
      },
    });
  } catch (error) {
    winston.error(Error updating draft picks for draft ${id}: ${error.message});
    res.status(500).json({ message: 'Internal Server Error' });
  }
});

/**
 * GET /api/drafts/:id/recommendations
 * Retrieve recommendations for the draft session
 */
router.get('/:id/recommendations', async (req, res) => {
  const { id } = req.params;
  const userId = req.user.id;

  try {
    // Validate draft ID format
    if (!id || !validator.isUUID(id)) {
      return res.status(400).json({ message: 'Invalid draft ID format.' });
    }

    // Check if the draft exists
    const draft = await Draft.findOne({
      where: { id: id },
      include: [{
        model: DraftParticipant,
        as: 'participants',
        where: { userId: userId },
        attributes: [],
      }],
    });

    if (!draft) {
      return res.status(404).json({ message: 'Draft session not found.' });
    }

    // Retrieve recommendations (Assuming recommendations are stored or generated on-the-fly)
    // For demonstration, let's assume recommendations are stored in the database
    const recommendations = await Recommendation.findAll({
      where: { draftId: id },
      include: [{ model: Card, as: 'card', attributes: ['id', 'name', 'manaCost', 'typeLine', 'oracleText', 'imageUri'] }],
      order: [['score', 'DESC']],
      limit: 10, // Top 10 recommendations
    });

    // Format recommendations
    const formattedRecommendations = recommendations.map(rec => ({
      recommendationId: rec.id,
      card: {
        id: rec.card.id,
        name: rec.card.name,
        manaCost: rec.card.manaCost,
        typeLine: rec.card.typeLine,
        oracleText: rec.card.oracleText,
        imageUri: rec.card.imageUri,
      },
      score: rec.score, // e.g., synergy score
    }));

    res.json({ draftId: id, recommendations: formattedRecommendations });
  } catch (error) {
    winston.error(Error fetching recommendations for draft ${id}: ${error.message});
    res.status(500).json({ message: 'Internal Server Error' });
  }
});

/**
 * GET /api/drafts
 * Retrieve all draft sessions (Admin Use)
 */
router.get('/', authorize('admin'), async (req, res) => {
  try {
    const drafts = await Draft.findAll({
      include: [{
        model: DraftParticipant,
        as: 'participants',
        include: [{ model: User, as: 'user', attributes: ['id', 'username'] }],
      }, {
        model: DraftedCard,
        as: 'picks',
        include: [
          { model: User, as: 'user', attributes: ['id', 'username'] },
          { model: Card, as: 'card', attributes: ['id', 'name'] },
        ],
      }],
      order: [['createdAt', 'DESC']],
    });

    const formattedDrafts = drafts.map(draft => ({
      draftId: draft.id,
      status: draft.status,
      createdAt: draft.createdAt,
      updatedAt: draft.updatedAt,
      participants: draft.participants.map(participant => ({
        userId: participant.user.id,
        username: participant.user.username,
      })),
      picks: draft.picks.map(pick => ({
        pickId: pick.id,
        userId: pick.user.id,
        username: pick.user.username,
        cardId: pick.card.id,
        cardName: pick.card.name,
        pickedAt: pick.pickedAt,
      })),
    }));

    res.json({ drafts: formattedDrafts });
  } catch (error) {
    winston.error(Error fetching all drafts: ${error.message});
    res.status(500).json({ message: 'Internal Server Error' });
  }
});

/**
 * GET /api/drafts/:id
 * Retrieve detailed information about a specific draft session
 */
router.get('/:id', async (req, res) => {
  const { id } = req.params;
  const userId = req.user.id;

  try {
    // Validate draft ID format
    if (!id || !validator.isUUID(id)) {
      return res.status(400).json({ message: 'Invalid draft ID format.' });
    }

    // Check if the draft exists and the user is part of it
    const draft = await Draft.findOne({
      where: { id: id },
      include: [{
        model: DraftParticipant,
        as: 'participants',
        where: { userId: userId },
        attributes: [],
      }, {
        model: DraftedCard,
        as: 'picks',
        include: [
          { model: User, as: 'user', attributes: ['id', 'username'] },
          { model: Card, as: 'card', attributes: ['id', 'name', 'manaCost', 'typeLine', 'oracleText', 'imageUri'] },
        ],
      }],
    });

    if (!draft) {
      return res.status(404).json({ message: 'Draft session not found.' });
    }

    // Format draft details
    const draftDetails = {
      draftId: draft.id,
      status: draft.status,
      createdAt: draft.createdAt,
      updatedAt: draft.updatedAt,
      picks: draft.picks.map(pick => ({
        pickId: pick.id,
        user: {
          id: pick.user.id,
          username: pick.user.username,
        },
        card: {
          id: pick.card.id,
          name: pick.card.name,
          manaCost: pick.card.manaCost,
          typeLine: pick.card.typeLine,
          oracleText: pick.card.oracleText,
          imageUri: pick.card.imageUri,
        },
        pickedAt: pick.pickedAt,
      })),
    };

    res.json(draftDetails);
  } catch (error) {
    winston.error(Error fetching draft details for draft ${id}: ${error.message});
    res.status(500).json({ message: 'Internal Server Error' });
  }
});

/**
 * DELETE /api/drafts/:id
 * Delete a specific draft session (Admin Use)
 */
router.delete('/:id', authorize('admin'), async (req, res) => {
  const { id } = req.params;

  try {
    // Validate draft ID format
    if (!id || !validator.isUUID(id)) {
      return res.status(400).json({ message: 'Invalid draft ID format.' });
    }

    // Delete the draft
    const deletedCount = await Draft.destroy({ where: { id: id } });

    if (deletedCount === 0) {
      return res.status(404).json({ message: 'Draft session not found.' });
    }

    res.json({ message: 'Draft session deleted successfully.' });
  } catch (error) {
    winston.error(Error deleting draft ${id}: ${error.message});
    res.status(500).json({ message: 'Internal Server Error' });
  }
});

module.exports = router;

   // models/User.js (continued)
   module.exports = (sequelize, DataTypes) => {
     const User = sequelize.define('User', {
       id: {
         type: DataTypes.UUID,
         defaultValue: DataTypes.UUIDV4,
         primaryKey: true,
       },
       username: {
         type: DataTypes.STRING,
         allowNull: false,
         unique: true,
       },
       email: {
         type: DataTypes.STRING,
         allowNull: false,
         unique: true,
         validate: {
           isEmail: true,
         },
       },
       passwordHash: {
         type: DataTypes.STRING,
         allowNull: false,
       },
       role: {
         type: DataTypes.ENUM('user', 'admin'),
         defaultValue: 'user',
       },
       createdAt: {
         type: DataTypes.DATE,
         allowNull: false,
       },
       updatedAt: {
         type: DataTypes.DATE,
         allowNull: false,
       },
     }, {
       tableName: 'users',
     });
     
     User.associate = (models) => {
       User.hasMany(models.DraftedCard, { foreignKey: 'userId', as: 'picks' });
       User.hasMany(models.DraftParticipant, { foreignKey: 'userId', as: 'draftsParticipated' });
     };
     
     return User;
   };
   

   // middleware/authorize.js
   module.exports = (roles = []) => {
     // roles param can be a single role string (e.g., 'admin') or an array of roles
     if (typeof roles === 'string') {
       roles = [roles];
     }
   
     return [
       (req, res, next) => {
         if (!roles.length || roles.includes(req.user.role)) {
           return next();
         }
         res.status(403).json({ message: 'Forbidden: You do not have access to this resource.' });
       }
     ];
   };
   

   // routes/drafts.js (continued)
   
   const authorize = require('../middleware/authorize');
   
   // DELETE /api/drafts/:id (Admin only)
   router.delete('/:id', authorize('admin'), async (req, res) => {
     // Implementation...
   });
   
   // GET /api/drafts (Admin only)
   router.get('/', authorize('admin'), async (req, res) => {
     // Implementation...
   });
   

// routes/drafts.js
const express = require('express');
const router = express.Router();
const { Draft, DraftedCard, Card, User, DraftParticipant, Recommendation } = require('../models');
const authenticate = require('../middleware/authenticate');
const authorize = require('../middleware/authorize');
const { Op } = require('sequelize');
const io = require('../index').io; // Socket.IO instance
const validator = require('validator');
const winston = require('winston');

// Apply authenticate middleware to all routes in this router
router.use(authenticate);

/**
 * POST /api/drafts
 * Initialize a new draft session
 */
router.post('/', async (req, res) => {
  const userId = req.user.id;
  const { participants } = req.body;

  if (!Array.isArray(participants) || participants.length < 2) {
    return res.status(400).json({ message: 'Participants must be an array with at least two user IDs.' });
  }

  try {
    // Verify that all participant IDs exist
    const existingUsers = await User.findAll({
      where: {
        id: {
          [Op.in]: participants,
        },
      },
    });

    if (existingUsers.length !== participants.length) {
      return res.status(400).json({ message: 'One or more participant user IDs are invalid.' });
    }

    // Create a new draft session
    const newDraft = await Draft.create({});

    // Assign participants to the draft
    await Promise.all(participants.map(participantId => {
      return DraftParticipant.create({
        draftId: newDraft.id,
        userId: participantId,
      });
    }));

    res.status(201).json({ message: 'Draft session created successfully.', draftId: newDraft.id });
  } catch (error) {
    winston.error(Error creating new draft session: ${error.message});
    res.status(500).json({ message: 'Internal Server Error' });
  }
});

/**
 * GET /api/drafts/:id/picks
 * Retrieve current picks in a draft session
 */
router.get('/:id/picks', async (req, res) => {
  const { id } = req.params;
  const userId = req.user.id;

  try {
    // Validate draft ID format
    if (!id || !validator.isUUID(id)) {
      return res.status(400).json({ message: 'Invalid draft ID format.' });
    }

    // Check if the draft exists and is ongoing
    const draft = await Draft.findOne({
      where: { id: id, status: 'ongoing' },
      include: [{
        model: DraftedCard,
        as: 'picks',
        include: [
          { model: User, as: 'user', attributes: ['id', 'username'] },
          { model: Card, as: 'card', attributes: ['id', 'name', 'manaCost', 'typeLine', 'oracleText', 'imageUri'] },
        ],
      }, {
        model: DraftParticipant,
        as: 'participants',
        where: { userId: userId },
        attributes: [],
      }],
    });

    if (!draft) {
      return res.status(404).json({ message: 'Draft session not found or already completed.' });
    }

    // Retrieve current picks
    const picks = draft.picks.map(pick => ({
      pickId: pick.id,
      user: {
        id: pick.user.id,
        username: pick.user.username,
      },
      card: {
        id: pick.card.id,
        name: pick.card.name,
        manaCost: pick.card.manaCost,
        typeLine: pick.card.typeLine,
        oracleText: pick.card.oracleText,
        imageUri: pick.card.imageUri,
      },
      pickedAt: pick.pickedAt,
    }));

    res.json({ draftId: id, picks: picks });
  } catch (error) {
    winston.error(Error fetching draft picks for draft ${id}: ${error.message});
    res.status(500).json({ message: 'Internal Server Error' });
  }
});

/**
 * PUT /api/drafts/:id/picks
 * Update draft picks as users make selections
 */
router.put('/:id/picks', async (req, res) => {
  const { id } = req.params;
  const userId = req.user.id;
  const { cardId } = req.body;

  // Validate input
  if (!cardId || !validator.isUUID(cardId)) {
    return res.status(400).json({ message: 'Invalid or missing card ID.' });
  }

  try {
    // Validate draft ID format
    if (!id || !validator.isUUID(id)) {
      return res.status(400).json({ message: 'Invalid draft ID format.' });
    }

    // Check if the draft exists and is ongoing
    const draft = await Draft.findOne({
      where: { id: id, status: 'ongoing' },
      include: [{
        model: DraftParticipant,
        as: 'participants',
        where: { userId: userId },
        attributes: [],
      }],
    });

    if (!draft) {
      return res.status(404).json({ message: 'Draft session not found or already completed.' });
    }

    // Check if the user has already made a pick
    const existingPick = await DraftedCard.findOne({
      where: { draftId: id, userId: userId },
    });

    if (existingPick) {
      return res.status(400).json({ message: 'User has already made a pick in this draft.' });
    }

    // Verify that the card exists
    const card = await Card.findOne({ where: { id: cardId } });
    if (!card) {
      return res.status(400).json({ message: 'Card not found.' });
    }

    // (Optional) Check if the card is available (not already drafted)
    const isCardDrafted = await DraftedCard.findOne({
      where: { draftId: id, cardId: cardId },
    });

    if (isCardDrafted) {
      return res.status(400).json({ message: 'Card has already been drafted.' });
    }

    // Create a new draft pick
    const newPick = await DraftedCard.create({
      draftId: id,
      userId: userId,
      cardId: cardId,
    });

    // Broadcast the new pick via Socket.IO
    io.to(draft_${id}).emit('newPick', {
      pickId: newPick.id,
      userId: userId,
      cardId: cardId,
      pickedAt: newPick.pickedAt,
    });

    res.status(200).json({
      message: 'Draft pick updated successfully.',
      pick: {
        pickId: newPick.id,
        userId: userId,
        cardId: cardId,
        pickedAt: newPick.pickedAt,
      },
    });
  } catch (error) {
    winston.error(Error updating draft picks for draft ${id}: ${error.message});
    res.status(500).json({ message: 'Internal Server Error' });
  }
});

/**
 * GET /api/drafts/:id/recommendations
 * Retrieve recommendations for the draft session
 */
router.get('/:id/recommendations', async (req, res) => {
  const { id } = req.params;
  const userId = req.user.id;

  try {
    // Validate draft ID format
    if (!id || !validator.isUUID(id)) {
      return res.status(400).json({ message: 'Invalid draft ID format.' });
    }

    // Check if the draft exists
    const draft = await Draft.findOne({
      where: { id: id },
      include: [{
        model: DraftParticipant,
        as: 'participants',
        where: { userId: userId },
        attributes: [],
      }],
    });

    if (!draft) {
      return res.status(404).json({ message: 'Draft session not found.' });
    }

    // Retrieve recommendations (Assuming recommendations are stored or generated on-the-fly)
    // For demonstration, let's assume recommendations are stored in the database
    const recommendations = await Recommendation.findAll({
      where: { draftId: id },
      include: [{ model: Card, as: 'card', attributes: ['id', 'name', 'manaCost', 'typeLine', 'oracleText', 'imageUri'] }],
      order: [['score', 'DESC']],
      limit: 10, // Top 10 recommendations
    });

    // Format recommendations
    const formattedRecommendations = recommendations.map(rec => ({
      recommendationId: rec.id,
      card: {
        id: rec.card.id,
        name: rec.card.name,
        manaCost: rec.card.manaCost,
        typeLine: rec.card.typeLine,
        oracleText: rec.card.oracleText,
        imageUri: rec.card.imageUri,
      },
      score: rec.score, // e.g., synergy score
    }));

    res.json({ draftId: id, recommendations: formattedRecommendations });
  } catch (error) {
    winston.error(Error fetching recommendations for draft ${id}: ${error.message});
    res.status(500).json({ message: 'Internal Server Error' });
  }
});

/**
 * GET /api/drafts
 * Retrieve all draft sessions (Admin Use)
 */
router.get('/', authorize('admin'), async (req, res) => {
  try {
    const drafts = await Draft.findAll({
      include: [{
        model: DraftParticipant,
        as: 'participants',
        include: [{ model: User, as: 'user', attributes: ['id', 'username'] }],
      }, {
        model: DraftedCard,
        as: 'picks',
        include: [
          { model: User, as: 'user', attributes: ['id', 'username'] },
          { model: Card, as: 'card', attributes: ['id', 'name'] },
        ],
      }],
      order: [['createdAt', 'DESC']],
    });

    const formattedDrafts = drafts.map(draft => ({
      draftId: draft.id,
      status: draft.status,
      createdAt: draft.createdAt,
      updatedAt: draft.updatedAt,
      participants: draft.participants.map(participant => ({
        userId: participant.user.id,
        username: participant.user.username,
      })),
      picks: draft.picks.map(pick => ({
        pickId: pick.id,
        userId: pick.user.id,
        username: pick.user.username,
        cardId: pick.card.id,
        cardName: pick.card.name,
        pickedAt: pick.pickedAt,
      })),
    }));

    res.json({ drafts: formattedDrafts });
  } catch (error) {
    winston.error(Error fetching all drafts: ${error.message});
    res.status(500).json({ message: 'Internal Server Error' });
  }
});

/**
 * GET /api/drafts/:id
 * Retrieve detailed information about a specific draft session
 */
router.get('/:id', async (req, res) => {
  const { id } = req.params;
  const userId = req.user.id;

  try {
    // Validate draft ID format
    if (!id || !validator.isUUID(id)) {
      return res.status(400).json({ message: 'Invalid draft ID format.' });
    }

    // Check if the draft exists and the user is part of it
    const draft = await Draft.findOne({
      where: { id: id },
      include: [{
        model: DraftParticipant,
        as: 'participants',
        where: { userId: userId },
        attributes: [],
      }, {
        model: DraftedCard,
        as: 'picks',
        include: [
          { model: User, as: 'user', attributes: ['id', 'username'] },
          { model: Card, as: 'card', attributes: ['id', 'name', 'manaCost', 'typeLine', 'oracleText', 'imageUri'] },
        ],
      }],
    });

    if (!draft) {
      return res.status(404).json({ message: 'Draft session not found.' });
    }

    // Format draft details
    const draftDetails = {
      draftId: draft.id,
      status: draft.status,
      createdAt: draft.createdAt,
      updatedAt: draft.updatedAt,
      picks: draft.picks.map(pick => ({
        pickId: pick.id,
        user: {
          id: pick.user.id,
          username: pick.user.username,
        },
        card: {
          id: pick.card.id,
          name: pick.card.name,
          manaCost: pick.card.manaCost,
          typeLine: pick.card.typeLine,
          oracleText: pick.card.oracleText,
          imageUri: pick.card.imageUri,
        },
        pickedAt: pick.pickedAt,
      })),
    };

    res.json(draftDetails);
  } catch (error) {
    winston.error(Error fetching draft details for draft ${id}: ${error.message});
    res.status(500).json({ message: 'Internal Server Error' });
  }
});

/**
 * DELETE /api/drafts/:id
 * Delete a specific draft session (Admin Use)
 */
router.delete('/:id', authorize('admin'), async (req, res) => {
  const { id } = req.params;

  try {
    // Validate draft ID format
    if (!id || !validator.isUUID(id)) {
      return res.status(400).json({ message: 'Invalid draft ID format.' });
    }

    // Delete the draft
    const deletedCount = await Draft.destroy({ where: { id: id } });

    if (deletedCount === 0) {
      return res.status(404).json({ message: 'Draft session not found.' });
    }

    res.json({ message: 'Draft session deleted successfully.' });
  } catch (error) {
    winston.error(Error deleting draft ${id}: ${error.message});
    res.status(500).json({ message: 'Internal Server Error' });
  }
});

module.exports = router;

     npm install --save-dev supertest jest
     

       "scripts": {
         "test": "jest"
       },
       "jest": {
         "testEnvironment": "node"
       }
       

     // test/drafts.test.js
     const request = require('supertest');
     const app = require('../index'); // Ensure your Express app is exported from index.js
     const { User, Draft, DraftedCard, Card, DraftParticipant } = require('../models');
     const jwt = require('jsonwebtoken');
     
     describe('Drafts API Endpoints', () => {
       let server;
       let token;
       let adminToken;
       let user1, user2, card1;
     
       beforeAll(async () => {
         server = app.listen(4000, () => console.log('Test server running on port 4000'));
     
         // Create test users
         user1 = await User.create({
           username: 'testuser1',
           email: 'testuser1@example.com',
           passwordHash: 'hashed_password_1',
           role: 'user',
         });
     
         user2 = await User.create({
           username: 'testuser2',
           email: 'testuser2@example.com',
           passwordHash: 'hashed_password_2',
           role: 'user',
         });
     
         // Create an admin user
         const adminUser = await User.create({
           username: 'adminuser',
           email: 'admin@example.com',
           passwordHash: 'hashed_password_admin',
           role: 'admin',
         });
     
         // Generate JWT tokens
         token = jwt.sign({ id: user1.id, role: 'user' }, process.env.JWT_SECRET, { expiresIn: '1h' });
         adminToken = jwt.sign({ id: adminUser.id, role: 'admin' }, process.env.JWT_SECRET, { expiresIn: '1h' });
     
         // Create a test card
         card1 = await Card.create({
           name: 'Black Lotus',
           manaCost: '{0}',
           typeLine: 'Artifact',
           oracleText: '{T}, Sacrifice Black Lotus: Add three mana of any one color.',
           imageUri: 'https://c1.scryfall.com/file/scryfall-cards/normal/front/5/3/534ed3e0-f8b6-4bf4-86f6-38fa6059e8de.jpg?1687522176',
         });
       });
     
       afterAll(async () => {
         // Clean up database
         await DraftedCard.destroy({ where: {} });
         await DraftParticipant.destroy({ where: {} });
         await Draft.destroy({ where: {} });
         await User.destroy({ where: {} });
         await Card.destroy({ where: {} });
     
         // Close server
         server.close();
       });
     
       test('POST /api/drafts - Create a new draft', async () => {
         const response = await request(server)
           .post('/api/drafts')
           .set('Authorization', Bearer ${token})
           .send({
             participants: [user1.id, user2.id],
           });
     
         expect(response.statusCode).toBe(201);
         expect(response.body).toHaveProperty('draftId');
       });
     
       test('GET /api/drafts/:id/picks - Retrieve current picks', async () => {
         // Create a draft and add a pick
         const draft = await Draft.create({});
         await DraftParticipant.create({ draftId: draft.id, userId: user1.id });
         await DraftParticipant.create({ draftId: draft.id, userId: user2.id });
         await DraftedCard.create({ draftId: draft.id, userId: user1.id, cardId: card1.id });
     
         const response = await request(server)
           .get(/api/drafts/${draft.id}/picks)
           .set('Authorization', Bearer ${token});
     
         expect(response.statusCode).toBe(200);
         expect(response.body).toHaveProperty('picks');
         expect(response.body.picks.length).toBe(1);
         expect(response.body.picks[0].card.name).toBe('Black Lotus');
       });
     
       test('PUT /api/drafts/:id/picks - Update draft picks', async () => {
         // Create a draft without any picks
         const draft = await Draft.create({});
         await DraftParticipant.create({ draftId: draft.id, userId: user1.id });
         await DraftParticipant.create({ draftId: draft.id, userId: user2.id });
     
         const response = await request(server)
           .put(/api/drafts/${draft.id}/picks)
           .set('Authorization', Bearer ${token})
           .send({
             cardId: card1.id,
           });
     
         expect(response.statusCode).toBe(200);
         expect(response.body).toHaveProperty('pick');
         expect(response.body.pick.cardId).toBe(card1.id);
       });
     
       test('GET /api/drafts/:id/recommendations - Retrieve recommendations', async () => {
         // Create a draft and add recommendations
         const draft = await Draft.create({});
         await DraftParticipant.create({ draftId: draft.id, userId: user1.id });
         await Recommendation.create({ draftId: draft.id, cardId: card1.id, score: 95 });
     
         const response = await request(server)
           .get(/api/drafts/${draft.id}/recommendations)
           .set('Authorization', Bearer ${token});
     
         expect(response.statusCode).toBe(200);
         expect(response.body).toHaveProperty('recommendations');
         expect(response.body.recommendations.length).toBe(1);
         expect(response.body.recommendations[0].card.name).toBe('Black Lotus');
       });
     
       test('GET /api/drafts - Retrieve all drafts (Admin only)', async () => {
         const response = await request(server)
           .get('/api/drafts')
           .set('Authorization', Bearer ${adminToken});
     
         expect(response.statusCode).toBe(200);
         expect(response.body).toHaveProperty('drafts');
         expect(Array.isArray(response.body.drafts)).toBe(true);
       });
     
       test('DELETE /api/drafts/:id - Delete a draft (Admin only)', async () => {
         // Create a draft to delete
         const draft = await Draft.create({});
     
         const response = await request(server)
           .delete(/api/drafts/${draft.id})
           .set('Authorization', Bearer ${adminToken});
     
         expect(response.statusCode).toBe(200);
         expect(response.body).toHaveProperty('message', 'Draft session deleted successfully.');
       });
     });
     

     npm test
     

     PASS  test/drafts.test.js
      Drafts API Endpoints
        ✓ POST /api/drafts - Create a new draft (XX ms)
        ✓ GET /api/drafts/:id/picks - Retrieve current picks (XX ms)
        ✓ PUT /api/drafts/:id/picks - Update draft picks (XX ms)
        ✓ GET /api/drafts/:id/recommendations - Retrieve recommendations (XX ms)
        ✓ GET /api/drafts - Retrieve all drafts (Admin only) (XX ms)
        ✓ DELETE /api/drafts/:id - Delete a draft (Admin only) (XX ms)

     Test Suites: 1 passed, 1 total
     Tests:       6 passed, 6 total
     Snapshots:   0 total
     Time:        3.456 s
     

   // Modify GET /api/drafts to include pagination
   router.get('/', authorize('admin'), async (req, res) => {
     const { page = 1, limit = 10 } = req.query;
     const offset = (page - 1) * limit;
     
     try {
       const { rows: drafts, count } = await Draft.findAndCountAll({
         include: [{
           model: DraftParticipant,
           as: 'participants',
           include: [{ model: User, as: 'user', attributes: ['id', 'username'] }],
         }, {
           model: DraftedCard,
           as: 'picks',
           include: [
             { model: User, as: 'user', attributes: ['id', 'username'] },
             { model: Card, as: 'card', attributes: ['id', 'name'] },
           ],
         }],
         order: [['createdAt', 'DESC']],
         limit: parseInt(limit),
         offset: parseInt(offset),
       });
     
       const formattedDrafts = drafts.map(draft => ({
         draftId: draft.id,
         status: draft.status,
         createdAt: draft.createdAt,
         updatedAt: draft.updatedAt,
         participants: draft.participants.map(participant => ({
           userId: participant.user.id,
           username: participant.user.username,
         })),
         picks: draft.picks.map(pick => ({
           pickId: pick.id,
           userId: pick.user.id,
           username: pick.user.username,
           cardId: pick.card.id,
           cardName: pick.card.name,
           pickedAt: pick.pickedAt,
         })),
       }));
     
       res.json({
         totalDrafts: count,
         currentPage: parseInt(page),
         totalPages: Math.ceil(count / limit),
         drafts: formattedDrafts,
       });
     } catch (error) {
       winston.error(Error fetching all drafts: ${error.message});
       res.status(500).json({ message: 'Internal Server Error' });
     }
   });
   

   const { sequelize } = require('../models');
   
   router.post('/', async (req, res) => {
     const t = await sequelize.transaction();
     try {
       // Database operations within the transaction
       const newDraft = await Draft.create({}, { transaction: t });
       await DraftParticipant.bulkCreate(participants.map(id => ({
         draftId: newDraft.id,
         userId: id,
       })), { transaction: t });
       
       await t.commit();
       res.status(201).json({ message: 'Draft created.', draftId: newDraft.id });
     } catch (error) {
       await t.rollback();
       res.status(500).json({ message: 'Internal Server Error' });
     }
   });
   

   // Mount routers with versioning
   app.use('/api/v1/drafts', draftsRouter);
   

  C:\Users\<YourUsername>\AppData\Local\Wizards Of The Coast\MTGA\Logs
  

  ~/Library/Logs/Wizards Of The Coast/MTGA/
  

  ~/.wine/drive_c/users/<YourUsername>/Local Settings/Application Data/Wizards Of The Coast/MTGA/Logs
  

[2024-04-27 12:00:00.000] [Player] [INFO] DraftPick: {"draftId":"123e4567-e89b-12d3-a456-426614174000","userId":"user-uuid-1","cardId":"card-uuid-1","timestamp":"2024-04-27T12:00:00Z"}

   pip install watchdog psycopg2-binary
   

   mtg_log_parser/
   ├── parser.py
   ├── config.py
   └── requirements.txt
   

# config.py

import os

# Path to the Player.log file
LOG_FILE_PATH = os.path.expanduser('~/AppData/Local/Wizards Of The Coast/MTGA/Logs/Player.log')  # Update based on OS

# PostgreSQL Database Configuration
DB_CONFIG = {
    'dbname': 'mtg_draft',
    'user': 'your_db_username',
    'password': 'your_db_password',
    'host': 'localhost',
    'port': '5432',
}

-- drafts table
CREATE TABLE drafts (
    id UUID PRIMARY KEY,
    status VARCHAR(20) NOT NULL DEFAULT 'ongoing',
    created_at TIMESTAMP WITHOUT TIME ZONE DEFAULT (NOW() AT TIME ZONE 'utc'),
    updated_at TIMESTAMP WITHOUT TIME ZONE DEFAULT (NOW() AT TIME ZONE 'utc')
);

-- drafted_cards table
CREATE TABLE drafted_cards (
    id UUID PRIMARY KEY,
    draft_id UUID REFERENCES drafts(id) ON DELETE CASCADE,
    user_id UUID NOT NULL,
    card_id UUID NOT NULL,
    picked_at TIMESTAMP WITHOUT TIME ZONE DEFAULT (NOW() AT TIME ZONE 'utc')
);

-- recommendations table (optional, if storing recommendations)
CREATE TABLE recommendations (
    id UUID PRIMARY KEY,
    draft_id UUID REFERENCES drafts(id) ON DELETE CASCADE,
    card_id UUID REFERENCES cards(id) ON DELETE CASCADE,
    score INTEGER NOT NULL,
    created_at TIMESTAMP WITHOUT TIME ZONE DEFAULT (NOW() AT TIME ZONE 'utc')
);

-- cards table (assuming it's pre-populated with all MTG cards)
CREATE TABLE cards (
    id UUID PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    mana_cost VARCHAR(50),
    type_line VARCHAR(255),
    oracle_text TEXT,
    image_uri TEXT
);

# parser.py

import time
import json
import re
import psycopg2
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler
from config import LOG_FILE_PATH, DB_CONFIG
import logging
from uuid import UUID

# Setup logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s [%(levelname)s] %(message)s',
    handlers=[
        logging.FileHandler("parser.log"),
        logging.StreamHandler()
    ]
)
logger = logging.getLogger(__name__)

# Helper function to validate UUID
def is_valid_uuid(val):
    try:
        UUID(str(val))
        return True
    except ValueError:
        return False

# Database connection handler
class Database:
    def __init__(self, config):
        self.config = config
        self.conn = None
        self.connect()
    
    def connect(self):
        try:
            self.conn = psycopg2.connect(**self.config)
            self.conn.autocommit = True
            logger.info("Connected to PostgreSQL database.")
        except Exception as e:
            logger.error(f"Failed to connect to PostgreSQL: {e}")
            self.conn = None
    
    def reconnect(self):
        if self.conn:
            self.conn.close()
        self.connect()
    
    def insert_draft(self, draft_id):
        if not is_valid_uuid(draft_id):
            logger.warning(f"Attempted to insert invalid draft_id: {draft_id}")
            return
        try:
            with self.conn.cursor() as cur:
                cur.execute(
                    """
                    INSERT INTO drafts (id, status)
                    VALUES (%s, %s)
                    ON CONFLICT (id) DO NOTHING;
                    """,
                    (draft_id, 'ongoing')
                )
                logger.info(f"Inserted draft: {draft_id}")
        except Exception as e:
            logger.error(f"Error inserting draft {draft_id}: {e}")
    
    def insert_drafted_card(self, draft_id, user_id, card_id, picked_at):
        if not all(is_valid_uuid(val) for val in [draft_id, user_id, card_id]):
            logger.warning(f"Invalid UUID in drafted_card: draft_id={draft_id}, user_id={user_id}, card_id={card_id}")
            return
        try:
            with self.conn.cursor() as cur:
                cur.execute(
                    """
                    INSERT INTO drafted_cards (id, draft_id, user_id, card_id, picked_at)
                    VALUES (gen_random_uuid(), %s, %s, %s, %s)
                    ON CONFLICT DO NOTHING;
                    """,
                    (draft_id, user_id, card_id, picked_at)
                )
                logger.info(f"Inserted drafted card: draft_id={draft_id}, user_id={user_id}, card_id={card_id}")
        except Exception as e:
            logger.error(f"Error inserting drafted card: {e}")
    
    def insert_recommendation(self, draft_id, card_id, score):
        if not all(is_valid_uuid(val) for val in [draft_id, card_id]):
            logger.warning(f"Invalid UUID in recommendation: draft_id={draft_id}, card_id={card_id}")
            return
        try:
            with self.conn.cursor() as cur:
                cur.execute(
                    """
                    INSERT INTO recommendations (id, draft_id, card_id, score)
                    VALUES (gen_random_uuid(), %s, %s, %s)
                    ON CONFLICT DO NOTHING;
                    """,
                    (draft_id, card_id, score)
                )
                logger.info(f"Inserted recommendation: draft_id={draft_id}, card_id={card_id}, score={score}")
        except Exception as e:
            logger.error(f"Error inserting recommendation: {e}")
    
    def close(self):
        if self.conn:
            self.conn.close()
            logger.info("Closed PostgreSQL connection.")

# Log Event Handler
class LogHandler(FileSystemEventHandler):
    def __init__(self, db):
        super().__init__()
        self.db = db
        self._file = open(LOG_FILE_PATH, 'r', encoding='utf-8')
        self._file.seek(0, 2)  # Move to the end of the file
    
    def on_modified(self, event):
        if event.src_path != LOG_FILE_PATH:
            return
        for line in self._file:
            self.process_line(line.strip())
    
    def process_line(self, line):
        # Example log line:
        # [2024-04-27 12:00:00.000] [Player] [INFO] DraftPick: {"draftId":"123e4567-e89b-12d3-a456-426614174000","userId":"user-uuid-1","cardId":"card-uuid-1","timestamp":"2024-04-27T12:00:00Z"}
        
        # Check if the line contains 'DraftPick'
        if 'DraftPick' not in line:
            return
        
        try:
            # Extract JSON part using regex
            json_part = re.search(r'DraftPick:\s*(\{.*\})', line)
            if not json_part:
                logger.warning(f"No JSON data found in line: {line}")
                return
            data = json.loads(json_part.group(1))
            
            draft_id = data.get('draftId')
            user_id = data.get('userId')
            card_id = data.get('cardId')
            timestamp = data.get('timestamp')  # ISO format
            
            if not all([draft_id, user_id, card_id, timestamp]):
                logger.warning(f"Incomplete data in line: {line}")
                return
            
            # Insert draft if not exists
            self.db.insert_draft(draft_id)
            
            # Insert drafted card
            self.db.insert_drafted_card(draft_id, user_id, card_id, timestamp)
            
            # (Optional) Generate and insert recommendations
            # This depends on your recommendation engine implementation
            # For demonstration, let's assume a dummy score
            score = 90  # Replace with actual scoring logic
            self.db.insert_recommendation(draft_id, card_id, score)
            
            # (Optional) Trigger backend update via API or message queue
            # This depends on your architecture
        except json.JSONDecodeError as e:
            logger.error(f"JSON decode error for line: {line} | Error: {e}")
        except Exception as e:
            logger.error(f"Error processing line: {line} | Error: {e}")

# Main Function
def main():
    db = Database(DB_CONFIG)
    
    event_handler = LogHandler(db)
    observer = Observer()
    log_dir = re.sub(r'[^\\/]+$', '', LOG_FILE_PATH)  # Get directory from log file path
    observer.schedule(event_handler, path=log_dir, recursive=False)
    observer.start()
    logger.info("Started log observer.")
    
    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        observer.stop()
        logger.info("Stopping log observer.")
    except Exception as e:
        logger.error(f"Unexpected error: {e}")
        observer.stop()
    
    observer.join()
    db.close()

if __name__ == "__main__":
    main()

   # Enhanced LogHandler to handle log rotation

   class LogHandler(FileSystemEventHandler):
       def __init__(self, db):
           super().__init__()
           self.db = db
           self.file_handlers = {}
           self._initialize_existing_logs()
       
       def _initialize_existing_logs(self):
           # Initialize file handlers for existing Player.log files
           import glob
           log_files = glob.glob(LOG_FILE_PATH)  # Adjust pattern if needed
           for file_path in log_files:
               self.add_file(file_path)
       
       def add_file(self, file_path):
           if file_path in self.file_handlers:
               return
           try:
               file = open(file_path, 'r', encoding='utf-8')
               file.seek(0, 2)  # Move to end of file
               self.file_handlers[file_path] = file
               logger.info(f"Started monitoring {file_path}")
           except Exception as e:
               logger.error(f"Error opening file {file_path}: {e}")
       
       def remove_file(self, file_path):
           if file_path in self.file_handlers:
               self.file_handlers[file_path].close()
               del self.file_handlers[file_path]
               logger.info(f"Stopped monitoring {file_path}")
       
       def on_created(self, event):
           if 'Player.log' in event.src_path:
               self.add_file(event.src_path)
       
       def on_deleted(self, event):
           if 'Player.log' in event.src_path:
               self.remove_file(event.src_path)
       
       def on_modified(self, event):
           if event.src_path not in self.file_handlers:
               return
           file = self.file_handlers[event.src_path]
           for line in file:
               self.process_line(line.strip())
       
       def process_line(self, line):
           # Same as before
           pass
   

def main():
    db = Database(DB_CONFIG)
    
    event_handler = LogHandler(db)
    observer = Observer()
    log_dir = re.sub(r'[^\\/]+$', '', LOG_FILE_PATH)  # Get directory from log file path
    observer.schedule(event_handler, path=log_dir, recursive=False)
    observer.start()
    logger.info("Started log observer.")
    
    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        observer.stop()
        logger.info("Stopping log observer.")
    except Exception as e:
        logger.error(f"Unexpected error: {e}")
        observer.stop()
    
    observer.join()
    db.close()

def insert_drafted_card(self, draft_id, user_id, card_id, picked_at):
    if not all(is_valid_uuid(val) for val in [draft_id, user_id, card_id]):
        logger.warning(f"Invalid UUID in drafted_card: draft_id={draft_id}, user_id={user_id}, card_id={card_id}")
        return
    try:
        with self.conn.cursor() as cur:
            cur.execute(
                """
                INSERT INTO drafted_cards (id, draft_id, user_id, card_id, picked_at)
                VALUES (gen_random_uuid(), %s, %s, %s, %s)
                ON CONFLICT DO NOTHING;
                """,
                (draft_id, user_id, card_id, picked_at)
            )
            logger.info(f"Inserted drafted card: draft_id={draft_id}, user_id={user_id}, card_id={card_id}")
    except Exception as e:
        logger.error(f"Error inserting drafted card: {e}")

# After inserting a drafted card, trigger recommendation generation
def process_line(self, line):
    # Existing parsing logic...
    
    # After inserting drafted card
    # Trigger recommendation logic here
    generate_recommendations(draft_id)

def generate_recommendations(draft_id):
    # Fetch current draft state
    # Calculate synergy scores based on picks
    # Insert recommendations into the database
    pass

def insert_drafted_card(self, draft_id, user_id, card_id, picked_at):
    if not all(is_valid_uuid(val) for val in [draft_id, user_id, card_id]):
        logger.warning(f"Invalid UUID in drafted_card: draft_id={draft_id}, user_id={user_id}, card_id={card_id}")
        return
    try:
        with self.conn.cursor() as cur:
            cur.execute(
                """
                INSERT INTO drafted_cards (id, draft_id, user_id, card_id, picked_at)
                VALUES (gen_random_uuid(), %s, %s, %s, %s)
                ON CONFLICT DO NOTHING;
                """,
                (draft_id, user_id, card_id, picked_at)
            )
            logger.info(f"Inserted drafted card: draft_id={draft_id}, user_id={user_id}, card_id={card_id}")
            
            # Send NOTIFY
            payload = json.dumps({
                'draft_id': draft_id,
                'user_id': user_id,
                'card_id': card_id,
                'picked_at': picked_at
            })
            cur.execute("NOTIFY new_pick, %s;", (payload,))
    except Exception as e:
        logger.error(f"Error inserting drafted card: {e}")

   npm install pg
   

   // index.js (continued)

   const { Pool } = require('pg');
   const socketIo = require('socket.io');
   
   // PostgreSQL connection pool for LISTEN/NOTIFY
   const pool = new Pool({
     user: 'your_db_username',
     host: 'localhost',
     database: 'mtg_draft',
     password: 'your_db_password',
     port: 5432,
   });
   
   pool.connect((err, client, release) => {
     if (err) {
       return logger.error('Error acquiring client', err.stack);
     }
     client.on('notification', (msg) => {
       if (msg.channel === 'new_pick') {
         const payload = JSON.parse(msg.payload);
         const { draft_id, user_id, card_id, picked_at } = payload;
         
         // Emit Socket.IO event to clients in the draft room
         io.to(draft_${draft_id}).emit('newPick', {
           userId: user_id,
           cardId: card_id,
           pickedAt: picked_at,
         });
         
         logger.info(Emitted newPick for draft ${draft_id});
       }
     });
     client.query('LISTEN new_pick');
     logger.info('Listening for new_pick notifications.');
   });
   
   // ... existing Socket.IO setup ...
   

// client.js (Frontend)
import { io } from "socket.io-client";

const socket = io('https://your-backend-domain.com', {
  auth: {
    token: 'your_jwt_token_here'
  }
});

// Join a draft room after connecting
socket.on('connect', () => {
  console.log(Connected with ID: ${socket.id});
  const draftId = '123e4567-e89b-12d3-a456-426614174000'; // Example draft ID
  socket.emit('joinDraft', draftId);
});

// Handle newPick event
socket.on('newPick', (data) => {
  console.log('New pick made:', data);
  // Update the UI with the new pick
  // e.g., add the picked card to the user's drafted cards
});

// Handle errors
socket.on('error', (error) => {
  console.error('Socket.IO Error:', error.message);
});

# parser.py

import time
import json
import re
import psycopg2
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler
from config import LOG_FILE_PATH, DB_CONFIG
import logging
from uuid import UUID

# Setup logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s [%(levelname)s] %(message)s',
    handlers=[
        logging.FileHandler("parser.log"),
        logging.StreamHandler()
    ]
)
logger = logging.getLogger(__name__)

# Helper function to validate UUID
def is_valid_uuid(val):
    try:
        UUID(str(val))
        return True
    except ValueError:
        return False

# Database connection handler
class Database:
    def __init__(self, config):
        self.config = config
        self.conn = None
        self.connect()
    
    def connect(self):
        try:
            self.conn = psycopg2.connect(**self.config)
            self.conn.autocommit = True
            logger.info("Connected to PostgreSQL database.")
        except Exception as e:
            logger.error(f"Failed to connect to PostgreSQL: {e}")
            self.conn = None
    
    def reconnect(self):
        if self.conn:
            self.conn.close()
        self.connect()
    
    def insert_draft(self, draft_id):
        if not is_valid_uuid(draft_id):
            logger.warning(f"Attempted to insert invalid draft_id: {draft_id}")
            return
        try:
            with self.conn.cursor() as cur:
                cur.execute(
                    """
                    INSERT INTO drafts (id, status)
                    VALUES (%s, %s)
                    ON CONFLICT (id) DO NOTHING;
                    """,
                    (draft_id, 'ongoing')
                )
                logger.info(f"Inserted draft: {draft_id}")
        except Exception as e:
            logger.error(f"Error inserting draft {draft_id}: {e}")
    
    def insert_drafted_card(self, draft_id, user_id, card_id, picked_at):
        if not all(is_valid_uuid(val) for val in [draft_id, user_id, card_id]):
            logger.warning(f"Invalid UUID in drafted_card: draft_id={draft_id}, user_id={user_id}, card_id={card_id}")
            return
        try:
            with self.conn.cursor() as cur:
                cur.execute(
                    """
                    INSERT INTO drafted_cards (id, draft_id, user_id, card_id, picked_at)
                    VALUES (gen_random_uuid(), %s, %s, %s, %s)
                    ON CONFLICT DO NOTHING;
                    """,
                    (draft_id, user_id, card_id, picked_at)
                )
                logger.info(f"Inserted drafted card: draft_id={draft_id}, user_id={user_id}, card_id={card_id}")
                
                # Send NOTIFY
                payload = json.dumps({
                    'draft_id': draft_id,
                    'user_id': user_id,
                    'card_id': card_id,
                    'picked_at': picked_at
                })
                cur.execute("NOTIFY new_pick, %s;", (payload,))
        except Exception as e:
            logger.error(f"Error inserting drafted card: {e}")
    
    def insert_recommendation(self, draft_id, card_id, score):
        if not all(is_valid_uuid(val) for val in [draft_id, card_id]):
            logger.warning(f"Invalid UUID in recommendation: draft_id={draft_id}, card_id={card_id}")
            return
        try:
            with self.conn.cursor() as cur:
                cur.execute(
                    """
                    INSERT INTO recommendations (id, draft_id, card_id, score)
                    VALUES (gen_random_uuid(), %s, %s, %s)
                    ON CONFLICT DO NOTHING;
                    """,
                    (draft_id, card_id, score)
                )
                logger.info(f"Inserted recommendation: draft_id={draft_id}, card_id={card_id}, score={score}")
        except Exception as e:
            logger.error(f"Error inserting recommendation: {e}")
    
    def close(self):
        if self.conn:
            self.conn.close()
            logger.info("Closed PostgreSQL connection.")

# Log Event Handler
class LogHandler(FileSystemEventHandler):
    def __init__(self, db):
        super().__init__()
        self.db = db
        self.file_handlers = {}
        self._initialize_existing_logs()
    
    def _initialize_existing_logs(self):
        # Initialize file handlers for existing Player.log files
        import glob
        log_files = glob.glob(LOG_FILE_PATH)  # Adjust pattern if needed
        for file_path in log_files:
            self.add_file(file_path)
    
    def add_file(self, file_path):
        if file_path in self.file_handlers:
            return
        try:
            file = open(file_path, 'r', encoding='utf-8')
            file.seek(0, 2)  # Move to end of file
            self.file_handlers[file_path] = file
            logger.info(f"Started monitoring {file_path}")
        except Exception as e:
            logger.error(f"Error opening file {file_path}: {e}")
    
    def remove_file(self, file_path):
        if file_path in self.file_handlers:
            self.file_handlers[file_path].close()
            del self.file_handlers[file_path]
            logger.info(f"Stopped monitoring {file_path}")
    
    def on_created(self, event):
        if 'Player.log' in event.src_path:
            self.add_file(event.src_path)
    
    def on_deleted(self, event):
        if 'Player.log' in event.src_path:
            self.remove_file(event.src_path)
    
    def on_modified(self, event):
        if event.src_path not in self.file_handlers:
            return
        file = self.file_handlers[event.src_path]
        for line in file:
            self.process_line(line.strip())
    
    def process_line(self, line):
        # Example log line:
        # [2024-04-27 12:00:00.000] [Player] [INFO] DraftPick: {"draftId":"123e4567-e89b-12d3-a456-426614174000","userId":"user-uuid-1","cardId":"card-uuid-1","timestamp":"2024-04-27T12:00:00Z"}
        
        # Check if the line contains 'DraftPick'
        if 'DraftPick' not in line:
            return
        
        try:
            # Extract JSON part using regex
            json_part = re.search(r'DraftPick:\s*(\{.*\})', line)
            if not json_part:
                logger.warning(f"No JSON data found in line: {line}")
                return
            data = json.loads(json_part.group(1))
            
            draft_id = data.get('draftId')
            user_id = data.get('userId')
            card_id = data.get('cardId')
            timestamp = data.get('timestamp')  # ISO format
            
            if not all([draft_id, user_id, card_id, timestamp]):
                logger.warning(f"Incomplete data in line: {line}")
                return
            
            # Insert draft if not exists
            self.db.insert_draft(draft_id)
            
            # Insert drafted card
            self.db.insert_drafted_card(draft_id, user_id, card_id, timestamp)
            
            # (Optional) Generate and insert recommendations
            # This depends on your recommendation engine implementation
            # For demonstration, let's assume a dummy score
            score = 90  # Replace with actual scoring logic
            self.db.insert_recommendation(draft_id, card_id, score)
            
            # (Optional) Trigger backend update via API or message queue
            # Already handled via NOTIFY and backend listening
        except json.JSONDecodeError as e:
            logger.error(f"JSON decode error for line: {line} | Error: {e}")
        except Exception as e:
            logger.error(f"Error processing line: {line} | Error: {e}")

# Main Function
def main():
    db = Database(DB_CONFIG)
    
    event_handler = LogHandler(db)
    observer = Observer()
    log_dir = re.sub(r'[^\\/]+$', '', LOG_FILE_PATH)  # Get directory from log file path
    observer.schedule(event_handler, path=log_dir, recursive=False)
    observer.start()
    logger.info("Started log observer.")
    
    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        observer.stop()
        logger.info("Stopping log observer.")
    except Exception as e:
        logger.error(f"Unexpected error: {e}")
        observer.stop()
    
    observer.join()
    db.close()

if __name__ == "__main__":
    main()

   echo '[2024-04-27 12:00:00.000] [Player] [INFO] DraftPick: {"draftId":"123e4567-e89b-12d3-a456-426614174000","userId":"user-uuid-1","cardId":"card-uuid-1","timestamp":"2024-04-27T12:00:00Z"}' >> Player.log
   

   python parser.py
   

   SELECT * FROM drafts WHERE id = '123e4567-e89b-12d3-a456-426614174000';
   SELECT * FROM drafted_cards WHERE draft_id = '123e4567-e89b-12d3-a456-426614174000';
   

   node index.js
   

   echo '[2024-04-27 12:01:00.000] [Player] [INFO] DraftPick: {"draftId":"123e4567-e89b-12d3-a456-426614174000","userId":"user-uuid-2","cardId":"card-uuid-2","timestamp":"2024-04-27T12:01:00Z"}' >> Player.log
   

   npm install -g pm2
   

   pm2 start parser.py --name mtg-log-parser
   

   pm2 logs mtg-log-parser
   

   pm2 startup
   pm2 save
   

-- Enable the pgcrypto extension for UUID generation
CREATE EXTENSION IF NOT EXISTS "pgcrypto";

-- Create Users table
CREATE TABLE IF NOT EXISTS Users (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    username VARCHAR(50) NOT NULL,
    email VARCHAR(100) NOT NULL UNIQUE,
    password_hash VARCHAR(255) NOT NULL,
    created_at TIMESTAMP WITHOUT TIME ZONE NOT NULL DEFAULT (NOW() AT TIME ZONE 'utc'),
    updated_at TIMESTAMP WITHOUT TIME ZONE NOT NULL DEFAULT (NOW() AT TIME ZONE 'utc')
);

-- Indexes for faster searches on username
CREATE INDEX IF NOT EXISTS idx_users_username ON Users(username);

-- Create Drafts table
CREATE TABLE IF NOT EXISTS Drafts (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    user_id UUID NOT NULL,
    status VARCHAR(20) NOT NULL DEFAULT 'ongoing',
    started_at TIMESTAMP WITHOUT TIME ZONE NOT NULL DEFAULT (NOW() AT TIME ZONE 'utc'),
    completed_at TIMESTAMP WITHOUT TIME ZONE,
    metadata JSONB,
    created_at TIMESTAMP WITHOUT TIME ZONE NOT NULL DEFAULT (NOW() AT TIME ZONE 'utc'),
    updated_at TIMESTAMP WITHOUT TIME ZONE NOT NULL DEFAULT (NOW() AT TIME ZONE 'utc'),
    CONSTRAINT fk_drafts_user
        FOREIGN KEY(user_id) 
            REFERENCES Users(id)
            ON DELETE CASCADE
);

-- Indexes for faster querying by status and user_id
CREATE INDEX IF NOT EXISTS idx_drafts_status ON Drafts(status);
CREATE INDEX IF NOT EXISTS idx_drafts_user_id ON Drafts(user_id);

-- Create DraftedCards table
CREATE TABLE IF NOT EXISTS DraftedCards (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    draft_id UUID NOT NULL,
    card_id UUID NOT NULL,
    pick_number INTEGER NOT NULL,
    position VARCHAR(20),
    timestamp TIMESTAMP WITHOUT TIME ZONE NOT NULL DEFAULT (NOW() AT TIME ZONE 'utc'),
    created_at TIMESTAMP WITHOUT TIME ZONE NOT NULL DEFAULT (NOW() AT TIME ZONE 'utc'),
    updated_at TIMESTAMP WITHOUT TIME ZONE NOT NULL DEFAULT (NOW() AT TIME ZONE 'utc'),
    CONSTRAINT fk_draftedcards_draft
        FOREIGN KEY(draft_id)
            REFERENCES Drafts(id)
            ON DELETE CASCADE,
    CONSTRAINT fk_draftedcards_card
        FOREIGN KEY(card_id)
            REFERENCES Cards(id)
            ON DELETE CASCADE
);

-- Indexes for faster querying by draft_id and card_id
CREATE INDEX IF NOT EXISTS idx_draftedcards_draft_id ON DraftedCards(draft_id);
CREATE INDEX IF NOT EXISTS idx_draftedcards_card_id ON DraftedCards(card_id);

-- Create DeckCompositions table
CREATE TABLE IF NOT EXISTS DeckCompositions (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    draft_id UUID NOT NULL,
    archetype VARCHAR(100),
    synergy_score INTEGER,
    mana_curve JSONB,
    created_at TIMESTAMP WITHOUT TIME ZONE NOT NULL DEFAULT (NOW() AT TIME ZONE 'utc'),
    updated_at TIMESTAMP WITHOUT TIME ZONE NOT NULL DEFAULT (NOW() AT TIME ZONE 'utc'),
    CONSTRAINT fk_deckcompositions_draft
        FOREIGN KEY(draft_id)
            REFERENCES Drafts(id)
            ON DELETE CASCADE
);

-- Indexes for faster querying by draft_id and archetype
CREATE INDEX IF NOT EXISTS idx_deckcompositions_draft_id ON DeckCompositions(draft_id);
CREATE INDEX IF NOT EXISTS idx_deckcompositions_archetype ON DeckCompositions(archetype);

-- Create SynergyScores table
CREATE TABLE IF NOT EXISTS SynergyScores (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    deck_composition_id UUID NOT NULL,
    card_id UUID NOT NULL,
    synergy_score INTEGER NOT NULL,
    updated_at TIMESTAMP WITHOUT TIME ZONE NOT NULL DEFAULT (NOW() AT TIME ZONE 'utc'),
    CONSTRAINT fk_synergyscores_deckcomposition
        FOREIGN KEY(deck_composition_id)
            REFERENCES DeckCompositions(id)
            ON DELETE CASCADE,
    CONSTRAINT fk_synergyscores_card
        FOREIGN KEY(card_id)
            REFERENCES Cards(id)
            ON DELETE CASCADE
);

-- Indexes for faster querying by deck_composition_id and card_id
CREATE INDEX IF NOT EXISTS idx_synergyscores_deckcomposition_id ON SynergyScores(deck_composition_id);
CREATE INDEX IF NOT EXISTS idx_synergyscores_card_id ON SynergyScores(card_id);

-- Enable the pgcrypto extension for UUID generation
CREATE EXTENSION IF NOT EXISTS "pgcrypto";

-- 1. Users Table
CREATE TABLE IF NOT EXISTS Users (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    username VARCHAR(50) NOT NULL,
    email VARCHAR(100) NOT NULL UNIQUE,
    password_hash VARCHAR(255) NOT NULL,
    created_at TIMESTAMP WITHOUT TIME ZONE NOT NULL DEFAULT (NOW() AT TIME ZONE 'utc'),
    updated_at TIMESTAMP WITHOUT TIME ZONE NOT NULL DEFAULT (NOW() AT TIME ZONE 'utc')
);

CREATE INDEX IF NOT EXISTS idx_users_username ON Users(username);

-- 2. Drafts Table
CREATE TABLE IF NOT EXISTS Drafts (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    user_id UUID NOT NULL,
    status VARCHAR(20) NOT NULL DEFAULT 'ongoing',
    started_at TIMESTAMP WITHOUT TIME ZONE NOT NULL DEFAULT (NOW() AT TIME ZONE 'utc'),
    completed_at TIMESTAMP WITHOUT TIME ZONE,
    metadata JSONB,
    created_at TIMESTAMP WITHOUT TIME ZONE NOT NULL DEFAULT (NOW() AT TIME ZONE 'utc'),
    updated_at TIMESTAMP WITHOUT TIME ZONE NOT NULL DEFAULT (NOW() AT TIME ZONE 'utc'),
    CONSTRAINT fk_drafts_user
        FOREIGN KEY(user_id) 
            REFERENCES Users(id)
            ON DELETE CASCADE
);

CREATE INDEX IF NOT EXISTS idx_drafts_status ON Drafts(status);
CREATE INDEX IF NOT EXISTS idx_drafts_user_id ON Drafts(user_id);

-- 3. DraftedCards Table
CREATE TABLE IF NOT EXISTS DraftedCards (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    draft_id UUID NOT NULL,
    card_id UUID NOT NULL,
    pick_number INTEGER NOT NULL,
    position VARCHAR(20),
    timestamp TIMESTAMP WITHOUT TIME ZONE NOT NULL DEFAULT (NOW() AT TIME ZONE 'utc'),
    created_at TIMESTAMP WITHOUT TIME ZONE NOT NULL DEFAULT (NOW() AT TIME ZONE 'utc'),
    updated_at TIMESTAMP WITHOUT TIME ZONE NOT NULL DEFAULT (NOW() AT TIME ZONE 'utc'),
    CONSTRAINT fk_draftedcards_draft
        FOREIGN KEY(draft_id)
            REFERENCES Drafts(id)
            ON DELETE CASCADE,
    CONSTRAINT fk_draftedcards_card
        FOREIGN KEY(card_id)
            REFERENCES Cards(id)
            ON DELETE CASCADE
);

CREATE INDEX IF NOT EXISTS idx_draftedcards_draft_id ON DraftedCards(draft_id);
CREATE INDEX IF NOT EXISTS idx_draftedcards_card_id ON DraftedCards(card_id);

-- 4. DeckCompositions Table
CREATE TABLE IF NOT EXISTS DeckCompositions (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    draft_id UUID NOT NULL,
    archetype VARCHAR(100),
    synergy_score INTEGER,
    mana_curve JSONB,
    created_at TIMESTAMP WITHOUT TIME ZONE NOT NULL DEFAULT (NOW() AT TIME ZONE 'utc'),
    updated_at TIMESTAMP WITHOUT TIME ZONE NOT NULL DEFAULT (NOW() AT TIME ZONE 'utc'),
    CONSTRAINT fk_deckcompositions_draft
        FOREIGN KEY(draft_id)
            REFERENCES Drafts(id)
            ON DELETE CASCADE
);

CREATE INDEX IF NOT EXISTS idx_deckcompositions_draft_id ON DeckCompositions(draft_id);
CREATE INDEX IF NOT EXISTS idx_deckcompositions_archetype ON DeckCompositions(archetype);

-- 5. SynergyScores Table
CREATE TABLE IF NOT EXISTS SynergyScores (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    deck_composition_id UUID NOT NULL,
    card_id UUID NOT NULL,
    synergy_score INTEGER NOT NULL,
    updated_at TIMESTAMP WITHOUT TIME ZONE NOT NULL DEFAULT (NOW() AT TIME ZONE 'utc'),
    CONSTRAINT fk_synergyscores_deckcomposition
        FOREIGN KEY(deck_composition_id)
            REFERENCES DeckCompositions(id)
            ON DELETE CASCADE,
    CONSTRAINT fk_synergyscores_card
        FOREIGN KEY(card_id)
            REFERENCES Cards(id)
            ON DELETE CASCADE
);

CREATE INDEX IF NOT EXISTS idx_synergyscores_deckcomposition_id ON SynergyScores(deck_composition_id);
CREATE INDEX IF NOT EXISTS idx_synergyscores_card_id ON SynergyScores(card_id);

-- Example of setting default to UTC timestamp
created_at TIMESTAMP WITHOUT TIME ZONE NOT NULL DEFAULT (NOW() AT TIME ZONE 'utc')

  # On Linux
  sudo systemctl start mongod

  # On macOS (using Homebrew)
  brew services start mongodb-community@6.0

  # On Windows
  # Start MongoDB as a service or run the mongod executable
  

   mongo
   

   use mtg_draft_app
   

   db.createCollection("cards")
   db.createCollection("archetypes")
   db.createCollection("mechanics")
   

   // Index on color
   db.cards.createIndex({ color: 1 })

   // Index on type
   db.cards.createIndex({ type: 1 })

   // Index on mechanics
   db.cards.createIndex({ mechanics: 1 })

   // Text index on name for text search
   db.cards.createIndex({ name: "text" })
   

   // Index on name
   db.archetypes.createIndex({ name: 1 })

   // Index on cards.card_id
   db.archetypes.createIndex({ "cards.card_id": 1 })
   

   // Index on name
   db.mechanics.createIndex({ name: 1 })
   

{
  "_id": ObjectId,           // Automatically generated by MongoDB
  "id": "unique-card-uuid",  // UUID string from Scryfall
  "name": "Card Name",
  "image_url": "https://...", // URL to the card image
  "mana_cost": "{2}{G}{G}",
  "type": "Creature — Elf Druid",
  "mechanics": ["Trample", "Reach"],
  "color": ["Green"],
  "rarity": "Rare",
  "set": "M19",
  "oracle_text": "Some card text.",
  "power": "2",
  "toughness": "3",
  "artist": "Artist Name",
  "collector_number": "175",
  "flavor_text": "Some flavor text.",
  "legalities": {
    "standard": "legal",
    "modern": "legal",
    "commander": "legal",
    // ... other formats
  },
  "released_at": "2019-07-12",
  "prices": {
    "usd": "3.50",
    "usd_foil": "15.00",
    // ... other price points
  },
  "related_uris": {
    "gatherer": "https://gatherer.wizards.com/...",
    "tcgplayer_decks": "https://decks.tcgplayer.com/...",
    // ... other URIs
  },
  "created_at": ISODate("2024-04-27T12:00:00Z"),
  "updated_at": ISODate("2024-04-27T12:00:00Z")
}

db.cards.insertOne({
  "id": "123e4567-e89b-12d3-a456-426614174000",
  "name": "Black Lotus",
  "image_url": "https://c1.scryfall.com/file/scryfall-cards/normal/front/5/3/534ed3e0-f8b6-4bf4-86f6-38fa6059e8de.jpg?1687522176",
  "mana_cost": "{0}",
  "type": "Artifact",
  "mechanics": [],
  "color": [],
  "rarity": "Rare",
  "set": "LEA",
  "oracle_text": "{T}, Sacrifice Black Lotus: Add three mana of any one color.",
  "power": null,
  "toughness": null,
  "artist": "Christopher Rush",
  "collector_number": "233",
  "flavor_text": "Its power is unrivaled by any other artifact.",
  "legalities": {
    "standard": "not_legal",
    "modern": "not_legal",
    "commander": "banned",
    // ... other formats
  },
  "released_at": "1993-10-04",
  "prices": {
    "usd": "20000.00",
    "usd_foil": "30000.00",
    // ... other price points
  },
  "related_uris": {
    "gatherer": "https://gatherer.wizards.com/Pages/Card/Details.aspx?multiverseid=370306",
    "tcgplayer_decks": "https://decks.tcgplayer.com/magic/deck/search?contains=Black+Lotus",
    // ... other URIs
  },
  "created_at": new Date(),
  "updated_at": new Date()
});

  db.cards.find({ color: "Green" })
  

  db.cards.find({ type: "Creature — Elf Druid" })
  

  db.cards.find({ mechanics: "Trample" })
  

  db.cards.find({ color: "Blue", type: "Instant", mechanics: "Counterspell" })
  

     db.cards.createIndex({ color: 1 })
     

     db.cards.createIndex({ type: 1 })
     

     db.cards.createIndex({ mechanics: 1 })
     

     db.cards.createIndex({ name: "text" })
     

     db.cards.createIndex({ color: 1, type: 1 })
     

     db.cards.createIndex({ color: 1, type: 1, mechanics: 1 })
     

     db.cards.createIndex({ rarity: 1 })
     

     db.cards.createIndex({ set: 1 })
     

   db.cards.createIndex({ "$**": "text" })
   

  db.cards.getIndexes()
  

  db.cards.find({ color: "Green", type: "Creature — Elf Druid" }).explain("executionStats")
  

   pip install pymongo requests
   

# ingest_scryfall.py

import requests
import pymongo
from pymongo import UpdateOne
from pymongo.errors import BulkWriteError
import logging
import time

# Configure Logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s [%(levelname)s] %(message)s',
    handlers=[
        logging.FileHandler("ingest_scryfall.log"),
        logging.StreamHandler()
    ]
)
logger = logging.getLogger(__name__)

# MongoDB Configuration
MONGO_URI = "mongodb://localhost:27017/"
DB_NAME = "mtg_draft_app"
CARDS_COLLECTION = "cards"

# Scryfall API Endpoint
SCRYFALL_API = "https://api.scryfall.com/cards"

def get_all_cards():
    """
    Generator function to fetch all cards from Scryfall API with pagination.
    """
    url = SCRYFALL_API
    while url:
        logger.info(f"Fetching data from: {url}")
        response = requests.get(url)
        if response.status_code != 200:
            logger.error(f"Failed to fetch data: {response.status_code}")
            break
        data = response.json()
        for card in data.get("data", []):
            yield card
        url = data.get("next_page")

def transform_card_data(card):
    """
    Transforms Scryfall card data into the desired MongoDB document structure.
    """
    transformed = {
        "id": card.get("id"),
        "name": card.get("name"),
        "image_url": card.get("image_uris", {}).get("normal") if "image_uris" in card else None,
        "mana_cost": card.get("mana_cost"),
        "type": card.get("type_line"),
        "mechanics": card.get("keywords", []),
        "color": card.get("colors", []),
        "rarity": card.get("rarity"),
        "set": card.get("set"),
        "oracle_text": card.get("oracle_text"),
        "power": card.get("power"),
        "toughness": card.get("toughness"),
        "artist": card.get("artist"),
        "collector_number": card.get("collector_number"),
        "flavor_text": card.get("flavor_text"),
        "legalities": card.get("legalities", {}),
        "released_at": card.get("released_at"),
        "prices": card.get("prices", {}),
        "related_uris": card.get("related_uris", {}),
        "created_at": card.get("created_at"),
        "updated_at": card.get("updated_at")
    }
    return transformed

def main():
    # Connect to MongoDB
    client = pymongo.MongoClient(MONGO_URI)
    db = client[DB_NAME]
    cards_col = db[CARDS_COLLECTION]
    
    # Fetch and Insert Cards
    batch_size = 100
    batch = []
    total_inserted = 0
    total_cards = 0

    for card in get_all_cards():
        total_cards += 1
        transformed_card = transform_card_data(card)
        # Upsert operation to avoid duplicates based on 'id'
        batch.append(
            UpdateOne(
                {"id": transformed_card["id"]},
                {"$set": transformed_card},
                upsert=True
            )
        )
        
        if len(batch) == batch_size:
            try:
                result = cards_col.bulk_write(batch, ordered=False)
                total_inserted += result.upserted_count
                logger.info(f"Inserted/Updated {result.upserted_count} cards.")
            except BulkWriteError as bwe:
                logger.error(f"Bulk write error: {bwe.details}")
            batch = []
    
    # Insert remaining cards in the batch
    if batch:
        try:
            result = cards_col.bulk_write(batch, ordered=False)
            total_inserted += result.upserted_count
            logger.info(f"Inserted/Updated {result.upserted_count} cards.")
        except BulkWriteError as bwe:
            logger.error(f"Bulk write error: {bwe.details}")
    
    logger.info(f"Total cards processed: {total_cards}")
    logger.info(f"Total cards inserted/updated: {total_inserted}")

if __name__ == "__main__":
    start_time = time.time()
    main()
    end_time = time.time()
    logger.info(f"Data ingestion completed in {end_time - start_time:.2f} seconds.")

   sudo systemctl status mongod
   

   python ingest_scryfall.py
   

   tail -f ingest_scryfall.log
   

  crontab -e
  

  0 0 * * * /usr/bin/python3 /path/to/ingest_scryfall.py >> /path/to/ingest_scryfall_cron.log 2>&1
  

// Example Aggregation Pipeline in MongoDB Shell

db.cards.aggregate([
  // Stage 1: Unwind mechanics array if needed
  { $unwind: "$mechanics" },
  
  // Stage 2: Group by archetype
  {
    $group: {
      _id: "$archetype", // Replace with actual archetype field
      total_cards: { $sum: 1 },
      average_synergy_score: { $avg: "$synergy_score" }, // Assuming synergy_score exists
      mechanics: { $addToSet: "$mechanics" },
      colors: { $addToSet: "$color" }
    }
  },
  
  // Stage 3: Project desired fields
  {
    $project: {
      _id: 0,
      archetype: "$_id",
      total_cards: 1,
      average_synergy_score: 1,
      mechanics: 1,
      colors: 1
    }
  },
  
  // Stage 4: Sort by average_synergy_score descending
  { $sort: { average_synergy_score: -1 } }
])

# aggregation_pipelines.py

import pymongo
from pymongo import MongoClient
import logging

# Configure Logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s [%(levelname)s] %(message)s',
    handlers=[
        logging.FileHandler("aggregation_pipelines.log"),
        logging.StreamHandler()
    ]
)
logger = logging.getLogger(__name__)

# MongoDB Configuration
MONGO_URI = "mongodb://localhost:27017/"
DB_NAME = "mtg_draft_app"
CARDS_COLLECTION = "cards"

def aggregate_archetypes():
    client = MongoClient(MONGO_URI)
    db = client[DB_NAME]
    cards_col = db[CARDS_COLLECTION]
    
    pipeline = [
        # Stage 1: Optional filtering based on criteria
        # { "$match": { "rarity": { "$in": ["rare", "mythic"] } } },
        
        # Stage 2: Group by archetype
        {
            "$group": {
                "_id": "$archetype",  # Replace with actual field if different
                "total_cards": { "$sum": 1 },
                "average_synergy_score": { "$avg": "$synergy_score" },  # Assuming synergy_score exists
                "mechanics": { "$addToSet": "$mechanics" },
                "colors": { "$addToSet": "$color" }
            }
        },
        
        # Stage 3: Project desired fields
        {
            "$project": {
                "_id": 0,
                "archetype": "$_id",
                "total_cards": 1,
                "average_synergy_score": 1,
                "mechanics": 1,
                "colors": 1
            }
        },
        
        # Stage 4: Sort by average_synergy_score descending
        { "$sort": { "average_synergy_score": -1 } }
    ]
    
    try:
        results = list(cards_col.aggregate(pipeline))
        logger.info("Archetype Aggregation Results:")
        for result in results:
            logger.info(result)
    except Exception as e:
        logger.error(f"Aggregation pipeline failed: {e}")
    finally:
        client.close()

if __name__ == "__main__":
    aggregate_archetypes()

   sudo systemctl status mongod
   

   python aggregation_pipelines.py
   

   tail -f aggregation_pipelines.log
   

     db.createCollection("cards", {
       validator: {
         $jsonSchema: {
           bsonType: "object",
           required: ["id", "name", "type", "color", "rarity"],
           properties: {
             id: {
               bsonType: "string",
               description: "must be a string and is required"
             },
             name: {
               bsonType: "string",
               description: "must be a string and is required"
             },
             type: {
               bsonType: "string",
               description: "must be a string and is required"
             },
             color: {
               bsonType: "array",
               description: "must be an array of colors and is required"
             },
             rarity: {
               bsonType: "string",
               description: "must be a string and is required"
             }
           }
         }
       },
       validationAction: "warn" // or "error" to enforce validation
     })
     

     // Enable authentication in MongoDB configuration (mongod.conf)
     security:
       authorization: "enabled"
     

     use admin
     db.createUser({
       user: "adminUser",
       pwd: "securePassword",
       roles: [ { role: "userAdminAnyDatabase", db: "admin" } ]
     })

     use mtg_draft_app
     db.createUser({
       user: "appUser",
       pwd: "appPassword",
       roles: [ { role: "readWrite", db: "mtg_draft_app" } ]
     })
     

     # Backup
     mongodump --db mtg_draft_app --out /path/to/backup/
     
     # Restore
     mongorestore --db mtg_draft_app /path/to/backup/mtg_draft_app
     

# ingest_scryfall_enhanced.py

import requests
import pymongo
from pymongo import UpdateOne
from pymongo.errors import BulkWriteError
import logging
import time
from datetime import datetime

# Configure Logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s [%(levelname)s] %(message)s',
    handlers=[
        logging.FileHandler("ingest_scryfall_enhanced.log"),
        logging.StreamHandler()
    ]
)
logger = logging.getLogger(__name__)

# MongoDB Configuration
MONGO_URI = "mongodb://appUser:appPassword@localhost:27017/"
DB_NAME = "mtg_draft_app"
CARDS_COLLECTION = "cards"

# Scryfall API Endpoint
SCRYFALL_API = "https://api.scryfall.com/cards"

def get_all_cards():
    """
    Generator function to fetch all cards from Scryfall API with pagination.
    """
    url = SCRYFALL_API
    while url:
        logger.info(f"Fetching data from: {url}")
        response = requests.get(url)
        if response.status_code != 200:
            logger.error(f"Failed to fetch data: {response.status_code} - {response.text}")
            break
        data = response.json()
        for card in data.get("data", []):
            yield card
        url = data.get("next_page")
        time.sleep(0.1)  # Respect API rate limits

def transform_card_data(card):
    """
    Transforms Scryfall card data into the desired MongoDB document structure.
    """
    transformed = {
        "id": card.get("id"),
        "name": card.get("name"),
        "image_url": card.get("image_uris", {}).get("normal") if "image_uris" in card else None,
        "mana_cost": card.get("mana_cost"),
        "type": card.get("type_line"),
        "mechanics": card.get("keywords", []),
        "color": card.get("colors", []),
        "rarity": card.get("rarity"),
        "set": card.get("set"),
        "oracle_text": card.get("oracle_text"),
        "power": card.get("power"),
        "toughness": card.get("toughness"),
        "artist": card.get("artist"),
        "collector_number": card.get("collector_number"),
        "flavor_text": card.get("flavor_text"),
        "legalities": card.get("legalities", {}),
        "released_at": card.get("released_at"),
        "prices": card.get("prices", {}),
        "related_uris": card.get("related_uris", {}),
        "created_at": datetime.utcnow(),
        "updated_at": datetime.utcnow(),
        "archetype": determine_archetype(card),  # Function to assign archetype
        "synergy_score": calculate_synergy_score(card)  # Function to calculate synergy
    }
    return transformed

def determine_archetype(card):
    """
    Determines the archetype of a card based on its attributes.
    Placeholder function: Implement your logic here.
    """
    # Example logic based on card type and mechanics
    if "Trample" in card.get("keywords", []) and "Creature" in card.get("type_line", ""):
        return "Aggro"
    elif "Flying" in card.get("keywords", []) and "Creature" in card.get("type_line", ""):
        return "Flyer"
    else:
        return "Midrange"

def calculate_synergy_score(card):
    """
    Calculates a synergy score for a card.
    Placeholder function: Implement your logic here.
    """
    score = 50  # Base score
    if "Trample" in card.get("keywords", []):
        score += 10
    if "Flying" in card.get("keywords", []):
        score += 10
    if "Reach" in card.get("keywords", []):
        score += 5
    # Add more rules as needed
    return score

def main():
    # Connect to MongoDB
    client = pymongo.MongoClient(MONGO_URI)
    db = client[DB_NAME]
    cards_col = db[CARDS_COLLECTION]
    
    # Ensure Indexes are in place
    cards_col.create_index([("color", pymongo.ASCENDING)])
    cards_col.create_index([("type", pymongo.ASCENDING)])
    cards_col.create_index([("mechanics", pymongo.ASCENDING)])
    cards_col.create_index([("name", "text")])
    cards_col.create_index([("archetype", pymongo.ASCENDING)])
    
    # Fetch and Insert Cards
    batch_size = 100
    batch = []
    total_inserted = 0
    total_cards = 0

    for card in get_all_cards():
        total_cards += 1
        transformed_card = transform_card_data(card)
        # Upsert operation to avoid duplicates based on 'id'
        batch.append(
            UpdateOne(
                {"id": transformed_card["id"]},
                {"$set": transformed_card},
                upsert=True
            )
        )
        
        if len(batch) == batch_size:
            try:
                result = cards_col.bulk_write(batch, ordered=False)
                total_inserted += result.upserted_count
                logger.info(f"Inserted/Updated {result.upserted_count} cards.")
            except BulkWriteError as bwe:
                logger.error(f"Bulk write error: {bwe.details}")
            batch = []
    
    # Insert remaining cards in the batch
    if batch:
        try:
            result = cards_col.bulk_write(batch, ordered=False)
            total_inserted += result.upserted_count
            logger.info(f"Inserted/Updated {result.upserted_count} cards.")
        except BulkWriteError as bwe:
            logger.error(f"Bulk write error: {bwe.details}")
    
    logger.info(f"Total cards processed: {total_cards}")
    logger.info(f"Total cards inserted/updated: {total_inserted}")
    client.close()

if __name__ == "__main__":
    start_time = time.time()
    main()
    end_time = time.time()
    logger.info(f"Data ingestion completed in {end_time - start_time:.2f} seconds.")

   python ingest_scryfall_enhanced.py
   

   tail -f ingest_scryfall_enhanced.log
   

   mongo
   use mtg_draft_app
   db.cards.findOne({ name: "Black Lotus" }, { name: 1, archetype: 1, synergy_score: 1 })
   

brew update
brew install redis

sudo apt update
sudo apt install redis-server

docker pull redis
docker run --name redis-cache -p 6379:6379 -d redis

   maxmemory 256mb
   maxmemory-policy allkeys-lru
   

   save 900 1
   save 300 10
   save 60 10000
   
   appendonly yes
   appendfilename "appendonly.aof"
   appendfsync everysec
   

   save ""
   appendonly no
   

     bind 127.0.0.1
     

     requirepass your_secure_password
     

   tcp-backlog 511
   timeout 300
   

    brew services start redis
    

    sudo systemctl start redis-server
    

    brew services start redis
    

    sudo systemctl enable redis-server
    

  redis-cli ping
  # Expected response: PONG
  

npm install redis

// redisClient.js

const redis = require('redis');
const { promisify } = require('util');
const logger = require('./logger'); // Assuming you have a logger module

// Configure Redis connection
const REDIS_PORT = process.env.REDIS_PORT || 6379;
const REDIS_HOST = process.env.REDIS_HOST || '127.0.0.1';
const REDIS_PASSWORD = process.env.REDIS_PASSWORD || ''; // If set

// Create Redis client
const client = redis.createClient({
  host: REDIS_HOST,
  port: REDIS_PORT,
  password: REDIS_PASSWORD || undefined,
});

// Promisify Redis commands for async/await usage
const getAsync = promisify(client.get).bind(client);
const setAsync = promisify(client.set).bind(client);
const delAsync = promisify(client.del).bind(client);

// Handle Redis connection events
client.on('connect', () => {
  logger.info('Connected to Redis server.');
});

client.on('error', (err) => {
  logger.error('Redis error:', err);
});

// Export Redis operations
module.exports = {
  get: getAsync,
  set: setAsync,
  del: delAsync,
  client, // Exporting client in case you need advanced operations
};

// cache.js

const redisClient = require('./redisClient');
const logger = require('./logger'); // Assuming you have a logger module

/**
 * Sets a value in Redis with an optional TTL (in seconds).
 * @param {string} key - The Redis key.
 * @param {any} value - The value to store (will be stringified).
 * @param {number} ttl - Time-to-live in seconds.
 */
async function setCache(key, value, ttl = 3600) { // Default TTL: 1 hour
  try {
    const stringValue = JSON.stringify(value);
    await redisClient.set(key, stringValue, 'EX', ttl);
    logger.info(Cache set for key: ${key});
  } catch (error) {
    logger.error(Error setting cache for key ${key}:, error);
  }
}

/**
 * Retrieves a value from Redis.
 * @param {string} key - The Redis key.
 * @returns {any} - The parsed value or null if not found.
 */
async function getCache(key) {
  try {
    const data = await redisClient.get(key);
    if (data) {
      logger.info(Cache hit for key: ${key});
      return JSON.parse(data);
    }
    logger.info(Cache miss for key: ${key});
    return null;
  } catch (error) {
    logger.error(Error getting cache for key ${key}:, error);
    return null;
  }
}

/**
 * Deletes a value from Redis.
 * @param {string} key - The Redis key.
 */
async function deleteCache(key) {
  try {
    await redisClient.del(key);
    logger.info(Cache deleted for key: ${key});
  } catch (error) {
    logger.error(Error deleting cache for key ${key}:, error);
  }
}

module.exports = {
  setCache,
  getCache,
  deleteCache,
};

// routes/cards.js

const express = require('express');
const router = express.Router();
const axios = require('axios');
const cache = require('../cache'); // Import the cache utility
const logger = require('../logger'); // Assuming you have a logger module

const SCRYFALL_API_BASE = 'https://api.scryfall.com/cards';

// GET /api/cards/:id
router.get('/:id', async (req, res) => {
  const cardId = req.params.id;
  const cacheKey = card:${cardId};

  try {
    // Check if card data is in cache
    const cachedCard = await cache.getCache(cacheKey);
    if (cachedCard) {
      return res.json({ source: 'cache', data: cachedCard });
    }

    // If not in cache, fetch from Scryfall API
    const response = await axios.get(${SCRYFALL_API_BASE}/${cardId});
    const cardData = response.data;

    // Store fetched data in cache with TTL of 24 hours
    await cache.setCache(cacheKey, cardData, 86400); // 86400 seconds = 24 hours

    res.json({ source: 'api', data: cardData });
  } catch (error) {
    logger.error(Error fetching card ${cardId}:, error.message);
    res.status(500).json({ message: 'Internal Server Error' });
  }
});

module.exports = router;

    await cache.setCache(cacheKey, cardData, 86400); // TTL: 24 hours
    

    await cache.deleteCache(cacheKey);
    

    const updatedData = await fetchUpdatedData(cardId);
    await cache.setCache(cacheKey, updatedData, 86400);
    

  // routes/cards.js

  // PUT /api/cards/:id
  router.put('/:id', async (req, res) => {
    const cardId = req.params.id;
    const updatedFields = req.body;

    try {
      // Update card in MongoDB or PostgreSQL
      const updatedCard = await updateCardInDatabase(cardId, updatedFields);

      if (!updatedCard) {
        return res.status(404).json({ message: 'Card not found.' });
      }

      const cacheKey = card:${cardId};
      
      // Invalidate the cache for this card
      await cache.deleteCache(cacheKey);

      res.json({ message: 'Card updated successfully.', data: updatedCard });
    } catch (error) {
      logger.error(Error updating card ${cardId}:, error.message);
      res.status(500).json({ message: 'Internal Server Error' });
    }
  });
  

    const CACHE_VERSION = 'v1';
    const cacheKey = v1:card:${cardId};
    

    const CACHE_VERSION = 'v2';
    

  card:{cardId}
  

  card:123e4567-e89b-12d3-a456-426614174000
  

// routes/cards.js

const express = require('express');
const router = express.Router();
const axios = require('axios');
const cache = require('../cache'); // Import the cache utility
const logger = require('../logger'); // Assuming you have a logger module

const SCRYFALL_API_BASE = 'https://api.scryfall.com/cards';

/**
 * Utility function to fetch card data from Scryfall API
 * @param {string} cardId - The unique ID of the card
 * @returns {object} - The card data
 */
async function fetchCardFromAPI(cardId) {
  try {
    const response = await axios.get(${SCRYFALL_API_BASE}/${cardId});
    return response.data;
  } catch (error) {
    logger.error(Error fetching card ${cardId} from Scryfall:, error.message);
    throw error;
  }
}

// GET /api/cards/:id
router.get('/:id', async (req, res) => {
  const cardId = req.params.id;
  const cacheKey = card:${cardId};

  try {
    // Attempt to retrieve card data from cache
    const cachedCard = await cache.getCache(cacheKey);
    if (cachedCard) {
      return res.json({ source: 'cache', data: cachedCard });
    }

    // If cache miss, fetch from Scryfall API
    const cardData = await fetchCardFromAPI(cardId);

    // Store the fetched data in cache with TTL of 24 hours
    await cache.setCache(cacheKey, cardData, 86400); // 86400 seconds = 24 hours

    res.json({ source: 'api', data: cardData });
  } catch (error) {
    res.status(500).json({ message: 'Internal Server Error' });
  }
});

module.exports = router;

// routes/cards.js

// GET /api/cards/batch
router.post('/batch', async (req, res) => {
  const { cardIds } = req.body; // Expecting an array of card IDs
  if (!Array.isArray(cardIds) || cardIds.length === 0) {
    return res.status(400).json({ message: 'cardIds must be a non-empty array.' });
  }

  const cacheKeys = cardIds.map(id => card:${id});

  try {
    // Retrieve multiple keys from cache
    const cachedCards = await Promise.all(cacheKeys.map(key => cache.getCache(key)));

    const responseData = {};
    const cardsToFetch = [];

    cardIds.forEach((id, index) => {
      if (cachedCards[index]) {
        responseData[id] = { source: 'cache', data: cachedCards[index] };
      } else {
        cardsToFetch.push(id);
      }
    });

    // Fetch missing cards from API
    const fetchPromises = cardsToFetch.map(id => fetchCardFromAPI(id));
    const fetchedCards = await Promise.all(fetchPromises);

    // Prepare bulk cache set operations
    const setPromises = fetchedCards.map(card => {
      const key = card:${card.id};
      responseData[card.id] = { source: 'api', data: card };
      return cache.setCache(key, card, 86400); // TTL: 24 hours
    });

    await Promise.all(setPromises);

    res.json({ data: responseData });
  } catch (error) {
    logger.error('Error in batch fetching cards:', error.message);
    res.status(500).json({ message: 'Internal Server Error' });
  }
});

redis-cli INFO

  redis-cli INFO memory
  

  redis-cli INFO stats
  

  redis-cli INFO keyspace
  

redis-cli INFO stats | grep hits
redis-cli INFO stats | grep misses

hit_rate = (hits / (hits + misses)) * 100

hit_rate = (5000 / (5000 + 1000)) * 100 = 83.33%

redis-cli MONITOR

   docker run -d --name redis_exporter -p 9121:9121 oliver006/redis_exporter
   

   scrape_configs:
     - job_name: 'redis'
       static_configs:
         - targets: ['localhost:9121']
   

   card:{cardId}
   user:{userId}:profile
   recommendations:{userId}
   

   // rateLimiter.js

   const redisClient = require('./redisClient');
   const { promisify } = require('util');

   const zaddAsync = promisify(redisClient.client.zadd).bind(redisClient.client);
   const zremrangebyscoreAsync = promisify(redisClient.client.zremrangebyscore).bind(redisClient.client);
   const zcardAsync = promisify(redisClient.client.zcard).bind(redisClient.client);

   /**
    * Checks if a user has exceeded the rate limit.
    * @param {string} userId - The unique ID of the user.
    * @param {number} maxRequests - Maximum allowed requests.
    * @param {number} windowSeconds - Time window in seconds.
    * @returns {boolean} - True if rate limited, else false.
    */
   async function isRateLimited(userId, maxRequests, windowSeconds) {
     const key = rate_limit:${userId};
     const currentTimestamp = Date.now();
     const windowStart = currentTimestamp - windowSeconds * 1000;

     // Remove outdated entries
     await zremrangebyscoreAsync(key, 0, windowStart);

     // Add current request
     await zaddAsync(key, currentTimestamp, currentTimestamp);

     // Get the number of requests in the window
     const requestCount = await zcardAsync(key);

     // Set TTL for the key to ensure it expires after the window
     redisClient.client.expire(key, windowSeconds);

     return requestCount > maxRequests;
   }

   module.exports = {
     isRateLimited,
   };
   

// redisClient.js

const redis = require('redis');
const { promisify } = require('util');
const logger = require('./logger'); // Assuming you have a logger module

// Configure Redis connection
const REDIS_PORT = process.env.REDIS_PORT || 6379;
const REDIS_HOST = process.env.REDIS_HOST || '127.0.0.1';
const REDIS_PASSWORD = process.env.REDIS_PASSWORD || ''; // If set

// Create Redis client
const client = redis.createClient({
  host: REDIS_HOST,
  port: REDIS_PORT,
  password: REDIS_PASSWORD || undefined,
});

// Promisify Redis commands for async/await usage
const getAsync = promisify(client.get).bind(client);
const setAsync = promisify(client.set).bind(client);
const delAsync = promisify(client.del).bind(client);

// Handle Redis connection events
client.on('connect', () => {
  logger.info('Connected to Redis server.');
});

client.on('error', (err) => {
  logger.error('Redis error:', err);
});

// Export Redis operations
module.exports = {
  get: getAsync,
  set: setAsync,
  del: delAsync,
  client, // Exporting client in case you need advanced operations
};

// cache.js

const redisClient = require('./redisClient');
const logger = require('./logger'); // Assuming you have a logger module

/**
 * Sets a value in Redis with an optional TTL (in seconds).
 * @param {string} key - The Redis key.
 * @param {any} value - The value to store (will be stringified).
 * @param {number} ttl - Time-to-live in seconds.
 */
async function setCache(key, value, ttl = 3600) { // Default TTL: 1 hour
  try {
    const stringValue = JSON.stringify(value);
    await redisClient.set(key, stringValue, 'EX', ttl);
    logger.info(Cache set for key: ${key});
  } catch (error) {
    logger.error(Error setting cache for key ${key}:, error);
  }
}

/**
 * Retrieves a value from Redis.
 * @param {string} key - The Redis key.
 * @returns {any} - The parsed value or null if not found.
 */
async function getCache(key) {
  try {
    const data = await redisClient.get(key);
    if (data) {
      logger.info(Cache hit for key: ${key});
      return JSON.parse(data);
    }
    logger.info(Cache miss for key: ${key});
    return null;
  } catch (error) {
    logger.error(Error getting cache for key ${key}:, error);
    return null;
  }
}

/**
 * Deletes a value from Redis.
 * @param {string} key - The Redis key.
 */
async function deleteCache(key) {
  try {
    await redisClient.del(key);
    logger.info(Cache deleted for key: ${key});
  } catch (error) {
    logger.error(Error deleting cache for key ${key}:, error);
  }
}

module.exports = {
  setCache,
  getCache,
  deleteCache,
};

// routes/cards.js

const express = require('express');
const router = express.Router();
const axios = require('axios');
const cache = require('../cache'); // Import the cache utility
const logger = require('../logger'); // Assuming you have a logger module

const SCRYFALL_API_BASE = 'https://api.scryfall.com/cards';

/**
 * Utility function to fetch card data from Scryfall API
 * @param {string} cardId - The unique ID of the card
 * @returns {object} - The card data
 */
async function fetchCardFromAPI(cardId) {
  try {
    const response = await axios.get(${SCRYFALL_API_BASE}/${cardId});
    return response.data;
  } catch (error) {
    logger.error(Error fetching card ${cardId} from Scryfall:, error.message);
    throw error;
  }
}

// GET /api/cards/:id
router.get('/:id', async (req, res) => {
  const cardId = req.params.id;
  const cacheKey = card:${cardId};

  try {
    // Attempt to retrieve card data from cache
    const cachedCard = await cache.getCache(cacheKey);
    if (cachedCard) {
      return res.json({ source: 'cache', data: cachedCard });
    }

    // If cache miss, fetch from Scryfall API
    const cardData = await fetchCardFromAPI(cardId);

    // Store the fetched data in cache with TTL of 24 hours
    await cache.setCache(cacheKey, cardData, 86400); // 86400 seconds = 24 hours

    res.json({ source: 'api', data: cardData });
  } catch (error) {
    res.status(500).json({ message: 'Internal Server Error' });
  }
});

// POST /api/cards/batch
router.post('/batch', async (req, res) => {
  const { cardIds } = req.body; // Expecting an array of card IDs
  if (!Array.isArray(cardIds) || cardIds.length === 0) {
    return res.status(400).json({ message: 'cardIds must be a non-empty array.' });
  }

  const cacheKeys = cardIds.map(id => card:${id});

  try {
    // Retrieve multiple keys from cache
    const cachedCards = await Promise.all(cacheKeys.map(key => cache.getCache(key)));

    const responseData = {};
    const cardsToFetch = [];

    cardIds.forEach((id, index) => {
      if (cachedCards[index]) {
        responseData[id] = { source: 'cache', data: cachedCards[index] };
      } else {
        cardsToFetch.push(id);
      }
    });

    // Fetch missing cards from API
    const fetchPromises = cardsToFetch.map(id => fetchCardFromAPI(id));
    const fetchedCards = await Promise.all(fetchPromises);

    // Prepare bulk cache set operations
    const setPromises = fetchedCards.map(card => {
      const key = card:${card.id};
      responseData[card.id] = { source: 'api', data: card };
      return cache.setCache(key, card, 86400); // TTL: 24 hours
    });

    await Promise.all(setPromises);

    res.json({ data: responseData });
  } catch (error) {
    logger.error('Error in batch fetching cards:', error.message);
    res.status(500).json({ message: 'Internal Server Error' });
  }
});

module.exports = router;

// routes/cards.js

// PUT /api/cards/:id
router.put('/:id', async (req, res) => {
  const cardId = req.params.id;
  const updatedFields = req.body;

  try {
    // Update card in MongoDB or PostgreSQL
    const updatedCard = await updateCardInDatabase(cardId, updatedFields); // Implement this function

    if (!updatedCard) {
      return res.status(404).json({ message: 'Card not found.' });
    }

    const cacheKey = card:${cardId};
    
    // Invalidate the cache for this card
    await cache.deleteCache(cacheKey);

    res.json({ message: 'Card updated successfully.', data: updatedCard });
  } catch (error) {
    logger.error(Error updating card ${cardId}:, error.message);
    res.status(500).json({ message: 'Internal Server Error' });
  }
});

redis-cli INFO

  redis-cli INFO memory
  

  redis-cli INFO stats
  

  redis-cli INFO keyspace
  

redis-cli INFO stats | grep keyspace_hits
redis-cli INFO stats | grep keyspace_misses

hit_rate = (8000 / (8000 + 2000)) * 100 = 80%

redis-cli MONITOR

   docker run -d --name redis_exporter -p 9121:9121 oliver006/redis_exporter
   

   scrape_configs:
     - job_name: 'redis'
       static_configs:
         - targets: ['localhost:9121']
   

   card:{cardId}
   user:{userId}:profile
   recommendations:{userId}
   

   // rateLimiter.js

   const redisClient = require('./redisClient');
   const { promisify } = require('util');

   const zaddAsync = promisify(redisClient.client.zadd).bind(redisClient.client);
   const zremrangebyscoreAsync = promisify(redisClient.client.zremrangebyscore).bind(redisClient.client);
   const zcardAsync = promisify(redisClient.client.zcard).bind(redisClient.client);

   /**
    * Checks if a user has exceeded the rate limit.
    * @param {string} userId - The unique ID of the user.
    * @param {number} maxRequests - Maximum allowed requests.
    * @param {number} windowSeconds - Time window in seconds.
    * @returns {boolean} - True if rate limited, else false.
    */
   async function isRateLimited(userId, maxRequests, windowSeconds) {
     const key = rate_limit:${userId};
     const currentTimestamp = Date.now();
     const windowStart = currentTimestamp - windowSeconds * 1000;

     // Remove outdated entries
     await zremrangebyscoreAsync(key, 0, windowStart);

     // Add current request
     await zaddAsync(key, currentTimestamp, currentTimestamp);

     // Get the number of requests in the window
     const requestCount = await zcardAsync(key);

     // Set TTL for the key to ensure it expires after the window
     redisClient.client.expire(key, windowSeconds);

     return requestCount > maxRequests;
   }

   module.exports = {
     isRateLimited,
   };
   

   cd /path/to/your/project
   

   npm init -y
   

   npm install sequelize pg pg-hstore
   npm install --save-dev sequelize-cli
   

   npx sequelize-cli init
   

   your-project/
   ├── config/
   │   └── config.json
   ├── migrations/
   ├── models/
   │   └── index.js
   ├── seeders/
   ├── package.json
   └── ...
   

   {
     "development": {
       "username": "your_db_username",
       "password": "your_db_password",
       "database": "mtg_draft_app_dev",
       "host": "127.0.0.1",
       "dialect": "postgres"
     },
     "test": {
       "username": "your_db_username",
       "password": "your_db_password",
       "database": "mtg_draft_app_test",
       "host": "127.0.0.1",
       "dialect": "postgres"
     },
     "production": {
       "username": "your_db_username",
       "password": "your_db_password",
       "database": "mtg_draft_app_prod",
       "host": "127.0.0.1",
       "dialect": "postgres"
     }
   }
   

npm install --save-dev jest sequelize-test-helpers sqlite3

{
  "scripts": {
    "test": "jest"
  },
  "jest": {
    "testEnvironment": "node"
  }
}

// jest.config.js

module.exports = {
  testEnvironment: 'node',
};

{
  "development": {
    "username": "your_db_username",
    "password": "your_db_password",
    "database": "mtg_draft_app_dev",
    "host": "127.0.0.1",
    "dialect": "postgres"
  },
  "test": {
    "username": "your_db_username",
    "password": "your_db_password",
    "database": "mtg_draft_app_test",
    "host": "127.0.0.1",
    "dialect": "postgres",
    "logging": false
  },
  "production": {
    "username": "your_db_username",
    "password": "your_db_password",
    "database": "mtg_draft_app_prod",
    "host": "127.0.0.1",
    "dialect": "postgres"
  }
}

your-project/
├── __tests__/
│   ├── user.test.js
│   ├── draft.test.js
│   └── draftedCard.test.js
├── models/
│   ├── user.js
│   ├── draft.js
│   └── draftedCard.js
├── config/
│   └── config.json
├── package.json
└── ...

// models/user.js

module.exports = (sequelize, DataTypes) => {
  const User = sequelize.define('User', {
    id: {
      type: DataTypes.UUID,
      defaultValue: DataTypes.UUIDV4,
      primaryKey: true,
    },
    username: {
      type: DataTypes.STRING(50),
      allowNull: false,
    },
    email: {
      type: DataTypes.STRING(100),
      allowNull: false,
      unique: true,
      validate: {
        isEmail: true,
      },
    },
    password_hash: {
      type: DataTypes.STRING(255),
      allowNull: false,
    },
    created_at: {
      type: DataTypes.DATE,
      defaultValue: sequelize.literal('NOW()'),
    },
    updated_at: {
      type: DataTypes.DATE,
      defaultValue: sequelize.literal('NOW()'),
    },
  }, {
    tableName: 'Users',
    timestamps: false,
  });

  User.associate = (models) => {
    User.hasMany(models.Draft, {
      foreignKey: 'user_id',
      as: 'drafts',
    });
  };

  return User;
};

// models/draft.js

module.exports = (sequelize, DataTypes) => {
  const Draft = sequelize.define('Draft', {
    id: {
      type: DataTypes.UUID,
      defaultValue: DataTypes.UUIDV4,
      primaryKey: true,
    },
    user_id: {
      type: DataTypes.UUID,
      allowNull: false,
    },
    status: {
      type: DataTypes.STRING(20),
      allowNull: false,
      defaultValue: 'ongoing',
    },
    started_at: {
      type: DataTypes.DATE,
      defaultValue: sequelize.literal('NOW()'),
    },
    completed_at: {
      type: DataTypes.DATE,
      allowNull: true,
    },
    metadata: {
      type: DataTypes.JSONB,
      allowNull: true,
    },
    created_at: {
      type: DataTypes.DATE,
      defaultValue: sequelize.literal('NOW()'),
    },
    updated_at: {
      type: DataTypes.DATE,
      defaultValue: sequelize.literal('NOW()'),
    },
  }, {
    tableName: 'Drafts',
    timestamps: false,
  });

  Draft.associate = (models) => {
    Draft.belongsTo(models.User, {
      foreignKey: 'user_id',
      as: 'user',
    });
    Draft.hasMany(models.DraftedCard, {
      foreignKey: 'draft_id',
      as: 'draftedCards',
    });
  };

  return Draft;
};

// models/draftedCard.js

module.exports = (sequelize, DataTypes) => {
  const DraftedCard = sequelize.define('DraftedCard', {
    id: {
      type: DataTypes.UUID,
      defaultValue: DataTypes.UUIDV4,
      primaryKey: true,
    },
    draft_id: {
      type: DataTypes.UUID,
      allowNull: false,
    },
    card_id: {
      type: DataTypes.UUID,
      allowNull: false,
    },
    pick_number: {
      type: DataTypes.INTEGER,
      allowNull: false,
    },
    position: {
      type: DataTypes.STRING(20),
      allowNull: true,
    },
    timestamp: {
      type: DataTypes.DATE,
      defaultValue: sequelize.literal('NOW()'),
    },
    created_at: {
      type: DataTypes.DATE,
      defaultValue: sequelize.literal('NOW()'),
    },
    updated_at: {
      type: DataTypes.DATE,
      defaultValue: sequelize.literal('NOW()'),
    },
  }, {
    tableName: 'DraftedCards',
    timestamps: false,
  });

  DraftedCard.associate = (models) => {
    DraftedCard.belongsTo(models.Draft, {
      foreignKey: 'draft_id',
      as: 'draft',
    });
    // Assuming there's a Card model
    DraftedCard.belongsTo(models.Card, {
      foreignKey: 'card_id',
      as: 'card',
    });
  };

  return DraftedCard;
};

// __tests__/user.test.js

const { sequelize, User, Draft } = require('../models');
const { sequelize: testSequelize } = require('../models'); // Ensure testSequelize is connected to test DB

beforeAll(async () => {
  await sequelize.sync({ force: true }); // Recreate tables
});

afterAll(async () => {
  await sequelize.close();
});

describe('User Model', () => {
  test('should create a new user', async () => {
    const user = await User.create({
      username: 'testuser',
      email: 'test@example.com',
      password_hash: 'hashedpassword',
    });

    expect(user.id).toBeDefined();
    expect(user.username).toBe('testuser');
    expect(user.email).toBe('test@example.com');
  });

  test('should not allow duplicate emails', async () => {
    expect.assertions(1);
    try {
      await User.create({
        username: 'anotheruser',
        email: 'test@example.com', // Duplicate email
        password_hash: 'anotherhashedpassword',
      });
    } catch (error) {
      expect(error.name).toBe('SequelizeUniqueConstraintError');
    }
  });

  test('should have many drafts', async () => {
    const user = await User.findOne({ where: { email: 'test@example.com' } });
    await Draft.create({
      user_id: user.id,
      status: 'ongoing',
    });
    await Draft.create({
      user_id: user.id,
      status: 'completed',
      completed_at: new Date(),
    });

    const drafts = await user.getDrafts();
    expect(drafts.length).toBe(2);
  });
});

// __tests__/draft.test.js

const { sequelize, User, Draft, DraftedCard } = require('../models');

beforeAll(async () => {
  await sequelize.sync({ force: true });
});

afterAll(async () => {
  await sequelize.close();
});

describe('Draft Model', () => {
  let user;

  beforeEach(async () => {
    user = await User.create({
      username: 'draftuser',
      email: 'draft@example.com',
      password_hash: 'drafthashedpassword',
    });
  });

  test('should create a new draft', async () => {
    const draft = await Draft.create({
      user_id: user.id,
      status: 'ongoing',
    });

    expect(draft.id).toBeDefined();
    expect(draft.status).toBe('ongoing');
    expect(draft.user_id).toBe(user.id);
  });

  test('should have many drafted cards', async () => {
    const draft = await Draft.create({
      user_id: user.id,
      status: 'ongoing',
    });

    await DraftedCard.create({
      draft_id: draft.id,
      card_id: 'card-uuid-1',
      pick_number: 1,
      position: 'first',
    });

    await DraftedCard.create({
      draft_id: draft.id,
      card_id: 'card-uuid-2',
      pick_number: 2,
      position: 'second',
    });

    const draftedCards = await draft.getDraftedCards();
    expect(draftedCards.length).toBe(2);
  });
});

// __tests__/draftedCard.test.js

const { sequelize, User, Draft, DraftedCard } = require('../models');

beforeAll(async () => {
  await sequelize.sync({ force: true });
});

afterAll(async () => {
  await sequelize.close();
});

describe('DraftedCard Model', () => {
  let user, draft;

  beforeEach(async () => {
    user = await User.create({
      username: 'drafteduser',
      email: 'drafted@example.com',
      password_hash: 'draftedhashedpassword',
    });

    draft = await Draft.create({
      user_id: user.id,
      status: 'ongoing',
    });
  });

  test('should create a drafted card', async () => {
    const draftedCard = await DraftedCard.create({
      draft_id: draft.id,
      card_id: 'card-uuid-3',
      pick_number: 1,
      position: 'first',
    });

    expect(draftedCard.id).toBeDefined();
    expect(draftedCard.card_id).toBe('card-uuid-3');
    expect(draftedCard.pick_number).toBe(1);
    expect(draftedCard.position).toBe('first');
    expect(draftedCard.draft_id).toBe(draft.id);
  });

  test('should belong to a draft and a card', async () => {
    const draftedCard = await DraftedCard.create({
      draft_id: draft.id,
      card_id: 'card-uuid-4',
      pick_number: 2,
      position: 'second',
    });

    const fetchedDraft = await draftedCard.getDraft();
    expect(fetchedDraft.id).toBe(draft.id);

    // Assuming a Card model exists and is associated
    // const fetchedCard = await draftedCard.getCard();
    // expect(fetchedCard.id).toBe('card-uuid-4');
  });
});

{
  "scripts": {
    "test": "jest"
  }
}

npm test

 PASS  __tests__/user.test.js
  User Model
    ✓ should create a new user (xx ms)
    ✓ should not allow duplicate emails (xx ms)
    ✓ should have many drafts (xx ms)

 PASS  __tests__/draft.test.js
  Draft Model
    ✓ should create a new draft (xx ms)
    ✓ should have many drafted cards (xx ms)

 PASS  __tests__/draftedCard.test.js
  DraftedCard Model
    ✓ should create a drafted card (xx ms)
    ✓ should belong to a draft and a card (xx ms)

Test Suites: 3 passed, 3 total
Tests:       7 passed, 7 total
Snapshots:   0 total
Time:        x.x s
Ran all test suites.

   // __tests__/user.test.js

   beforeEach(async () => {
     await sequelize.transaction(async (t) => {
       // Use transaction 't' for all create operations
     });
   });
   

Synergy Score = (Shared Mechanics * 0.25) +
                (Color Alignment * 0.20) +
                (Archetype Compatibility * 0.15) +
                (Mana Curve Balance * 0.15) +
                (Synergistic Interactions * 0.10) +
                (Combo Potential * 0.05) +
                (Card Strength * 0.05) +
                (Card Type Diversity * 0.05)

pip install pandas numpy

import pandas as pd

drafted_cards = pd.DataFrame([
    {
        'id': 'card-uuid-1',
        'name': 'Card One',
        'mechanics': ['Trample', 'Haste'],
        'color': ['Green'],
        'archetype': 'Aggro',
        'mana_cost': 3,
        'type': 'Creature',
        'synergistic_interactions': ['Card Three'],
        'combo_potential': 0,
        'card_strength': 80,
        'card_type': 'Creature'
    },
    {
        'id': 'card-uuid-2',
        'name': 'Card Two',
        'mechanics': ['Flying'],
        'color': ['Blue'],
        'archetype': 'Control',
        'mana_cost': 2,
        'type': 'Instant',
        'synergistic_interactions': [],
        'combo_potential': 0,
        'card_strength': 70,
        'card_type': 'Instant'
    },
    # Add more drafted cards
])

available_cards = pd.DataFrame([
    {
        'id': 'card-uuid-3',
        'name': 'Card Three',
        'mechanics': ['Trample'],
        'color': ['Green'],
        'archetype': 'Aggro',
        'mana_cost': 4,
        'type': 'Creature',
        'synergistic_interactions': ['Card One'],
        'combo_potential': 0,
        'card_strength': 85,
        'card_type': 'Creature'
    },
    {
        'id': 'card-uuid-4',
        'name': 'Card Four',
        'mechanics': ['Flying', 'First Strike'],
        'color': ['White'],
        'archetype': 'Midrange',
        'mana_cost': 3,
        'type': 'Creature',
        'synergistic_interactions': [],
        'combo_potential': 1,
        'card_strength': 75,
        'card_type': 'Creature'
    },
    # Add more available cards
])

import pandas as pd
import numpy as np

def calculate_synergy_scores(drafted_cards: pd.DataFrame, available_cards: pd.DataFrame) -> pd.DataFrame:
    """
    Calculates synergy scores for available cards based on drafted cards.

    :param drafted_cards: DataFrame containing drafted cards.
    :param available_cards: DataFrame containing available cards to recommend.
    :return: DataFrame with available cards and their synergy scores.
    """
    # Define weights
    weights = {
        'shared_mechanics': 0.25,
        'color_alignment': 0.20,
        'archetype_compatibility': 0.15,
        'mana_curve_balance': 0.15,
        'synergistic_interactions': 0.10,
        'combo_potential': 0.05,
        'card_strength': 0.05,
        'card_type_diversity': 0.05
    }

    # Initialize synergy scores
    available_cards = available_cards.copy()
    available_cards['synergy_score'] = 0

    # Shared Mechanics
    def compute_shared_mechanics(row):
        shared = drafted_cards['mechanics'].apply(lambda x: len(set(row['mechanics']).intersection(set(x)))).sum()
        max_shared = len(row['mechanics']) * len(drafted_cards)
        return (shared / max_shared) * 100 if max_shared > 0 else 0

    available_cards['shared_mechanics_score'] = available_cards.apply(compute_shared_mechanics, axis=1)
    available_cards['synergy_score'] += available_cards['shared_mechanics_score'] * weights['shared_mechanics']

    # Color Alignment
    def compute_color_alignment(row):
        aligned = drafted_cards['color'].apply(lambda x: 1 if set(row['color']).issubset(set(x)) else 0).sum()
        total = len(drafted_cards)
        return (aligned / total) * 100 if total > 0 else 0

    available_cards['color_alignment_score'] = available_cards.apply(compute_color_alignment, axis=1)
    available_cards['synergy_score'] += available_cards['color_alignment_score'] * weights['color_alignment']

    # Archetype Compatibility
    def compute_archetype_compatibility(row):
        compatible = drafted_cards['archetype'].apply(lambda x: 1 if row['archetype'] == x else 0).sum()
        total = len(drafted_cards)
        return (compatible / total) * 100 if total > 0 else 0

    available_cards['archetype_compatibility_score'] = available_cards.apply(compute_archetype_compatibility, axis=1)
    available_cards['synergy_score'] += available_cards['archetype_compatibility_score'] * weights['archetype_compatibility']

    # Mana Curve Balance
    def compute_mana_curve_balance(row):
        # Simple example: prefer cards that fit the average mana cost of drafted cards
        avg_mana = drafted_cards['mana_cost'].mean()
        deviation = abs(row['mana_cost'] - avg_mana)
        # Inverse relation: smaller deviation means higher score
        max_deviation = drafted_cards['mana_cost'].max()
        score = ((max_deviation - deviation) / max_deviation) * 100 if max_deviation > 0 else 100
        return score

    available_cards['mana_curve_balance_score'] = available_cards.apply(compute_mana_curve_balance, axis=1)
    available_cards['synergy_score'] += available_cards['mana_curve_balance_score'] * weights['mana_curve_balance']

    # Synergistic Interactions
    def compute_synergistic_interactions(row):
        interactions = row['synergistic_interactions']
        synergy = drafted_cards['name'].isin(interactions).sum()
        total_interactions = len(interactions)
        return (synergy / total_interactions) * 100 if total_interactions > 0 else 0

    available_cards['synergistic_interactions_score'] = available_cards.apply(compute_synergistic_interactions, axis=1)
    available_cards['synergy_score'] += available_cards['synergistic_interactions_score'] * weights['synergistic_interactions']

    # Combo Potential
    available_cards['combo_potential_score'] = available_cards['combo_potential'] * 100  # Assuming 0 or 1
    available_cards['synergy_score'] += available_cards['combo_potential_score'] * weights['combo_potential']

    # Card Strength
    available_cards['card_strength_score'] = available_cards['card_strength']  # Assuming already out of 100
    available_cards['synergy_score'] += available_cards['card_strength_score'] * weights['card_strength']

    # Card Type Diversity
    def compute_card_type_diversity(row):
        # Increase score if card type is not overly represented in drafted cards
        type_counts = drafted_cards['card_type'].value_counts()
        total_types = type_counts.sum()
        type_count = type_counts.get(row['card_type'], 0)
        diversity = 1 - (type_count / total_types) if total_types > 0 else 1
        return diversity * 100

    available_cards['card_type_diversity_score'] = available_cards.apply(compute_card_type_diversity, axis=1)
    available_cards['synergy_score'] += available_cards['card_type_diversity_score'] * weights['card_type_diversity']

    # Final Synergy Score (ensure it's within 0-100)
    available_cards['synergy_score'] = available_cards['synergy_score'].clip(0, 100)

    # Select relevant columns
    synergy_scores = available_cards[['id', 'name', 'synergy_score']]

    return synergy_scores

# synergy_calculator.py

import pandas as pd
from synergy_calculation import calculate_synergy_scores

# Sample drafted cards
drafted_cards = pd.DataFrame([
    {
        'id': 'card-uuid-1',
        'name': 'Card One',
        'mechanics': ['Trample', 'Haste'],
        'color': ['Green'],
        'archetype': 'Aggro',
        'mana_cost': 3,
        'type': 'Creature',
        'synergistic_interactions': ['Card Three'],
        'combo_potential': 0,
        'card_strength': 80,
        'card_type': 'Creature'
    },
    {
        'id': 'card-uuid-2',
        'name': 'Card Two',
        'mechanics': ['Flying'],
        'color': ['Blue'],
        'archetype': 'Control',
        'mana_cost': 2,
        'type': 'Instant',
        'synergistic_interactions': [],
        'combo_potential': 0,
        'card_strength': 70,
        'card_type': 'Instant'
    },
])

# Sample available cards
available_cards = pd.DataFrame([
    {
        'id': 'card-uuid-3',
        'name': 'Card Three',
        'mechanics': ['Trample'],
        'color': ['Green'],
        'archetype': 'Aggro',
        'mana_cost': 4,
        'type': 'Creature',
        'synergistic_interactions': ['Card One'],
        'combo_potential': 0,
        'card_strength': 85,
        'card_type': 'Creature'
    },
    {
        'id': 'card-uuid-4',
        'name': 'Card Four',
        'mechanics': ['Flying', 'First Strike'],
        'color': ['White'],
        'archetype': 'Midrange',
        'mana_cost': 3,
        'type': 'Creature',
        'synergistic_interactions': [],
        'combo_potential': 1,
        'card_strength': 75,
        'card_type': 'Creature'
    },
])

synergy_scores = calculate_synergy_scores(drafted_cards, available_cards)
print(synergy_scores)

               id        name  synergy_score
0  card-uuid-3  Card Three           77.5
1  card-uuid-4   Card Four           55.0

npm install axios

// powerLevelCalculator.js

const axios = require('axios');
const logger = require('./logger'); // Assuming you have a logger module

const SEVENTEENLANDS_API_BASE = 'https://www.17lands.com/api'; // Replace with actual base URL

/**
 * Fetches win rate data for a specific archetype from the 17lands API.
 * @param {string} archetype - The name of the archetype.
 * @returns {object} - An object containing win rate data.
 */
async function fetchWinRateData(archetype) {
  try {
    const response = await axios.get(${SEVENTEENLANDS_API_BASE}/archetypes/${encodeURIComponent(archetype)}/stats);
    return response.data;
  } catch (error) {
    logger.error(Error fetching win rate data for archetype ${archetype}:, error.message);
    throw error;
  }
}

/**
 * Normalizes win rate data to a consistent scale (e.g., 0-100).
 * @param {object} winRateData - Raw win rate data from the API.
 * @returns {object} - Normalized win rate scores.
 */
function normalizeWinRates(winRateData) {
  const normalizedData = {};

  // Example normalization: Assume win_rate is between 0 and 1
  normalizedData.overall_win_rate = winRateData.overall_win_rate * 100;

  // Normalize matchups
  normalizedData.matchups = {};
  for (const matchup of winRateData.matchups) {
    normalizedData.matchups[matchup.opponent_archetype] = matchup.win_rate * 100;
  }

  return normalizedData;
}

/**
 * Calculates power level based on normalized win rates.
 * @param {object} normalizedWinRates - Normalized win rate scores.
 * @returns {number} - Calculated power level.
 */
function calculatePowerLevel(normalizedWinRates) {
  // Example calculation: Weighted average of overall win rate and matchup win rates
  const weights = {
    overall: 0.6,
    matchups: 0.4,
  };

  const overall = normalizedWinRates.overall_win_rate;

  // Calculate average matchup win rate
  const matchupWinRates = Object.values(normalizedWinRates.matchups);
  const avgMatchupWinRate = matchupWinRates.length > 0
    ? matchupWinRates.reduce((a, b) => a + b, 0) / matchupWinRates.length
    : 0;

  const powerLevel = (overall * weights.overall) + (avgMatchupWinRate * weights.matchups);
  return parseFloat(powerLevel.toFixed(2));
}

/**
 * Fetches and calculates power level for a given archetype.
 * @param {string} archetype - The name of the archetype.
 * @returns {number} - The calculated power level.
 */
async function getPowerLevel(archetype) {
  try {
    const rawData = await fetchWinRateData(archetype);
    const normalizedData = normalizeWinRates(rawData);
    const powerLevel = calculatePowerLevel(normalizedData);
    return powerLevel;
  } catch (error) {
    logger.error(Failed to calculate power level for archetype ${archetype}.);
    return null;
  }
}

module.exports = {
  getPowerLevel,
};

// exampleUsage.js

const powerLevelCalculator = require('./powerLevelCalculator');

async function main() {
  const archetype = 'Aggro'; // Example archetype
  const powerLevel = await powerLevelCalculator.getPowerLevel(archetype);
  if (powerLevel !== null) {
    console.log(Power Level for ${archetype}: ${powerLevel});
  } else {
    console.log(Failed to calculate Power Level for ${archetype}.);
  }
}

main();

Power Level for Aggro: 65.75

import pandas as pd

archetype_templates = {
    'Aggro': {
        'mechanics': ['Haste', 'Trample'],
        'color': ['Red', 'Green'],
        'card_types': ['Creature'],
        'mana_cost_range': (1, 4)
    },
    'Control': {
        'mechanics': ['Counterspell', 'Draw'],
        'color': ['Blue', 'White'],
        'card_types': ['Instant', 'Sorcery', 'Enchantment'],
        'mana_cost_range': (2, 6)
    },
    'Midrange': {
        'mechanics': ['Flying', 'First Strike'],
        'color': ['Black', 'Green'],
        'card_types': ['Creature', 'Enchantment'],
        'mana_cost_range': (3, 5)
    },
    # Add more archetypes as needed
}

def calculate_synergy_scores(drafted_cards: pd.DataFrame, available_cards: pd.DataFrame, archetype_templates: dict) -> pd.DataFrame:
    """
    Calculates synergy scores for available cards based on drafted cards and archetype templates.

    :param drafted_cards: DataFrame containing drafted cards.
    :param available_cards: DataFrame containing available cards to recommend.
    :param archetype_templates: Dictionary of archetype templates.
    :return: DataFrame with available cards and their synergy scores.
    """
    # Define weights (including archetype compatibility)
    weights = {
        'shared_mechanics': 0.20,
        'color_alignment': 0.15,
        'archetype_compatibility': 0.25,
        'mana_curve_balance': 0.10,
        'synergistic_interactions': 0.10,
        'combo_potential': 0.05,
        'card_strength': 0.10,
        'card_type_diversity': 0.05
    }

    # Initialize synergy scores
    available_cards = available_cards.copy()
    available_cards['synergy_score'] = 0

    # Existing metrics calculations...

    # Archetype Compatibility
    def compute_archetype_compatibility(row):
        compatibility_scores = {}
        for archetype, template in archetype_templates.items():
            # Shared mechanics
            shared_mechanics = len(set(row['mechanics']).intersection(set(template['mechanics']))) / len(template['mechanics']) if template['mechanics'] else 0
            # Color alignment
            color_alignment = len(set(row['color']).intersection(set(template['color']))) / len(template['color']) if template['color'] else 0
            # Card type alignment
            type_alignment = 1 if row['type'] in template['card_types'] else 0
            # Mana cost alignment
            mana_cost = row['mana_cost']
            mana_cost_alignment = 1 if template['mana_cost_range'][0] <= mana_cost <= template['mana_cost_range'][1] else 0

            # Calculate compatibility score for the archetype
            compatibility = (shared_mechanics + color_alignment + type_alignment + mana_cost_alignment) / 4 * 100
            compatibility_scores[archetype] = compatibility

        # Take the maximum compatibility score
        max_compatibility = max(compatibility_scores.values()) if compatibility_scores else 0
        return max_compatibility

    available_cards['archetype_compatibility_score'] = available_cards.apply(compute_archetype_compatibility, axis=1)
    available_cards['synergy_score'] += available_cards['archetype_compatibility_score'] * weights['archetype_compatibility']

    # Final Synergy Score (ensure it's within 0-100)
    available_cards['synergy_score'] = available_cards['synergy_score'].clip(0, 100)

    # Select relevant columns
    synergy_scores = available_cards[['id', 'name', 'synergy_score']]

    return synergy_scores

import cProfile
import pstats
from synergy_calculation import calculate_synergy_scores

def run_profiling():
    # Sample data
    drafted_cards = pd.read_csv('drafted_cards.csv')
    available_cards = pd.read_csv('available_cards.csv')
    archetype_templates = load_archetype_templates()

    profiler = cProfile.Profile()
    profiler.enable()

    synergy_scores = calculate_synergy_scores(drafted_cards, available_cards, archetype_templates)

    profiler.disable()
    stats = pstats.Stats(profiler).sort_stats('cumtime')
    stats.print_stats(10)  # Print top 10 functions by cumulative time

if __name__ == "__main__":
    run_profiling()

def compute_shared_mechanics_vectorized(drafted_mechanics, available_mechanics):
    """
    Computes shared mechanics score using vectorized operations.
    """
    # Create a set of all drafted mechanics
    drafted_mechanics_set = set(mech for sublist in drafted_mechanics for mech in sublist)
    available_cards['shared_mechanics_count'] = available_mechanics.apply(lambda x: len(set(x).intersection(drafted_mechanics_set)))
    available_cards['shared_mechanics_max'] = available_cards['mechanics'].apply(len) * len(drafted_mechanics_set)
    available_cards['shared_mechanics_score'] = np.where(
        available_cards['shared_mechanics_max'] > 0,
        (available_cards['shared_mechanics_count'] / available_cards['shared_mechanics_max']) * 100,
        0
    )
    available_cards['synergy_score'] += available_cards['shared_mechanics_score'] * weights['shared_mechanics']

available_cards['mechanics'] = available_cards['mechanics'].astype('category')
available_cards['color'] = available_cards['color'].astype('category')

from joblib import Parallel, delayed

def calculate_shared_mechanics(row, drafted_mechanics_set):
    return len(set(row['mechanics']).intersection(drafted_mechanics_set))

available_cards['shared_mechanics_count'] = Parallel(n_jobs=-1)(
    delayed(calculate_shared_mechanics)(row, drafted_mechanics_set)
    for _, row in available_cards.iterrows()
)

available_cards.drop(['shared_mechanics_count', 'shared_mechanics_max'], axis=1, inplace=True)

from functools import lru_cache

@lru_cache(maxsize=None)
def get_drafted_mechanics():
    return tuple(mech for sublist in drafted_cards['mechanics'] for mech in sublist)

test_cases = [
    {
        'description': 'Aggro Strategy',
        'drafted_cards': pd.DataFrame([
            {
                'id': 'card-aggro-1',
                'name': 'Quick Strike',
                'mechanics': ['Haste'],
                'color': ['Red'],
                'archetype': 'Aggro',
                'mana_cost': 1,
                'type': 'Creature',
                'synergistic_interactions': [],
                'combo_potential': 0,
                'card_strength': 75,
                'card_type': 'Creature'
            },
            {
                'id': 'card-aggro-2',
                'name': 'Frenzied Berserker',
                'mechanics': ['Trample'],
                'color': ['Red'],
                'archetype': 'Aggro',
                'mana_cost': 3,
                'type': 'Creature',
                'synergistic_interactions': ['Quick Strike'],
                'combo_potential': 0,
                'card_strength': 80,
                'card_type': 'Creature'
            },
        ]),
        'available_cards': pd.DataFrame([
            {
                'id': 'card-aggro-3',
                'name': 'Rampaging Bull',
                'mechanics': ['Trample'],
                'color': ['Red'],
                'archetype': 'Aggro',
                'mana_cost': 4,
                'type': 'Creature',
                'synergistic_interactions': ['Frenzied Berserker'],
                'combo_potential': 0,
                'card_strength': 85,
                'card_type': 'Creature'
            },
            {
                'id': 'card-control-1',
                'name': 'Counterspell',
                'mechanics': ['Counter'],
                'color': ['Blue'],
                'archetype': 'Control',
                'mana_cost': 2,
                'type': 'Instant',
                'synergistic_interactions': [],
                'combo_potential': 0,
                'card_strength': 90,
                'card_type': 'Instant'
            },
        ]),
        'expected': {
            'card-aggro-3': 'High Synergy',
            'card-control-1': 'Low Synergy'
        }
    },
    {
        'description': 'Control Strategy',
        'drafted_cards': pd.DataFrame([
            {
                'id': 'card-control-1',
                'name': 'Scry Mage',
                'mechanics': ['Draw'],
                'color': ['Blue'],
                'archetype': 'Control',
                'mana_cost': 2,
                'type': 'Creature',
                'synergistic_interactions': [],
                'combo_potential': 0,
                'card_strength': 70,
                'card_type': 'Creature'
            },
            {
                'id': 'card-control-2',
                'name': 'Counterspell',
                'mechanics': ['Counter'],
                'color': ['Blue'],
                'archetype': 'Control',
                'mana_cost': 2,
                'type': 'Instant',
                'synergistic_interactions': [],
                'combo_potential': 0,
                'card_strength': 90,
                'card_type': 'Instant'
            },
        ]),
        'available_cards': pd.DataFrame([
            {
                'id': 'card-control-3',
                'name': 'Divination',
                'mechanics': ['Draw'],
                'color': ['Blue'],
                'archetype': 'Control',
                'mana_cost': 3,
                'type': 'Sorcery',
                'synergistic_interactions': ['Scry Mage'],
                'combo_potential': 0,
                'card_strength': 85,
                'card_type': 'Sorcery'
            },
            {
                'id': 'card-aggro-1',
                'name': 'Quick Strike',
                'mechanics': ['Haste'],
                'color': ['Red'],
                'archetype': 'Aggro',
                'mana_cost': 1,
                'type': 'Creature',
                'synergistic_interactions': [],
                'combo_potential': 0,
                'card_strength': 75,
                'card_type': 'Creature'
            },
        ]),
        'expected': {
            'card-control-3': 'High Synergy',
            'card-aggro-1': 'Low Synergy'
        }
    },
    # Add more test cases as needed
]

# __tests__/synergy_calculation.test.py

import unittest
import pandas as pd
from synergy_calculation import calculate_synergy_scores
from power_level_calculator import load_archetype_templates  # Assuming you have this function

class TestSynergyCalculation(unittest.TestCase):

    def setUp(self):
        # Load archetype templates
        self.archetype_templates = load_archetype_templates()

    def test_aggressive_strategy(self):
        test_case = {
            'description': 'Aggro Strategy',
            'drafted_cards': pd.DataFrame([
                {
                    'id': 'card-aggro-1',
                    'name': 'Quick Strike',
                    'mechanics': ['Haste'],
                    'color': ['Red'],
                    'archetype': 'Aggro',
                    'mana_cost': 1,
                    'type': 'Creature',
                    'synergistic_interactions': [],
                    'combo_potential': 0,
                    'card_strength': 75,
                    'card_type': 'Creature'
                },
                {
                    'id': 'card-aggro-2',
                    'name': 'Frenzied Berserker',
                    'mechanics': ['Trample'],
                    'color': ['Red'],
                    'archetype': 'Aggro',
                    'mana_cost': 3,
                    'type': 'Creature',
                    'synergistic_interactions': ['Quick Strike'],
                    'combo_potential': 0,
                    'card_strength': 80,
                    'card_type': 'Creature'
                },
            ]),
            'available_cards': pd.DataFrame([
                {
                    'id': 'card-aggro-3',
                    'name': 'Rampaging Bull',
                    'mechanics': ['Trample'],
                    'color': ['Red'],
                    'archetype': 'Aggro',
                    'mana_cost': 4,
                    'type': 'Creature',
                    'synergistic_interactions': ['Frenzied Berserker'],
                    'combo_potential': 0,
                    'card_strength': 85,
                    'card_type': 'Creature'
                },
                {
                    'id': 'card-control-1',
                    'name': 'Counterspell',
                    'mechanics': ['Counter'],
                    'color': ['Blue'],
                    'archetype': 'Control',
                    'mana_cost': 2,
                    'type': 'Instant',
                    'synergistic_interactions': [],
                    'combo_potential': 0,
                    'card_strength': 90,
                    'card_type': 'Instant'
                },
            ]),
            'expected': {
                'card-aggro-3': 'High Synergy',
                'card-control-1': 'Low Synergy'
            }
        }

        synergy_scores = calculate_synergy_scores(
            test_case['drafted_cards'],
            test_case['available_cards'],
            self.archetype_templates
        )

        for index, row in synergy_scores.iterrows():
            card_id = row['id']
            score = row['synergy_score']
            if card_id == 'card-aggro-3':
                self.assertGreaterEqual(score, 70)  # Expected high synergy
            elif card_id == 'card-control-1':
                self.assertLess(score, 60)  # Expected low synergy

    def test_control_strategy(self):
        test_case = {
            'description': 'Control Strategy',
            'drafted_cards': pd.DataFrame([
                {
                    'id': 'card-control-1',
                    'name': 'Scry Mage',
                    'mechanics': ['Draw'],
                    'color': ['Blue'],
                    'archetype': 'Control',
                    'mana_cost': 2,
                    'type': 'Creature',
                    'synergistic_interactions': [],
                    'combo_potential': 0,
                    'card_strength': 70,
                    'card_type': 'Creature'
                },
                {
                    'id': 'card-control-2',
                    'name': 'Counterspell',
                    'mechanics': ['Counter'],
                    'color': ['Blue'],
                    'archetype': 'Control',
                    'mana_cost': 2,
                    'type': 'Instant',
                    'synergistic_interactions': [],
                    'combo_potential': 0,
                    'card_strength': 90,
                    'card_type': 'Instant'
                },
            ]),
            'available_cards': pd.DataFrame([
                {
                    'id': 'card-control-3',
                    'name': 'Divination',
                    'mechanics': ['Draw'],
                    'color': ['Blue'],
                    'archetype': 'Control',
                    'mana_cost': 3,
                    'type': 'Sorcery',
                    'synergistic_interactions': ['Scry Mage'],
                    'combo_potential': 0,
                    'card_strength': 85,
                    'card_type': 'Sorcery'
                },
                {
                    'id': 'card-aggro-1',
                    'name': 'Quick Strike',
                    'mechanics': ['Haste'],
                    'color': ['Red'],
                    'archetype': 'Aggro',
                    'mana_cost': 1,
                    'type': 'Creature',
                    'synergistic_interactions': [],
                    'combo_potential': 0,
                    'card_strength': 75,
                    'card_type': 'Creature'
                },
            ]),
            'expected': {
                'card-control-3': 'High Synergy',
                'card-aggro-1': 'Low Synergy'
            }
        }

        synergy_scores = calculate_synergy_scores(
            test_case['drafted_cards'],
            test_case['available_cards'],
            self.archetype_templates
        )

        for index, row in synergy_scores.iterrows():
            card_id = row['id']
            score = row['synergy_score']
            if card_id == 'card-control-3':
                self.assertGreaterEqual(score, 70)  # Expected high synergy
            elif card_id == 'card-aggro-1':
                self.assertLess(score, 60)  # Expected low synergy

    # Add more test methods for additional test cases

if __name__ == '__main__':
    unittest.main()

python -m unittest discover -s __tests__

..
----------------------------------------------------------------------
Ran 2 tests in 0.XXXs

OK

npm install axios

// powerLevelCalculator.js

const axios = require('axios');
const logger = require('./logger'); // Assuming you have a logger module
const redisClient = require('./redisClient'); // Redis for caching

const SEVENTEENLANDS_API_BASE = 'https://www.17lands.com/api'; // Replace with actual base URL

/**
 * Fetches win rate data for a specific archetype from the 17lands API.
 * @param {string} archetype - The name of the archetype.
 * @returns {object} - An object containing win rate data.
 */
async function fetchWinRateData(archetype) {
  try {
    const response = await axios.get(${SEVENTEENLANDS_API_BASE}/archetypes/${encodeURIComponent(archetype)}/stats);
    return response.data;
  } catch (error) {
    logger.error(Error fetching win rate data for archetype ${archetype}:, error.message);
    throw error;
  }
}

/**
 * Normalizes win rate data to a consistent scale (e.g., 0-100).
 * @param {object} winRateData - Raw win rate data from the API.
 * @returns {object} - Normalized win rate scores.
 */
function normalizeWinRates(winRateData) {
  const normalizedData = {};

  // Example normalization: Assume win_rate is between 0 and 1
  normalizedData.overall_win_rate = winRateData.overall_win_rate * 100;

  // Normalize matchups
  normalizedData.matchups = {};
  for (const matchup of winRateData.matchups) {
    normalizedData.matchups[matchup.opponent_archetype] = matchup.win_rate * 100;
  }

  return normalizedData;
}

/**
 * Calculates power level based on normalized win rates.
 * @param {object} normalizedWinRates - Normalized win rate scores.
 * @returns {number} - Calculated power level.
 */
function calculatePowerLevel(normalizedWinRates) {
  // Example calculation: Weighted average of overall win rate and matchup win rates
  const weights = {
    overall: 0.6,
    matchups: 0.4,
  };

  const overall = normalizedWinRates.overall_win_rate;

  // Calculate average matchup win rate
  const matchupWinRates = Object.values(normalizedWinRates.matchups);
  const avgMatchupWinRate = matchupWinRates.length > 0
    ? matchupWinRates.reduce((a, b) => a + b, 0) / matchupWinRates.length
    : 0;

  const powerLevel = (overall * weights.overall) + (avgMatchupWinRate * weights.matchups);
  return parseFloat(powerLevel.toFixed(2));
}

/**
 * Fetches and calculates power level for a given archetype.
 * @param {string} archetype - The name of the archetype.
 * @returns {number} - The calculated power level.
 */
async function getPowerLevel(archetype) {
  const cacheKey = power_level:${archetype};

  try {
    // Check cache first
    const cachedPowerLevel = await redisClient.get(cacheKey);
    if (cachedPowerLevel) {
      logger.info(Power level for archetype ${archetype} fetched from cache.);
      return parseFloat(cachedPowerLevel);
    }

    const rawData = await fetchWinRateData(archetype);
    const normalizedData = normalizeWinRates(rawData);
    const powerLevel = calculatePowerLevel(normalizedData);

    // Cache the result with TTL of 24 hours
    await redisClient.set(cacheKey, powerLevel, 86400); // 86400 seconds = 24 hours

    logger.info(Power level for archetype ${archetype} calculated and cached.);
    return powerLevel;
  } catch (error) {
    logger.error(Failed to calculate power level for archetype ${archetype}:, error.message);
    return null;
  }
}

module.exports = {
  getPowerLevel,
};

// examplePowerLevel.js

const powerLevelCalculator = require('./powerLevelCalculator');

async function main() {
  const archetypes = ['Aggro', 'Control', 'Midrange']; // Example archetypes
  for (const archetype of archetypes) {
    const powerLevel = await powerLevelCalculator.getPowerLevel(archetype);
    if (powerLevel !== null) {
      console.log(Power Level for ${archetype}: ${powerLevel});
    } else {
      console.log(Failed to calculate Power Level for ${archetype}.);
    }
  }
}

main();

Power Level for Aggro: 65.75
Power Level for Control: 70.25
Power Level for Midrange: 68.50

   // src/components/PowerSynergyBar.jsx

   import React from 'react';
   import PropTypes from 'prop-types';
   import './PowerSynergyBar.css'; // Import corresponding CSS

   const PowerSynergyBar = ({ power, synergy }) => {
     return (
       <div className="power-synergy-container">
         <div className="metric">
           <span>Power</span>
           <div className="bar">
             <div
               className="bar-fill power-fill"
               style={{ width: ${power}% }}
             ></div>
           </div>
           <span>{power}</span>
         </div>
         <div className="metric">
           <span>Synergy</span>
           <div className="bar">
             <div
               className="bar-fill synergy-fill"
               style={{ width: ${synergy}% }}
             ></div>
           </div>
           <span>{synergy}</span>
         </div>
       </div>
     );
   };

   PowerSynergyBar.propTypes = {
     power: PropTypes.number.isRequired,
     synergy: PropTypes.number.isRequired,
   };

   export default PowerSynergyBar;
   

const manaCurve = {
  1: 0,
  2: 0,
  3: 0,
  4: 0,
  5: 0,
  6: 0,
  7: 0,
  8: 0,
  9: 0,
  10: 0,
};

// services/manaCurveService.js

const { DraftedCard, Card } = require('../models'); // Sequelize models
const io = require('../socket'); // Socket.io instance

/**
 * Calculates the mana curve for a given draft.
 * @param {string} draftId - The unique ID of the draft.
 * @returns {object} - The mana curve object.
 */
async function calculateManaCurve(draftId) {
  const draftedCards = await DraftedCard.findAll({
    where: { draft_id: draftId },
    include: [{ model: Card, as: 'card' }],
  });

  const curve = {
    1: 0,
    2: 0,
    3: 0,
    4: 0,
    5: 0,
    6: 0,
    7: 0,
    8: 0,
    9: 0,
    10: 0,
    '10+': 0,
  };

  draftedCards.forEach(({ card }) => {
    const cost = card.mana_cost;
    if (cost >= 1 && cost <= 10) {
      curve[cost] += 1;
    } else if (cost > 10) {
      curve['10+'] += 1;
    }
  });

  return curve;
}

/**
 * Updates the mana curve and emits it via WebSockets.
 * @param {string} draftId - The unique ID of the draft.
 */
async function updateManaCurve(draftId) {
  const curve = await calculateManaCurve(draftId);
  io.to(draftId).emit('manaCurveUpdate', curve);
}

module.exports = {
  calculateManaCurve,
  updateManaCurve,
};

// routes/manaCurve.js

const express = require('express');
const router = express.Router();
const { updateManaCurve } = require('../services/manaCurveService');

/**
 * GET /api/drafts/:draftId/mana-curve
 * Retrieves the current mana curve for the specified draft.
 */
router.get('/drafts/:draftId/mana-curve', async (req, res) => {
  const { draftId } = req.params;
  try {
    await updateManaCurve(draftId);
    res.status(200).json({ message: 'Mana curve updated and emitted.' });
  } catch (error) {
    res.status(500).json({ message: 'Failed to update mana curve.', error: error.message });
  }
});

module.exports = router;

npx create-react-app draft-navigator-overlay
cd draft-navigator-overlay

npm install d3

const manaCurveData = [
  { manaCost: 1, count: 3 },
  { manaCost: 2, count: 5 },
  { manaCost: 3, count: 7 },
  { manaCost: 4, count: 4 },
  { manaCost: 5, count: 2 },
  { manaCost: 6, count: 1 },
  { manaCost: 7, count: 0 },
  { manaCost: 8, count: 0 },
  { manaCost: 9, count: 0 },
  { manaCost: 10, count: 0 },
];

// src/components/ManaCurve.jsx

import React, { useRef, useEffect } from 'react';
import * as d3 from 'd3';
import PropTypes from 'prop-types';
import './ManaCurve.css'; // Import corresponding CSS

const ManaCurve = ({ data, width, height, onBarHover }) => {
  const svgRef = useRef();

  useEffect(() => {
    // Clear previous SVG content
    d3.select(svgRef.current).selectAll('*').remove();

    // Set up SVG canvas
    const svg = d3
      .select(svgRef.current)
      .attr('width', width)
      .attr('height', height);

    // Define margins
    const margin = { top: 20, right: 30, bottom: 30, left: 40 };
    const innerWidth = width - margin.left - margin.right;
    const innerHeight = height - margin.top - margin.bottom;

    // Create scales
    const x = d3
      .scaleBand()
      .domain(data.map((d) => d.manaCost))
      .range([0, innerWidth])
      .padding(0.1);

    const y = d3
      .scaleLinear()
      .domain([0, d3.max(data, (d) => d.count) || 10])
      .nice()
      .range([innerHeight, 0]);

    // Create a group element for margins
    const g = svg
      .append('g')
      .attr('transform', translate(${margin.left},${margin.top}));

    // Add X-axis
    g.append('g')
      .attr('transform', translate(0,${innerHeight}))
      .call(d3.axisBottom(x).tickFormat((d) => ${d}));

    // Add Y-axis
    g.append('g').call(d3.axisLeft(y));

    // Create bars
    g.selectAll('.bar')
      .data(data)
      .enter()
      .append('rect')
      .attr('class', 'bar')
      .attr('x', (d) => x(d.manaCost))
      .attr('y', (d) => y(d.count))
      .attr('width', x.bandwidth())
      .attr('height', (d) => innerHeight - y(d.count))
      .attr('fill', '#69b3a2')
      .on('mouseover', function (event, d) {
        d3.select(this).attr('fill', '#40a9f3');
        if (onBarHover) {
          onBarHover(d);
        }
      })
      .on('mouseout', function () {
        d3.select(this).attr('fill', '#69b3a2');
        if (onBarHover) {
          onBarHover(null);
        }
      });
  }, [data, width, height, onBarHover]);

  return <svg ref={svgRef}></svg>;
};

ManaCurve.propTypes = {
  data: PropTypes.arrayOf(
    PropTypes.shape({
      manaCost: PropTypes.number.isRequired,
      count: PropTypes.number.isRequired,
    })
  ).isRequired,
  width: PropTypes.number,
  height: PropTypes.number,
  onBarHover: PropTypes.func,
};

ManaCurve.defaultProps = {
  width: 500,
  height: 300,
  onBarHover: null,
};

export default ManaCurve;

// src/components/ManaCurveTooltip.jsx

import React from 'react';
import PropTypes from 'prop-types';
import './ManaCurveTooltip.css'; // Import corresponding CSS

const ManaCurveTooltip = ({ position, data }) => {
  if (!data) return null;

  const style = {
    left: position.x + 10,
    top: position.y + 10,
  };

  return (
    <div className="mana-curve-tooltip" style={style}>
      <strong>Mana Cost:</strong> {data.manaCost}
      <br />
      <strong>Count:</strong> {data.count}
    </div>
  );
};

ManaCurveTooltip.propTypes = {
  position: PropTypes.shape({
    x: PropTypes.number,
    y: PropTypes.number,
  }).isRequired,
  data: PropTypes.shape({
    manaCost: PropTypes.number,
    count: PropTypes.number,
  }),
};

ManaCurveTooltip.defaultProps = {
  data: null,
};

export default ManaCurveTooltip;

/* src/components/ManaCurveTooltip.css */

.mana-curve-tooltip {
  position: absolute;
  background-color: rgba(0, 0, 0, 0.75);
  color: #fff;
  padding: 8px;
  border-radius: 4px;
  pointer-events: none;
  font-size: 12px;
  z-index: 10;
}

// src/components/ManaCurve.jsx

import React, { useRef, useEffect, useState } from 'react';
import * as d3 from 'd3';
import PropTypes from 'prop-types';
import './ManaCurve.css';
import ManaCurveTooltip from './ManaCurveTooltip';

const ManaCurve = ({ data, width, height }) => {
  const svgRef = useRef();
  const [tooltipData, setTooltipData] = useState(null);
  const [tooltipPosition, setTooltipPosition] = useState({ x: 0, y: 0 });

  useEffect(() => {
    // Clear previous SVG content
    d3.select(svgRef.current).selectAll('*').remove();

    // Set up SVG canvas
    const svg = d3
      .select(svgRef.current)
      .attr('width', width)
      .attr('height', height)
      .style('position', 'relative');

    // Define margins
    const margin = { top: 20, right: 30, bottom: 30, left: 40 };
    const innerWidth = width - margin.left - margin.right;
    const innerHeight = height - margin.top - margin.bottom;

    // Create scales
    const x = d3
      .scaleBand()
      .domain(data.map((d) => d.manaCost))
      .range([0, innerWidth])
      .padding(0.1);

    const y = d3
      .scaleLinear()
      .domain([0, d3.max(data, (d) => d.count) || 10])
      .nice()
      .range([innerHeight, 0]);

    // Create a group element for margins
    const g = svg
      .append('g')
      .attr('transform', translate(${margin.left},${margin.top}));

    // Add X-axis
    g.append('g')
      .attr('transform', translate(0,${innerHeight}))
      .call(d3.axisBottom(x).tickFormat((d) => ${d}));

    // Add Y-axis
    g.append('g').call(d3.axisLeft(y));

    // Create bars
    g.selectAll('.bar')
      .data(data)
      .enter()
      .append('rect')
      .attr('class', 'bar')
      .attr('x', (d) => x(d.manaCost))
      .attr('y', (d) => y(d.count))
      .attr('width', x.bandwidth())
      .attr('height', (d) => innerHeight - y(d.count))
      .attr('fill', '#69b3a2')
      .on('mouseover', function (event, d) {
        d3.select(this).attr('fill', '#40a9f3');
        const [xPos, yPos] = d3.pointer(event, svg.node());
        setTooltipPosition({ x: xPos, y: yPos });
        setTooltipData(d);
      })
      .on('mousemove', function (event) {
        const [xPos, yPos] = d3.pointer(event, svg.node());
        setTooltipPosition({ x: xPos, y: yPos });
      })
      .on('mouseout', function () {
        d3.select(this).attr('fill', '#69b3a2');
        setTooltipData(null);
      });
  }, [data, width, height]);

  return (
    <div style={{ position: 'relative' }}>
      <svg ref={svgRef}></svg>
      <ManaCurveTooltip position={tooltipPosition} data={tooltipData} />
    </div>
  );
};

ManaCurve.propTypes = {
  data: PropTypes.arrayOf(
    PropTypes.shape({
      manaCost: PropTypes.number.isRequired,
      count: PropTypes.number.isRequired,
    })
  ).isRequired,
  width: PropTypes.number,
  height: PropTypes.number,
};

ManaCurve.defaultProps = {
  width: 500,
  height: 300,
};

export default ManaCurve;

// server.js

const express = require('express');
const http = require('http');
const socketIo = require('socket.io');
const { updateManaCurve } = require('./services/manaCurveService');

const app = express();
const server = http.createServer(app);
const io = socketIo(server, {
  cors: {
    origin: '*', // Adjust as needed for security
    methods: ['GET', 'POST'],
  },
});

// Middleware and routes setup...

io.on('connection', (socket) => {
  console.log('New client connected');

  // Join a room based on draft ID
  socket.on('joinDraft', (draftId) => {
    socket.join(draftId);
    console.log(Client joined draft room: ${draftId});
  });

  socket.on('disconnect', () => {
    console.log('Client disconnected');
  });
});

// Example endpoint for drafting a card
app.post('/api/drafts/:draftId/pick', async (req, res) => {
  const { draftId } = req.params;
  const { cardId } = req.body;

  try {
    // Logic to add the drafted card to the database...

    // Update and emit the mana curve
    await updateManaCurve(draftId);

    res.status(200).json({ message: 'Card drafted successfully.' });
  } catch (error) {
    console.error('Error drafting card:', error);
    res.status(500).json({ message: 'Failed to draft card.' });
  }
});

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

npm install socket.io-client

// src/App.jsx

import React, { useState, useEffect } from 'react';
import io from 'socket.io-client';
import ManaCurve from './components/ManaCurve';

const socket = io('http://localhost:5000'); // Adjust the URL as needed

const App = () => {
  const [manaCurveData, setManaCurveData] = useState([
    { manaCost: 1, count: 0 },
    { manaCost: 2, count: 0 },
    { manaCost: 3, count: 0 },
    { manaCost: 4, count: 0 },
    { manaCost: 5, count: 0 },
    { manaCost: 6, count: 0 },
    { manaCost: 7, count: 0 },
    { manaCost: 8, count: 0 },
    { manaCost: 9, count: 0 },
    { manaCost: 10, count: 0 },
    { manaCost: '10+', count: 0 },
  ]);

  const draftId = 'unique-draft-id'; // Replace with actual draft ID

  useEffect(() => {
    // Join the draft room
    socket.emit('joinDraft', draftId);

    // Listen for mana curve updates
    socket.on('manaCurveUpdate', (curve) => {
      const updatedData = Object.entries(curve).map(([manaCost, count]) => ({
        manaCost: isNaN(manaCost) ? manaCost : parseInt(manaCost, 10),
        count,
      }));
      setManaCurveData(updatedData);
    });

    // Cleanup on unmount
    return () => {
      socket.off('manaCurveUpdate');
    };
  }, [draftId]);

  return (
    <div>
      <h1>Draft Navigator Overlay</h1>
      <ManaCurve data={manaCurveData} width={600} height={400} />
    </div>
  );
};

export default App;

// src/components/ManaCurve.jsx

import React, { useRef, useEffect, useState } from 'react';
import * as d3 from 'd3';
import PropTypes from 'prop-types';
import './ManaCurve.css';
import ManaCurveTooltip from './ManaCurveTooltip';

const ManaCurve = ({ data, width, height, imbalanceThresholds }) => {
  const svgRef = useRef();
  const [tooltipData, setTooltipData] = useState(null);
  const [tooltipPosition, setTooltipPosition] = useState({ x: 0, y: 0 });

  useEffect(() => {
    // Clear previous SVG content
    d3.select(svgRef.current).selectAll('*').remove();

    // Set up SVG canvas
    const svg = d3
      .select(svgRef.current)
      .attr('width', width)
      .attr('height', height)
      .style('position', 'relative');

    // Define margins
    const margin = { top: 20, right: 30, bottom: 30, left: 40 };
    const innerWidth = width - margin.left - margin.right;
    const innerHeight = height - margin.top - margin.bottom;

    // Create scales
    const x = d3
      .scaleBand()
      .domain(data.map((d) => d.manaCost))
      .range([0, innerWidth])
      .padding(0.1);

    const y = d3
      .scaleLinear()
      .domain([0, d3.max(data, (d) => d.count) || 10])
      .nice()
      .range([innerHeight, 0]);

    // Create a group element for margins
    const g = svg
      .append('g')
      .attr('transform', translate(${margin.left},${margin.top}));

    // Add X-axis
    g.append('g')
      .attr('transform', translate(0,${innerHeight}))
      .call(d3.axisBottom(x).tickFormat((d) => ${d}));

    // Add Y-axis
    g.append('g').call(d3.axisLeft(y));

    // Define color function based on imbalance
    const colorFunction = (manaCost, count) => {
      const threshold = imbalanceThresholds[manaCost] || Infinity;
      return count > threshold ? '#ff4d4f' : '#69b3a2'; // Red for imbalance, green otherwise
    };

    // Create bars
    g.selectAll('.bar')
      .data(data)
      .enter()
      .append('rect')
      .attr('class', 'bar')
      .attr('x', (d) => x(d.manaCost))
      .attr('y', (d) => y(d.count))
      .attr('width', x.bandwidth())
      .attr('height', (d) => innerHeight - y(d.count))
      .attr('fill', (d) => colorFunction(d.manaCost, d.count))
      .on('mouseover', function (event, d) {
        d3.select(this).attr('fill', '#40a9f3');
        const [xPos, yPos] = d3.pointer(event, svg.node());
        setTooltipPosition({ x: xPos, y: yPos });
        setTooltipData(d);
      })
      .on('mousemove', function (event) {
        const [xPos, yPos] = d3.pointer(event, svg.node());
        setTooltipPosition({ x: xPos, y: yPos });
      })
      .on('mouseout', function () {
        // Reset color based on imbalance
        d3.select(this).attr('fill', (d) => colorFunction(d.manaCost, d.count));
        setTooltipData(null);
      });
  }, [data, width, height, imbalanceThresholds]);

  return (
    <div style={{ position: 'relative' }}>
      <svg ref={svgRef}></svg>
      <ManaCurveTooltip position={tooltipPosition} data={tooltipData} />
    </div>
  );
};

ManaCurve.propTypes = {
  data: PropTypes.arrayOf(
    PropTypes.shape({
      manaCost: PropTypes.oneOfType([PropTypes.number, PropTypes.string])
        .isRequired,
      count: PropTypes.number.isRequired,
    })
  ).isRequired,
  width: PropTypes.number,
  height: PropTypes.number,
  imbalanceThresholds: PropTypes.object, // { manaCost: threshold }
};

ManaCurve.defaultProps = {
  width: 600,
  height: 400,
  imbalanceThresholds: {
    1: 4,
    2: 6,
    3: 8,
    4: 5,
    5: 3,
    6: 2,
    7: 1,
    8: 1,
    9: 1,
    10: 1,
    '10+': 1,
  },
};

export default ManaCurve;

/* src/components/ManaCurve.css */

.bar {
  cursor: pointer;
}

.bar:hover {
  opacity: 0.8;
}

const imbalanceCriteria = {
  low: {
    manaCosts: [1, 2],
    maxCount: 4,
    suggestion: 'Consider adding more mid-cost cards (3-5).',
  },
  high: {
    manaCosts: [7, 8, 9, '10+'],
    maxCount: 2,
    suggestion: 'Consider reducing high-cost cards and adding more early plays.',
  },
  mid: {
    manaCosts: [3, 4, 5],
    minCount: 5,
    suggestion: 'Increase the number of mid-cost cards for better curve balance.',
  },
};

// src/components/ManaCurveFeedback.jsx

import React from 'react';
import PropTypes from 'prop-types';
import './ManaCurveFeedback.css'; // Import corresponding CSS

const ManaCurveFeedback = ({ data, imbalanceCriteria }) => {
  const feedback = [];

  // Check for low mana cost imbalance
  const lowManaCount = data
    .filter((d) => imbalanceCriteria.low.manaCosts.includes(d.manaCost))
    .reduce((acc, d) => acc + d.count, 0);

  if (lowManaCount > imbalanceCriteria.low.maxCount) {
    feedback.push({
      type: 'low',
      message: imbalanceCriteria.low.suggestion,
    });
  }

  // Check for high mana cost imbalance
  const highManaCount = data
    .filter((d) => imbalanceCriteria.high.manaCosts.includes(d.manaCost))
    .reduce((acc, d) => acc + d.count, 0);

  if (highManaCount > imbalanceCriteria.high.maxCount) {
    feedback.push({
      type: 'high',
      message: imbalanceCriteria.high.suggestion,
    });
  }

  // Check for mid mana cost balance
  const midManaCount = data
    .filter((d) => imbalanceCriteria.mid.manaCosts.includes(d.manaCost))
    .reduce((acc, d) => acc + d.count, 0);

  if (midManaCount < imbalanceCriteria.mid.minCount) {
    feedback.push({
      type: 'mid',
      message: imbalanceCriteria.mid.suggestion,
    });
  }

  if (feedback.length === 0) {
    return <div className="mana-curve-feedback success">Mana curve is well-balanced!</div>;
  }

  return (
    <div className="mana-curve-feedback">
      {feedback.map((item, index) => (
        <div key={index} className={feedback-item ${item.type}}>
          {item.message}
        </div>
      ))}
    </div>
  );
};

ManaCurveFeedback.propTypes = {
  data: PropTypes.arrayOf(
    PropTypes.shape({
      manaCost: PropTypes.oneOfType([PropTypes.number, PropTypes.string])
        .isRequired,
      count: PropTypes.number.isRequired,
    })
  ).isRequired,
  imbalanceCriteria: PropTypes.object.isRequired,
};

export default ManaCurveFeedback;

/* src/components/ManaCurveFeedback.css */

.mana-curve-feedback {
  margin-top: 20px;
  padding: 10px;
  border-radius: 5px;
}

.feedback-item {
  margin-bottom: 5px;
  padding: 8px;
  border-radius: 4px;
  color: #fff;
}

.feedback-item.low {
  background-color: #ff4d4f; /* Red */
}

.feedback-item.high {
  background-color: #ffa940; /* Orange */
}

.feedback-item.mid {
  background-color: #40a9ff; /* Blue */
}

.mana-curve-feedback.success {
  background-color: #52c41a; /* Green */
  color: #fff;
  padding: 10px;
  border-radius: 5px;
}

// src/App.jsx

import React, { useState, useEffect } from 'react';
import io from 'socket.io-client';
import ManaCurve from './components/ManaCurve';
import ManaCurveFeedback from './components/ManaCurveFeedback';

const socket = io('http://localhost:5000'); // Adjust the URL as needed

const imbalanceCriteria = {
  low: {
    manaCosts: [1, 2],
    maxCount: 4,
    suggestion: 'Consider adding more mid-cost cards (3-5).',
  },
  high: {
    manaCosts: [7, 8, 9, '10+'],
    maxCount: 2,
    suggestion: 'Consider reducing high-cost cards and adding more early plays.',
  },
  mid: {
    manaCosts: [3, 4, 5],
    minCount: 5,
    suggestion: 'Increase the number of mid-cost cards for better curve balance.',
  },
};

const App = () => {
  const [manaCurveData, setManaCurveData] = useState([
    { manaCost: 1, count: 0 },
    { manaCost: 2, count: 0 },
    { manaCost: 3, count: 0 },
    { manaCost: 4, count: 0 },
    { manaCost: 5, count: 0 },
    { manaCost: 6, count: 0 },
    { manaCost: 7, count: 0 },
    { manaCost: 8, count: 0 },
    { manaCost: 9, count: 0 },
    { manaCost: 10, count: 0 },
    { manaCost: '10+', count: 0 },
  ]);

  const draftId = 'unique-draft-id'; // Replace with actual draft ID

  useEffect(() => {
    // Join the draft room
    socket.emit('joinDraft', draftId);

    // Listen for mana curve updates
    socket.on('manaCurveUpdate', (curve) => {
      const updatedData = Object.entries(curve).map(([manaCost, count]) => ({
        manaCost: isNaN(manaCost) ? manaCost : parseInt(manaCost, 10),
        count,
      }));
      setManaCurveData(updatedData);
    });

    // Cleanup on unmount
    return () => {
      socket.off('manaCurveUpdate');
    };
  }, [draftId]);

  return (
    <div>
      <h1>Draft Navigator Overlay</h1>
      <ManaCurve data={manaCurveData} width={600} height={400} />
      <ManaCurveFeedback data={manaCurveData} imbalanceCriteria={imbalanceCriteria} />
    </div>
  );
};

export default App;

// src/components/ManaCurveFeedback.jsx

import React from 'react';
import PropTypes from 'prop-types';
import './ManaCurveFeedback.css';

const ManaCurveFeedback = ({ data, imbalanceCriteria }) => {
  const feedback = [];

  // Check for low mana cost imbalance
  const lowManaCount = data
    .filter((d) => imbalanceCriteria.low.manaCosts.includes(d.manaCost))
    .reduce((acc, d) => acc + d.count, 0);

  if (lowManaCount > imbalanceCriteria.low.maxCount) {
    feedback.push({
      type: 'low',
      message: imbalanceCriteria.low.suggestion,
    });
  }

  // Check for high mana cost imbalance
  const highManaCount = data
    .filter((d) => imbalanceCriteria.high.manaCosts.includes(d.manaCost))
    .reduce((acc, d) => acc + d.count, 0);

  if (highManaCount > imbalanceCriteria.high.maxCount) {
    feedback.push({
      type: 'high',
      message: imbalanceCriteria.high.suggestion,
    });
  }

  // Check for mid mana cost balance
  const midManaCount = data
    .filter((d) => imbalanceCriteria.mid.manaCosts.includes(d.manaCost))
    .reduce((acc, d) => acc + d.count, 0);

  if (midManaCount < imbalanceCriteria.mid.minCount) {
    feedback.push({
      type: 'mid',
      message: imbalanceCriteria.mid.suggestion,
    });
  }

  if (feedback.length === 0) {
    return <div className="mana-curve-feedback success">Mana curve is well-balanced!</div>;
  }

  return (
    <div className="mana-curve-feedback">
      {feedback.map((item, index) => (
        <div key={index} className={feedback-item ${item.type}}>
          {item.message}
        </div>
      ))}
    </div>
  );
};

ManaCurveFeedback.propTypes = {
  data: PropTypes.arrayOf(
    PropTypes.shape({
      manaCost: PropTypes.oneOfType([PropTypes.number, PropTypes.string])
        .isRequired,
      count: PropTypes.number.isRequired,
    })
  ).isRequired,
  imbalanceCriteria: PropTypes.object.isRequired,
};

export default ManaCurveFeedback;

// src/components/ManaCurve.jsx

// Inside the useEffect after creating bars

g.selectAll('.bar')
  .data(data)
  .enter()
  .append('rect')
  .attr('class', 'bar')
  .attr('x', (d) => x(d.manaCost))
  .attr('y', (d) => y(d.count))
  .attr('width', x.bandwidth())
  .attr('height', (d) => innerHeight - y(d.count))
  .attr('fill', (d) => colorFunction(d.manaCost, d.count))
  .attr('stroke', (d) => {
    if (
      (imbalanceThresholds.low.manaCosts.includes(d.manaCost) &&
        d.count > imbalanceThresholds.low.maxCount) ||
      (imbalanceThresholds.high.manaCosts.includes(d.manaCost) &&
        d.count > imbalanceThresholds.high.maxCount) ||
      (imbalanceThresholds.mid.manaCosts.includes(d.manaCost) &&
        d.count < imbalanceThresholds.mid.minCount)
    ) {
      return '#ff4d4f'; // Red border for imbalance
    }
    return 'none';
  })
  .attr('stroke-width', 2)
  .on('mouseover', function (event, d) {
    d3.select(this).attr('fill', '#40a9f3');
    const [xPos, yPos] = d3.pointer(event, svg.node());
    setTooltipPosition({ x: xPos, y: yPos });
    setTooltipData(d);
  })
  .on('mousemove', function (event) {
    const [xPos, yPos] = d3.pointer(event, svg.node());
    setTooltipPosition({ x: xPos, y: yPos });
  })
  .on('mouseout', function (d) {
    d3.select(this).attr('fill', colorFunction(d.manaCost, d.count));
    setTooltipData(null);
  });

// src/components/ManaCurveSettings.jsx

import React from 'react';
import PropTypes from 'prop-types';
import './ManaCurveSettings.css';

const ManaCurveSettings = ({
  settings,
  onChangeColorScheme,
  onChangeThresholds,
}) => {
  const handleColorChange = (e) => {
    onChangeColorScheme(e.target.value);
  };

  const handleThresholdChange = (manaCost, type, value) => {
    onChangeThresholds(manaCost, type, parseInt(value, 10));
  };

  return (
    <div className="mana-curve-settings">
      <h3>Mana Curve Settings</h3>
      <div className="setting-item">
        <label htmlFor="colorScheme">Color Scheme:</label>
        <select
          id="colorScheme"
          value={settings.colorScheme}
          onChange={handleColorChange}
        >
          <option value="default">Default</option>
          <option value="dark">Dark</option>
          <option value="light">Light</option>
          {/* Add more schemes as needed */}
        </select>
      </div>
      <div className="setting-item">
        <h4>Imbalance Thresholds:</h4>
        <div className="threshold-group">
          <h5>Low Mana Costs (1-2)</h5>
          <label>
            Max Count:
            <input
              type="number"
              min="0"
              value={settings.thresholds.low.maxCount}
              onChange={(e) =>
                handleThresholdChange(
                  'low',
                  'maxCount',
                  e.target.value
                )
              }
            />
          </label>
        </div>
        <div className="threshold-group">
          <h5>High Mana Costs (7-10+)</h5>
          <label>
            Max Count:
            <input
              type="number"
              min="0"
              value={settings.thresholds.high.maxCount}
              onChange={(e) =>
                handleThresholdChange(
                  'high',
                  'maxCount',
                  e.target.value
                )
              }
            />
          </label>
        </div>
        <div className="threshold-group">
          <h5>Mid Mana Costs (3-5)</h5>
          <label>
            Min Count:
            <input
              type="number"
              min="0"
              value={settings.thresholds.mid.minCount}
              onChange={(e) =>
                handleThresholdChange(
                  'mid',
                  'minCount',
                  e.target.value
                )
              }
            />
          </label>
        </div>
      </div>
    </div>
  );
};

ManaCurveSettings.propTypes = {
  settings: PropTypes.shape({
    colorScheme: PropTypes.string.isRequired,
    thresholds: PropTypes.shape({
      low: PropTypes.shape({
        maxCount: PropTypes.number.isRequired,
      }),
      high: PropTypes.shape({
        maxCount: PropTypes.number.isRequired,
      }),
      mid: PropTypes.shape({
        minCount: PropTypes.number.isRequired,
      }),
    }).isRequired,
  }).isRequired,
  onChangeColorScheme: PropTypes.func.isRequired,
  onChangeThresholds: PropTypes.func.isRequired,
};

export default ManaCurveSettings;

/* src/components/ManaCurveSettings.css */

.mana-curve-settings {
  border: 1px solid #ccc;
  padding: 15px;
  border-radius: 5px;
  margin-top: 20px;
}

.setting-item {
  margin-bottom: 15px;
}

.threshold-group {
  margin-left: 15px;
  margin-bottom: 10px;
}

.threshold-group label {
  display: block;
  margin-top: 5px;
}

.mana-curve-settings select,
.mana-curve-settings input {
  margin-left: 10px;
}

// src/App.jsx

import React, { useState, useEffect } from 'react';
import io from 'socket.io-client';
import ManaCurve from './components/ManaCurve';
import ManaCurveFeedback from './components/ManaCurveFeedback';
import ManaCurveSettings from './components/ManaCurveSettings';

const socket = io('http://localhost:5000'); // Adjust the URL as needed

const defaultSettings = {
  colorScheme: 'default',
  thresholds: {
    low: {
      manaCosts: [1, 2],
      maxCount: 4,
      suggestion: 'Consider adding more mid-cost cards (3-5).',
    },
    high: {
      manaCosts: [7, 8, 9, '10+'],
      maxCount: 2,
      suggestion: 'Consider reducing high-cost cards and adding more early plays.',
    },
    mid: {
      manaCosts: [3, 4, 5],
      minCount: 5,
      suggestion: 'Increase the number of mid-cost cards for better curve balance.',
    },
  },
};

const App = () => {
  const [manaCurveData, setManaCurveData] = useState([
    { manaCost: 1, count: 0 },
    { manaCost: 2, count: 0 },
    { manaCost: 3, count: 0 },
    { manaCost: 4, count: 0 },
    { manaCost: 5, count: 0 },
    { manaCost: 6, count: 0 },
    { manaCost: 7, count: 0 },
    { manaCost: 8, count: 0 },
    { manaCost: 9, count: 0 },
    { manaCost: 10, count: 0 },
    { manaCost: '10+', count: 0 },
  ]);

  const [settings, setSettings] = useState(defaultSettings);
  const draftId = 'unique-draft-id'; // Replace with actual draft ID

  useEffect(() => {
    // Join the draft room
    socket.emit('joinDraft', draftId);

    // Listen for mana curve updates
    socket.on('manaCurveUpdate', (curve) => {
      const updatedData = Object.entries(curve).map(([manaCost, count]) => ({
        manaCost: isNaN(manaCost) ? manaCost : parseInt(manaCost, 10),
        count,
      }));
      setManaCurveData(updatedData);
    });

    // Cleanup on unmount
    return () => {
      socket.off('manaCurveUpdate');
    };
  }, [draftId]);

  const handleColorSchemeChange = (newScheme) => {
    setSettings((prevSettings) => ({
      ...prevSettings,
      colorScheme: newScheme,
    }));
  };

  const handleThresholdChange = (type, key, value) => {
    setSettings((prevSettings) => ({
      ...prevSettings,
      thresholds: {
        ...prevSettings.thresholds,
        [type]: {
          ...prevSettings.thresholds[type],
          [key]: value,
        },
      },
    }));
  };

  return (
    <div>
      <h1>Draft Navigator Overlay</h1>
      <ManaCurve
        data={manaCurveData}
        width={600}
        height={400}
        imbalanceThresholds={settings.thresholds}
      />
      <ManaCurveFeedback data={manaCurveData} imbalanceCriteria={settings.thresholds} />
      <ManaCurveSettings
        settings={settings}
        onChangeColorScheme={handleColorSchemeChange}
        onChangeThresholds={handleThresholdChange}
      />
    </div>
  );
};

export default App;

// src/components/ManaCurve.jsx

const ManaCurve = ({ data, width, height, imbalanceThresholds, colorScheme }) => {
  const svgRef = useRef();
  const [tooltipData, setTooltipData] = useState(null);
  const [tooltipPosition, setTooltipPosition] = useState({ x: 0, y: 0 });

  // Define color schemes
  const colorSchemes = {
    default: {
      balanced: '#69b3a2',
      imbalanced: '#ff4d4f',
      hover: '#40a9f3',
    },
    dark: {
      balanced: '#1f77b4',
      imbalanced: '#d62728',
      hover: '#ff7f0e',
    },
    light: {
      balanced: '#2ca02c',
      imbalanced: '#9467bd',
      hover: '#ffbb78',
    },
    // Add more schemes as needed
  };

  const currentScheme = colorSchemes[colorScheme] || colorSchemes.default;

  useEffect(() => {
    // Clear previous SVG content
    d3.select(svgRef.current).selectAll('*').remove();

    // Set up SVG canvas
    const svg = d3
      .select(svgRef.current)
      .attr('width', width)
      .attr('height', height)
      .style('position', 'relative');

    // Define margins
    const margin = { top: 20, right: 30, bottom: 30, left: 40 };
    const innerWidth = width - margin.left - margin.right;
    const innerHeight = height - margin.top - margin.bottom;

    // Create scales
    const x = d3
      .scaleBand()
      .domain(data.map((d) => d.manaCost))
      .range([0, innerWidth])
      .padding(0.1);

    const y = d3
      .scaleLinear()
      .domain([0, d3.max(data, (d) => d.count) || 10])
      .nice()
      .range([innerHeight, 0]);

    // Create a group element for margins
    const g = svg
      .append('g')
      .attr('transform', translate(${margin.left},${margin.top}));

    // Add X-axis
    g.append('g')
      .attr('transform', translate(0,${innerHeight}))
      .call(d3.axisBottom(x).tickFormat((d) => ${d}));

    // Add Y-axis
    g.append('g').call(d3.axisLeft(y));

    // Define color function based on imbalance
    const colorFunction = (manaCost, count) => {
      const threshold = imbalanceThresholds[manaCost] || Infinity;
      return count > threshold
        ? currentScheme.imbalanced
        : currentScheme.balanced;
    };

    // Create bars
    g.selectAll('.bar')
      .data(data)
      .enter()
      .append('rect')
      .attr('class', 'bar')
      .attr('x', (d) => x(d.manaCost))
      .attr('y', (d) => y(d.count))
      .attr('width', x.bandwidth())
      .attr('height', (d) => innerHeight - y(d.count))
      .attr('fill', (d) => colorFunction(d.manaCost, d.count))
      .attr('stroke', (d) => {
        if (
          (imbalanceThresholds.low.manaCosts.includes(d.manaCost) &&
            d.count > imbalanceThresholds.low.maxCount) ||
          (imbalanceThresholds.high.manaCosts.includes(d.manaCost) &&
            d.count > imbalanceThresholds.high.maxCount) ||
          (imbalanceThresholds.mid.manaCosts.includes(d.manaCost) &&
            d.count < imbalanceThresholds.mid.minCount)
        ) {
          return currentScheme.imbalanced; // Red border for imbalance
        }
        return 'none';
      })
      .attr('stroke-width', 2)
      .on('mouseover', function (event, d) {
        d3.select(this).attr('fill', currentScheme.hover);
        const [xPos, yPos] = d3.pointer(event, svg.node());
        setTooltipPosition({ x: xPos, y: yPos });
        setTooltipData(d);
      })
      .on('mousemove', function (event) {
        const [xPos, yPos] = d3.pointer(event, svg.node());
        setTooltipPosition({ x: xPos, y: yPos });
      })
      .on('mouseout', function (d) {
        // Reset color based on imbalance
        d3.select(this).attr('fill', colorFunction(d.manaCost, d.count));
        setTooltipData(null);
      });
  }, [data, width, height, imbalanceThresholds, colorScheme, currentScheme]);

  return (
    <div style={{ position: 'relative' }}>
      <svg ref={svgRef}></svg>
      <ManaCurveTooltip position={tooltipPosition} data={tooltipData} />
    </div>
  );
};

ManaCurve.propTypes = {
  data: PropTypes.arrayOf(
    PropTypes.shape({
      manaCost: PropTypes.oneOfType([PropTypes.number, PropTypes.string])
        .isRequired,
      count: PropTypes.number.isRequired,
    })
  ).isRequired,
  width: PropTypes.number,
  height: PropTypes.number,
  imbalanceThresholds: PropTypes.object.isRequired,
  colorScheme: PropTypes.string.isRequired,
};

ManaCurve.defaultProps = {
  width: 600,
  height: 400,
  colorScheme: 'default',
};

export default ManaCurve;

{
  id: 'card-uuid-5',
  name: 'Sample Card',
  manaCost: 3,
  powerScore: 75,
  synergyScore: 80,
  // Additional metadata...
}

// services/recommendationService.js

const { getPowerLevel } = require('./powerLevelCalculator');
const { calculateManaCurve } = require('./manaCurveService');
const { Card } = require('../models');

/**
 * Generate card recommendations considering mana curve balance.
 * @param {string} draftId - The unique ID of the draft.
 * @returns {array} - List of recommended cards.
 */
async function generateRecommendations(draftId) {
  // Fetch current mana curve
  const manaCurve = await calculateManaCurve(draftId);

  // Define desired mana curve based on current state
  const desiredManaCurve = {
    1: 2,
    2: 4,
    3: 6,
    4: 4,
    5: 2,
    6: 1,
    7: 0,
    8: 0,
    9: 0,
    10: 0,
    '10+': 0,
  };

  // Fetch available cards (implement logic to fetch available cards)
  const availableCards = await Card.findAll({
    where: {
      // Conditions to fetch available cards
    },
  });

  // Fetch power levels for archetypes
  const powerLevels = {}; // Implement logic to fetch power levels

  // Adjust weights based on mana curve needs
  const adjustedRecommendations = availableCards.map((card) => {
    // Calculate power and synergy scores
    const powerScore = card.powerScore; // Assume precomputed
    const synergyScore = card.synergyScore; // Assume precomputed

    // Determine mana curve adjustment factor
    const currentCount = manaCurve[card.manaCost] || 0;
    const desiredCount = desiredManaCurve[card.manaCost] || 0;
    const curveFactor = desiredCount - currentCount; // Positive if more needed

    // Adjust weights dynamically
    const powerWeight = curveFactor > 0 ? 0.6 : 0.4;
    const synergyWeight = 1 - powerWeight;

    // Compute weighted score
    const weightedScore = powerScore * powerWeight + synergyScore * synergyWeight;

    return {
      id: card.id,
      name: card.name,
      manaCost: card.manaCost,
      powerScore,
      synergyScore,
      weightedScore,
      // Additional metadata...
    };
  });

  // Sort recommendations based on weighted score
  adjustedRecommendations.sort((a, b) => b.weightedScore - a.weightedScore);

  return adjustedRecommendations.slice(0, 10); // Top 10 recommendations
}

module.exports = {
  generateRecommendations,
};

// src/components/Recommendations.jsx

import React from 'react';
import PropTypes from 'prop-types';
import PowerSynergyBar from './PowerSynergyBar';
import './Recommendations.css';

const Recommendations = ({ recommendations }) => {
  return (
    <div className="recommendations-container">
      <h2>Recommended Cards</h2>
      <div className="recommendations-list">
        {recommendations.map((card) => (
          <div key={card.id} className="recommendation-card">
            <h3>{card.name}</h3>
            <p>Mana Cost: {card.manaCost}</p>
            <PowerSynergyBar
              power={card.powerScore}
              synergy={card.synergyScore}
            />
            <p>Weighted Score: {card.weightedScore.toFixed(2)}</p>
          </div>
        ))}
      </div>
    </div>
  );
};

Recommendations.propTypes = {
  recommendations: PropTypes.arrayOf(
    PropTypes.shape({
      id: PropTypes.string.isRequired,
      name: PropTypes.string.isRequired,
      manaCost: PropTypes.oneOfType([PropTypes.number, PropTypes.string])
        .isRequired,
      powerScore: PropTypes.number.isRequired,
      synergyScore: PropTypes.number.isRequired,
      weightedScore: PropTypes.number.isRequired,
    })
  ).isRequired,
};

export default Recommendations;

/* src/components/Recommendations.css */

.recommendations-container {
  margin-top: 30px;
}

.recommendations-list {
  display: flex;
  flex-wrap: wrap;
  gap: 20px;
}

.recommendation-card {
  border: 1px solid #ccc;
  padding: 15px;
  border-radius: 5px;
  width: 200px;
}

.recommendation-card h3 {
  margin-bottom: 10px;
}

.recommendation-card p {
  margin: 5px 0;
}

// src/App.jsx

import React, { useState, useEffect } from 'react';
import io from 'socket.io-client';
import ManaCurve from './components/ManaCurve';
import ManaCurveFeedback from './components/ManaCurveFeedback';
import ManaCurveSettings from './components/ManaCurveSettings';
import Recommendations from './components/Recommendations';

const socket = io('http://localhost:5000'); // Adjust the URL as needed

const imbalanceCriteria = {
  low: {
    manaCosts: [1, 2],
    maxCount: 4,
    suggestion: 'Consider adding more mid-cost cards (3-5).',
  },
  high: {
    manaCosts: [7, 8, 9, '10+'],
    maxCount: 2,
    suggestion: 'Consider reducing high-cost cards and adding more early plays.',
  },
  mid: {
    manaCosts: [3, 4, 5],
    minCount: 5,
    suggestion: 'Increase the number of mid-cost cards for better curve balance.',
  },
};

const App = () => {
  const [manaCurveData, setManaCurveData] = useState([
    { manaCost: 1, count: 0 },
    { manaCost: 2, count: 0 },
    { manaCost: 3, count: 0 },
    { manaCost: 4, count: 0 },
    { manaCost: 5, count: 0 },
    { manaCost: 6, count: 0 },
    { manaCost: 7, count: 0 },
    { manaCost: 8, count: 0 },
    { manaCost: 9, count: 0 },
    { manaCost: 10, count: 0 },
    { manaCost: '10+', count: 0 },
  ]);

  const [settings, setSettings] = useState({
    colorScheme: 'default',
    thresholds: {
      low: {
        manaCosts: [1, 2],
        maxCount: 4,
        suggestion: 'Consider adding more mid-cost cards (3-5).',
      },
      high: {
        manaCosts: [7, 8, 9, '10+'],
        maxCount: 2,
        suggestion: 'Consider reducing high-cost cards and adding more early plays.',
      },
      mid: {
        manaCosts: [3, 4, 5],
        minCount: 5,
        suggestion: 'Increase the number of mid-cost cards for better curve balance.',
      },
    },
  });

  const [recommendations, setRecommendations] = useState([]);
  const draftId = 'unique-draft-id'; // Replace with actual draft ID

  useEffect(() => {
    // Join the draft room
    socket.emit('joinDraft', draftId);

    // Listen for mana curve updates
    socket.on('manaCurveUpdate', async (curve) => {
      const updatedData = Object.entries(curve).map(([manaCost, count]) => ({
        manaCost: isNaN(manaCost) ? manaCost : parseInt(manaCost, 10),
        count,
      }));
      setManaCurveData(updatedData);

      // Fetch recommendations from backend
      try {
        const response = await fetch(/api/drafts/${draftId}/recommendations);
        const recommendationsData = await response.json();
        setRecommendations(recommendationsData);
      } catch (error) {
        console.error('Error fetching recommendations:', error);
      }
    });

    // Cleanup on unmount
    return () => {
      socket.off('manaCurveUpdate');
    };
  }, [draftId]);

  const handleColorSchemeChange = (newScheme) => {
    setSettings((prevSettings) => ({
      ...prevSettings,
      colorScheme: newScheme,
    }));
  };

  const handleThresholdChange = (type, key, value) => {
    setSettings((prevSettings) => ({
      ...prevSettings,
      thresholds: {
        ...prevSettings.thresholds,
        [type]: {
          ...prevSettings.thresholds[type],
          [key]: value,
        },
      },
    }));
  };

  return (
    <div>
      <h1>Draft Navigator Overlay</h1>
      <ManaCurve
        data={manaCurveData}
        width={600}
        height={400}
        imbalanceThresholds={settings.thresholds}
        colorScheme={settings.colorScheme}
      />
      <ManaCurveFeedback data={manaCurveData} imbalanceCriteria={settings.thresholds} />
      <ManaCurveSettings
        settings={settings}
        onChangeColorScheme={handleColorSchemeChange}
        onChangeThresholds={handleThresholdChange}
      />
      <Recommendations recommendations={recommendations} />
    </div>
  );
};

export default App;

// src/App.jsx

import React, { useState, useEffect } from 'react';
// ... other imports

const App = () => {
  const draftId = 'unique-draft-id'; // Replace with actual draft ID

  const [manaCurveData, setManaCurveData] = useState([
    { manaCost: 1, count: 0 },
    // ... other mana costs
  ]);

  const [settings, setSettings] = useState(() => {
    const savedSettings = localStorage.getItem('manaCurveSettings');
    return savedSettings
      ? JSON.parse(savedSettings)
      : {
          colorScheme: 'default',
          thresholds: {
            low: {
              manaCosts: [1, 2],
              maxCount: 4,
              suggestion: 'Consider adding more mid-cost cards (3-5).',
            },
            high: {
              manaCosts: [7, 8, 9, '10+'],
              maxCount: 2,
              suggestion: 'Consider reducing high-cost cards and adding more early plays.',
            },
            mid: {
              manaCosts: [3, 4, 5],
              minCount: 5,
              suggestion: 'Increase the number of mid-cost cards for better curve balance.',
            },
          },
        };
  });

  useEffect(() => {
    // Save settings to local storage whenever they change
    localStorage.setItem('manaCurveSettings', JSON.stringify(settings));
  }, [settings]);

  // ... rest of the component
};

// src/App.jsx

import React, { useState, useEffect } from 'react';
import io from 'socket.io-client';
import ManaCurve from './components/ManaCurve';
import ManaCurveFeedback from './components/ManaCurveFeedback';
import ManaCurveSettings from './components/ManaCurveSettings';
import Recommendations from './components/Recommendations';
import DeckAnalyzer from './components/DeckAnalyzer';

const socket = io('http://localhost:5000'); // Adjust the URL as needed

const imbalanceCriteria = {
  low: {
    manaCosts: [1, 2],
    maxCount: 4,
    suggestion: 'Consider adding more mid-cost cards (3-5).',
  },
  high: {
    manaCosts: [7, 8, 9, '10+'],
    maxCount: 2,
    suggestion: 'Consider reducing high-cost cards and adding more early plays.',
  },
  mid: {
    manaCosts: [3, 4, 5],
    minCount: 5,
    suggestion: 'Increase the number of mid-cost cards for better curve balance.',
  },
};

const App = () => {
  const [manaCurveData, setManaCurveData] = useState([
    { manaCost: 1, count: 0 },
    // ... other mana costs
  ]);

  const [settings, setSettings] = useState(() => {
    const savedSettings = localStorage.getItem('manaCurveSettings');
    return savedSettings
      ? JSON.parse(savedSettings)
      : {
          colorScheme: 'default',
          thresholds: {
            low: {
              manaCosts: [1, 2],
              maxCount: 4,
              suggestion: 'Consider adding more mid-cost cards (3-5).',
            },
            high: {
              manaCosts: [7, 8, 9, '10+'],
              maxCount: 2,
              suggestion: 'Consider reducing high-cost cards and adding more early plays.',
            },
            mid: {
              manaCosts: [3, 4, 5],
              minCount: 5,
              suggestion: 'Increase the number of mid-cost cards for better curve balance.',
            },
          },
        };
  });

  const [recommendations, setRecommendations] = useState([]);
  const [synergyData, setSynergyData] = useState({});
  const draftId = 'unique-draft-id'; // Replace with actual draft ID

  useEffect(() => {
    // Join the draft room
    socket.emit('joinDraft', draftId);

    // Listen for mana curve updates
    socket.on('manaCurveUpdate', async (curve) => {
      const updatedData = Object.entries(curve).map(([manaCost, count]) => ({
        manaCost: isNaN(manaCost) ? manaCost : parseInt(manaCost, 10),
        count,
      }));
      setManaCurveData(updatedData);

      // Fetch synergy data from backend
      try {
        const synergyResponse = await fetch(/api/drafts/${draftId}/synergy);
        const synergyData = await synergyResponse.json();
        setSynergyData(synergyData);
      } catch (error) {
        console.error('Error fetching synergy data:', error);
      }

      // Fetch recommendations from backend
      try {
        const recommendationResponse = await fetch(/api/drafts/${draftId}/recommendations);
        const recommendationsData = await recommendationResponse.json();
        setRecommendations(recommendationsData);
      } catch (error) {
        console.error('Error fetching recommendations:', error);
      }
    });

    // Cleanup on unmount
    return () => {
      socket.off('manaCurveUpdate');
    };
  }, [draftId]);

  const handleColorSchemeChange = (newScheme) => {
    setSettings((prevSettings) => ({
      ...prevSettings,
      colorScheme: newScheme,
    }));
  };

  const handleThresholdChange = (type, key, value) => {
    setSettings((prevSettings) => ({
      ...prevSettings,
      thresholds: {
        ...prevSettings.thresholds,
        [type]: {
          ...prevSettings.thresholds[type],
          [key]: value,
        },
      },
    }));
  };

  return (
    <div>
      <h1>Draft Navigator Overlay</h1>
      <ManaCurve
        data={manaCurveData}
        width={600}
        height={400}
        imbalanceThresholds={settings.thresholds}
        colorScheme={settings.colorScheme}
      />
      <ManaCurveFeedback data={manaCurveData} imbalanceCriteria={settings.thresholds} />
      <ManaCurveSettings
        settings={settings}
        onChangeColorScheme={handleColorSchemeChange}
        onChangeThresholds={handleThresholdChange}
      />
      <DeckAnalyzer manaCurveData={manaCurveData} synergyData={synergyData} />
      <Recommendations recommendations={recommendations} />
    </div>
  );
};

export default App;

// src/components/DeckAnalyzer.jsx

import React from 'react';
import PropTypes from 'prop-types';
import './DeckAnalyzer.css';

const DeckAnalyzer = ({ manaCurveData, synergyData }) => {
  // Example logic to analyze combined data
  // You can expand this based on your specific requirements

  const overallSynergy = synergyData.overallSynergy || 0;
  const synergyFeedback =
    overallSynergy > 80
      ? 'Excellent synergy!'
      : overallSynergy > 60
      ? 'Good synergy.'
      : overallSynergy > 40
      ? 'Average synergy.'
      : 'Consider improving synergy.';

  return (
    <div className="deck-analyzer">
      <h2>Deck Analyzer</h2>
      <div className="synergy-section">
        <h3>Synergy Score: {overallSynergy}</h3>
        <p>{synergyFeedback}</p>
      </div>
      <div className="mana-curve-section">
        <h3>Mana Curve Overview</h3>
        {/* Additional analysis or visualization can be added here */}
      </div>
    </div>
  );
};

DeckAnalyzer.propTypes = {
  manaCurveData: PropTypes.arrayOf(
    PropTypes.shape({
      manaCost: PropTypes.oneOfType([PropTypes.number, PropTypes.string])
        .isRequired,
      count: PropTypes.number.isRequired,
    })
  ).isRequired,
  synergyData: PropTypes.object.isRequired,
};

export default DeckAnalyzer;

/* src/components/DeckAnalyzer.css */

.deck-analyzer {
  margin-top: 30px;
  border: 1px solid #ccc;
  padding: 15px;
  border-radius: 5px;
}

.synergy-section,
.mana-curve-section {
  margin-bottom: 15px;
}

.synergy-section h3,
.mana-curve-section h3 {
  margin-bottom: 10px;
}

// services/recommendationService.js

/**
 * Generate card recommendations considering mana curve balance and synergy.
 * @param {string} draftId - The unique ID of the draft.
 * @returns {array} - List of recommended cards.
 */
async function generateRecommendations(draftId) {
  // Fetch current mana curve
  const manaCurve = await calculateManaCurve(draftId);

  // Define desired mana curve based on current state
  const desiredManaCurve = {
    1: 2,
    2: 4,
    3: 6,
    4: 4,
    5: 2,
    6: 1,
    7: 0,
    8: 0,
    9: 0,
    10: 0,
    '10+': 0,
  };

  // Fetch available cards
  const availableCards = await Card.findAll({
    where: {
      // Conditions to fetch available cards
    },
  });

  // Fetch synergy data
  const synergyData = await fetchSynergyData(draftId); // Implement this function

  // Adjust weights based on mana curve needs
  const adjustedRecommendations = availableCards.map((card) => {
    // Calculate power and synergy scores
    const powerScore = card.powerScore; // Assume precomputed
    const synergyScore = card.synergyScore; // Assume precomputed

    // Determine mana curve adjustment factor
    const currentCount = manaCurve[card.manaCost] || 0;
    const desiredCount = desiredManaCurve[card.manaCost] || 0;
    const curveFactor = desiredCount - currentCount; // Positive if more needed

    // Adjust weights dynamically
    const powerWeight = curveFactor > 0 ? 0.6 : 0.4;
    const synergyWeight = 1 - powerWeight;

    // Compute weighted score
    const weightedScore = powerScore * powerWeight + synergyScore * synergyWeight;

    return {
      id: card.id,
      name: card.name,
      manaCost: card.manaCost,
      powerScore,
      synergyScore,
      weightedScore,
      // Additional metadata...
    };
  });

  // Sort recommendations based on weighted score
  adjustedRecommendations.sort((a, b) => b.weightedScore - a.weightedScore);

  return adjustedRecommendations.slice(0, 10); // Top 10 recommendations
}

// routes/recommendations.js

const express = require('express');
const router = express.Router();
const { generateRecommendations } = require('../services/recommendationService');

/**
 * GET /api/drafts/:draftId/recommendations
 * Returns card recommendations considering mana curve and synergy.
 */
router.get('/drafts/:draftId/recommendations', async (req, res) => {
  const { draftId } = req.params;

  try {
    const recommendations = await generateRecommendations(draftId);
    res.status(200).json(recommendations);
  } catch (error) {
    console.error('Error generating recommendations:', error);
    res.status(500).json({ message: 'Failed to generate recommendations.' });
  }
});

module.exports = router;

// src/components/ManaCurveTooltip.jsx

import React from 'react';
import PropTypes from 'prop-types';
import './ManaCurveTooltip.css';

const ManaCurveTooltip = ({ position, data, synergyDetails }) => {
  if (!data) return null;

  const style = {
    left: position.x + 10,
    top: position.y + 10,
  };

  return (
    <div className="mana-curve-tooltip" style={style}>
      <strong>Mana Cost:</strong> {data.manaCost}
      <br />
      <strong>Count:</strong> {data.count}
      {synergyDetails && synergyDetails[data.manaCost] && (
        <>
          <br />
          <strong>Synergistic Cards:</strong>
          <ul>
            {synergyDetails[data.manaCost].map((card) => (
              <li key={card.id}>{card.name}</li>
            ))}
          </ul>
        </>
      )}
    </div>
  );
};

ManaCurveTooltip.propTypes = {
  position: PropTypes.shape({
    x: PropTypes.number,
    y: PropTypes.number,
  }).isRequired,
  data: PropTypes.shape({
    manaCost: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
    count: PropTypes.number,
  }),
  synergyDetails: PropTypes.object, // { manaCost: [{id, name}, ...] }
};

ManaCurveTooltip.defaultProps = {
  data: null,
  synergyDetails: null,
};

export default ManaCurveTooltip;

// src/components/ManaCurve.jsx

const ManaCurve = ({ data, width, height, imbalanceThresholds, colorScheme, synergyDetails }) => {
  // ... existing code

  // Update onHover to include synergy details
  g.selectAll('.bar')
    .data(data)
    .enter()
    .append('rect')
    // ... existing attributes
    .on('mouseover', function (event, d) {
      d3.select(this).attr('fill', currentScheme.hover);
      const [xPos, yPos] = d3.pointer(event, svg.node());
      setTooltipPosition({ x: xPos, y: yPos });
      setTooltipData(d);
    })
    .on('mousemove', function (event) {
      const [xPos, yPos] = d3.pointer(event, svg.node());
      setTooltipPosition({ x: xPos, y: yPos });
    })
    .on('mouseout', function (d) {
      // Reset color based on imbalance
      d3.select(this).attr('fill', colorFunction(d.manaCost, d.count));
      setTooltipData(null);
    });

  return (
    <div style={{ position: 'relative' }}>
      <svg ref={svgRef}></svg>
      <ManaCurveTooltip
        position={tooltipPosition}
        data={tooltipData}
        synergyDetails={synergyDetails}
      />
    </div>
  );
};

ManaCurve.propTypes = {
  // ... existing propTypes
  synergyDetails: PropTypes.object, // { manaCost: [{id, name}, ...] }
};

ManaCurve.defaultProps = {
  // ... existing defaultProps
  synergyDetails: null,
};

// src/App.jsx

// ... existing imports

const App = () => {
  // ... existing state

  const [synergyDetails, setSynergyDetails] = useState({});

  useEffect(() => {
    // Listen for mana curve updates
    socket.on('manaCurveUpdate', async (curve) => {
      const updatedData = Object.entries(curve).map(([manaCost, count]) => ({
        manaCost: isNaN(manaCost) ? manaCost : parseInt(manaCost, 10),
        count,
      }));
      setManaCurveData(updatedData);

      // Fetch synergy data from backend
      try {
        const synergyResponse = await fetch(/api/drafts/${draftId}/synergy);
        const synergyData = await synergyResponse.json();
        setSynergyDetails(synergyData.synergyDetails || {});
      } catch (error) {
        console.error('Error fetching synergy data:', error);
      }

      // Fetch recommendations from backend
      try {
        const recommendationResponse = await fetch(/api/drafts/${draftId}/recommendations);
        const recommendationsData = await recommendationResponse.json();
        setRecommendations(recommendationsData);
      } catch (error) {
        console.error('Error fetching recommendations:', error);
      }
    });

    // ... existing cleanup
  }, [draftId]);

  return (
    <div>
      <h1>Draft Navigator Overlay</h1>
      <ManaCurve
        data={manaCurveData}
        width={600}
        height={400}
        imbalanceThresholds={settings.thresholds}
        colorScheme={settings.colorScheme}
        synergyDetails={synergyDetails}
      />
      <ManaCurveFeedback data={manaCurveData} imbalanceCriteria={settings.thresholds} />
      <ManaCurveSettings
        settings={settings}
        onChangeColorScheme={handleColorSchemeChange}
        onChangeThresholds={handleThresholdChange}
      />
      <DeckAnalyzer manaCurveData={manaCurveData} synergyData={synergyData} />
      <Recommendations recommendations={recommendations} />
    </div>
  );
};

export default App;

   npm install chart.js react-chartjs-2
   

   // src/components/SynergyBar.jsx

   import React from 'react';
   import { Bar } from 'react-chartjs-2';
   import PropTypes from 'prop-types';
   import { Chart as ChartJS, CategoryScale, LinearScale, BarElement, Tooltip, Legend } from 'chart.js';
   import './SynergyBar.css'; // Optional: For additional styling

   ChartJS.register(CategoryScale, LinearScale, BarElement, Tooltip, Legend);

   const SynergyBar = ({ cards }) => {
     // Extract card names and their synergy scores
     const cardNames = cards.map((card) => card.name);
     const synergyScores = cards.map((card) => card.synergyScore);

     const data = {
       labels: cardNames,
       datasets: [
         {
           label: 'Synergy Score',
           data: synergyScores,
           backgroundColor: 'rgba(54, 162, 235, 0.6)',
           borderColor: 'rgba(54, 162, 235, 1)',
           borderWidth: 1,
         },
       ],
     };

     const options = {
       indexAxis: 'y', // Horizontal bars
       responsive: true,
       maintainAspectRatio: false,
       scales: {
         x: {
           beginAtZero: true,
           max: 100, // Assuming synergy scores are out of 100
         },
       },
       plugins: {
         legend: {
           display: false,
         },
         tooltip: {
           callbacks: {
             label: function (context) {
               return Synergy: ${context.parsed.x};
             },
           },
         },
       },
     };

     return (
       <div className="synergy-bar-container" style={{ height: ${cards.length * 40}px }}>
         <Bar data={data} options={options} />
       </div>
     );
   };

   SynergyBar.propTypes = {
     cards: PropTypes.arrayOf(
       PropTypes.shape({
         id: PropTypes.string.isRequired,
         name: PropTypes.string.isRequired,
         synergyScore: PropTypes.number.isRequired,
       })
     ).isRequired,
   };

   export default SynergyBar;
   

   /* src/components/SynergyBar.css */

   .synergy-bar-container {
     width: 100%;
     padding: 20px;
     background-color: #f9f9f9;
     border-radius: 8px;
     box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
   }
   

   // src/App.jsx

   import React, { useState, useEffect } from 'react';
   import SynergyBar from './components/SynergyBar';
   // ... other imports

   const App = () => {
     const [recommendations, setRecommendations] = useState([]);
     // ... other state variables

     useEffect(() => {
       // Fetch recommendations from backend
       const fetchRecommendations = async () => {
         try {
           const response = await fetch(/api/drafts/${draftId}/recommendations);
           const data = await response.json();
           setRecommendations(data);
         } catch (error) {
           console.error('Error fetching recommendations:', error);
         }
       };

       fetchRecommendations();
     }, [draftId]);

     return (
       <div>
         <h1>Draft Navigator Overlay</h1>
         {/* Other components */}
         <SynergyBar cards={recommendations} />
         {/* Other components */}
       </div>
     );
   };

   export default App;
   

   // src/components/ManaCurveVisualizer.jsx

   import React from 'react';
   import { Bar } from 'react-chartjs-2';
   import PropTypes from 'prop-types';
   import { Chart as ChartJS, CategoryScale, LinearScale, BarElement, Tooltip, Legend } from 'chart.js';
   import './ManaCurveVisualizer.css'; // Optional: For additional styling

   ChartJS.register(CategoryScale, LinearScale, BarElement, Tooltip, Legend);

   const ManaCurveVisualizer = ({ manaCurve, imbalanceThresholds }) => {
     const manaCosts = Object.keys(manaCurve).sort((a, b) => {
       if (a === '10+') return 11;
       if (b === '10+') return 11;
       return parseInt(a, 10) - parseInt(b, 10);
     });

     const counts = manaCosts.map((cost) => manaCurve[cost]);

     // Define colors based on imbalance thresholds
     const barColors = manaCosts.map((cost) => {
       const count = manaCurve[cost];
       const threshold = imbalanceThresholds[cost] || Infinity;
       return count > threshold ? 'rgba(255, 99, 132, 0.6)' : 'rgba(75, 192, 192, 0.6)';
     });

     const borderColors = manaCosts.map((cost) => {
       const count = manaCurve[cost];
       const threshold = imbalanceThresholds[cost] || Infinity;
       return count > threshold ? 'rgba(255, 99, 132, 1)' : 'rgba(75, 192, 192, 1)';
     });

     const data = {
       labels: manaCosts,
       datasets: [
         {
           label: 'Card Count',
           data: counts,
           backgroundColor: barColors,
           borderColor: borderColors,
           borderWidth: 1,
         },
       ],
     };

     const options = {
       responsive: true,
       maintainAspectRatio: false,
       scales: {
         y: {
           beginAtZero: true,
           ticks: {
             precision: 0,
           },
         },
       },
       plugins: {
         legend: {
           display: false,
         },
         tooltip: {
           callbacks: {
             label: function (context) {
               const cost = context.label;
               const count = context.parsed.y;
               return Mana Cost ${cost}: ${count} card(s);
             },
           },
         },
       },
     };

     return (
       <div className="mana-curve-visualizer" style={{ height: '400px' }}>
         <Bar data={data} options={options} />
       </div>
     );
   };

   ManaCurveVisualizer.propTypes = {
     manaCurve: PropTypes.object.isRequired, // { '1': 3, '2': 5, ..., '10+': 0 }
     imbalanceThresholds: PropTypes.object.isRequired, // { '1': 4, '2': 6, ..., '10+': 1 }
   };

   export default ManaCurveVisualizer;
   

   /* src/components/ManaCurveVisualizer.css */

   .mana-curve-visualizer {
     width: 100%;
     padding: 20px;
     background-color: #f0f0f0;
     border-radius: 8px;
     box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
   }
   

   // src/App.jsx

   import React, { useState, useEffect } from 'react';
   import ManaCurveVisualizer from './components/ManaCurveVisualizer';
   // ... other imports

   const App = () => {
     const [manaCurve, setManaCurve] = useState({
       '1': 0,
       '2': 0,
       '3': 0,
       '4': 0,
       '5': 0,
       '6': 0,
       '7': 0,
       '8': 0,
       '9': 0,
       '10': 0,
       '10+': 0,
     });
     const [imbalanceThresholds, setImbalanceThresholds] = useState({
       '1': 4,
       '2': 6,
       '3': 8,
       '4': 5,
       '5': 3,
       '6': 2,
       '7': 1,
       '8': 1,
       '9': 1,
       '10': 1,
       '10+': 1,
     });

     useEffect(() => {
       // Fetch or listen for mana curve updates
       const fetchManaCurve = async () => {
         try {
           const response = await fetch(/api/drafts/${draftId}/mana-curve);
           const data = await response.json();
           setManaCurve(data.curve);
         } catch (error) {
           console.error('Error fetching mana curve:', error);
         }
       };

       fetchManaCurve();

       // Optionally, set up WebSocket listeners for real-time updates
     }, [draftId]);

     return (
       <div>
         <h1>Draft Navigator Overlay</h1>
         <ManaCurveVisualizer manaCurve={manaCurve} imbalanceThresholds={imbalanceThresholds} />
         {/* Other components */}
       </div>
     );
   };

   export default App;
   

   // src/components/PowerSynergyComparison.jsx

   import React from 'react';
   import { Radar } from 'react-chartjs-2';
   import PropTypes from 'prop-types';
   import { Chart as ChartJS, RadialLinearScale, PointElement, LineElement, Filler, Tooltip, Legend } from 'chart.js';
   import './PowerSynergyComparison.css'; // Optional: For additional styling

   ChartJS.register(RadialLinearScale, PointElement, LineElement, Filler, Tooltip, Legend);

   const PowerSynergyComparison = ({ cards }) => {
     // Prepare data for Radar Chart
     const labels = ['Power', 'Synergy'];
     const datasets = cards.map((card, index) => ({
       label: card.name,
       data: [card.powerScore, card.synergyScore],
       backgroundColor: rgba(255, 99, 132, 0.${(index + 1) * 2}),
       borderColor: 'rgba(255, 99, 132, 1)',
       borderWidth: 1,
     }));

     const data = {
       labels,
       datasets,
     };

     const options = {
       responsive: true,
       maintainAspectRatio: false,
       scales: {
         r: {
           beginAtZero: true,
           max: 100, // Assuming scores are out of 100
         },
       },
       plugins: {
         legend: {
           position: 'top',
         },
         tooltip: {
           callbacks: {
             label: function (context) {
               return ${context.label}: ${context.parsed.r};
             },
           },
         },
       },
     };

     return (
       <div className="power-synergy-comparison" style={{ height: '400px', width: '600px' }}>
         <Radar data={data} options={options} />
       </div>
     );
   };

   PowerSynergyComparison.propTypes = {
     cards: PropTypes.arrayOf(
       PropTypes.shape({
         id: PropTypes.string.isRequired,
         name: PropTypes.string.isRequired,
         powerScore: PropTypes.number.isRequired,
         synergyScore: PropTypes.number.isRequired,
       })
     ).isRequired,
   };

   export default PowerSynergyComparison;
   

   /* src/components/PowerSynergyComparison.css */

   .power-synergy-comparison {
     width: 100%;
     padding: 20px;
     background-color: #fff;
     border-radius: 8px;
     box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
   }
   

   // src/App.jsx

   import React, { useState, useEffect } from 'react';
   import PowerSynergyComparison from './components/PowerSynergyComparison';
   // ... other imports

   const App = () => {
     const [recommendations, setRecommendations] = useState([]);
     // ... other state variables

     useEffect(() => {
       // Fetch recommendations from backend
       const fetchRecommendations = async () => {
         try {
           const response = await fetch(/api/drafts/${draftId}/recommendations);
           const data = await response.json();
           setRecommendations(data);
         } catch (error) {
           console.error('Error fetching recommendations:', error);
         }
       };

       fetchRecommendations();
     }, [draftId]);

     return (
       <div>
         <h1>Draft Navigator Overlay</h1>
         {/* Other components */}
         <PowerSynergyComparison cards={recommendations} />
         {/* Other components */}
       </div>
     );
   };

   export default App;
   

   npm install react-toastify
   

   // src/index.jsx

   import React from 'react';
   import ReactDOM from 'react-dom';
   import App from './App';
   import { ToastContainer } from 'react-toastify';
   import 'react-toastify/dist/ReactToastify.css';

   ReactDOM.render(
     <React.StrictMode>
       <App />
       <ToastContainer
         position="top-right"
         autoClose={5000}
         hideProgressBar={false}
         newestOnTop={false}
         closeOnClick
         rtl={false}
         pauseOnFocusLoss
         draggable
         pauseOnHover
       />
     </React.StrictMode>,
     document.getElementById('root')
   );
   

   // src/services/PivotAlertService.js

   import { toast } from 'react-toastify';

   /**
    * Displays a pivot alert notification.
    * @param {string} message - The alert message.
    * @param {string} type - The type of alert ('info', 'warning', 'error', etc.).
    */
   export const showPivotAlert = (message, type = 'info') => {
     toast[type](message, {
       position: 'top-right',
       autoClose: 8000,
       hideProgressBar: false,
       closeOnClick: true,
       pauseOnHover: true,
       draggable: true,
       progress: undefined,
     });
   };
   

   // src/components/DeckAnalyzer.jsx

   import React, { useEffect } from 'react';
   import PropTypes from 'prop-types';
   import './DeckAnalyzer.css';
   import { showPivotAlert } from '../services/PivotAlertService';

   const DeckAnalyzer = ({ manaCurveData, synergyData }) => {
     useEffect(() => {
       // Example logic to determine if a pivot is needed
       const { overallSynergy, recommendedPivot } = synergyData;

       if (recommendedPivot) {
         const message = Consider pivoting to a ${recommendedPivot.color} ${recommendedPivot.archetype} deck for better performance!;
         showPivotAlert(message, 'warning');
       }
     }, [synergyData]);

     const overallSynergy = synergyData.overallSynergy || 0;
     const synergyFeedback =
       overallSynergy > 80
         ? 'Excellent synergy!'
         : overallSynergy > 60
         ? 'Good synergy.'
         : overallSynergy > 40
         ? 'Average synergy.'
         : 'Consider improving synergy.';

     return (
       <div className="deck-analyzer">
         <h2>Deck Analyzer</h2>
         <div className="synergy-section">
           <h3>Synergy Score: {overallSynergy}</h3>
           <p>{synergyFeedback}</p>
         </div>
         <div className="mana-curve-section">
           <h3>Mana Curve Overview</h3>
           {/* Additional analysis or visualization can be added here */}
         </div>
       </div>
     );
   };

   DeckAnalyzer.propTypes = {
     manaCurveData: PropTypes.arrayOf(
       PropTypes.shape({
         manaCost: PropTypes.oneOfType([PropTypes.number, PropTypes.string])
           .isRequired,
         count: PropTypes.number.isRequired,
       })
     ).isRequired,
     synergyData: PropTypes.object.isRequired,
   };

   export default DeckAnalyzer;
   

   /* src/App.css */

   /* Optional: Customize react-toastify styles */
   .Toastify__toast--warning {
     background: #ffcc00;
     color: #000;
   }
   

   npm install react-bootstrap bootstrap
   

   // src/index.jsx

   import React from 'react';
   import ReactDOM from 'react-dom';
   import App from './App';
   import 'bootstrap/dist/css/bootstrap.min.css'; // Import Bootstrap CSS
   import { ToastContainer } from 'react-toastify';
   import 'react-toastify/dist/ReactToastify.css';

   ReactDOM.render(
     <React.StrictMode>
       <App />
       <ToastContainer
         position="top-right"
         autoClose={5000}
         hideProgressBar={false}
         newestOnTop={false}
         closeOnClick
         rtl={false}
         pauseOnFocusLoss
         draggable
         pauseOnHover
       />
     </React.StrictMode>,
     document.getElementById('root')
   );
   

   // src/components/PostPickFeedback.jsx

   import React, { useEffect, useState } from 'react';
   import { Alert } from 'react-bootstrap';
   import PropTypes from 'prop-types';
   import './PostPickFeedback.css'; // Optional: For additional styling

   const PostPickFeedback = ({ lastPickedCard, synergyImpact, manaCurveImpact, powerImpact }) => {
     const [show, setShow] = useState(false);

     useEffect(() => {
       if (lastPickedCard) {
         setShow(true);
         // Auto-hide after 5 seconds
         const timer = setTimeout(() => setShow(false), 5000);
         return () => clearTimeout(timer);
       }
     }, [lastPickedCard]);

     if (!lastPickedCard) return null;

     return (
       <div className="post-pick-feedback">
         <Alert variant="info" show={show} onClose={() => setShow(false)} dismissible>
           <Alert.Heading>Card Picked: {lastPickedCard.name}</Alert.Heading>
           <p><strong>Synergy Impact:</strong> {synergyImpact}</p>
           <p><strong>Mana Curve Impact:</strong> {manaCurveImpact}</p>
           <p><strong>Power Impact:</strong> {powerImpact}</p>
         </Alert>
       </div>
     );
   };

   PostPickFeedback.propTypes = {
     lastPickedCard: PropTypes.shape({
       id: PropTypes.string.isRequired,
       name: PropTypes.string.isRequired,
     }),
     synergyImpact: PropTypes.string,
     manaCurveImpact: PropTypes.string,
     powerImpact: PropTypes.string,
   };

   PostPickFeedback.defaultProps = {
     lastPickedCard: null,
     synergyImpact: '',
     manaCurveImpact: '',
     powerImpact: '',
   };

   export default PostPickFeedback;
   

   /* src/components/PostPickFeedback.css */

   .post-pick-feedback {
     position: fixed;
     bottom: 20px;
     right: 20px;
     z-index: 1000;
   }
   

   // src/App.jsx

   import React, { useState, useEffect } from 'react';
   import PostPickFeedback from './components/PostPickFeedback';
   // ... other imports

   const App = () => {
     const [lastPickedCard, setLastPickedCard] = useState(null);
     const [synergyImpact, setSynergyImpact] = useState('');
     const [manaCurveImpact, setManaCurveImpact] = useState('');
     const [powerImpact, setPowerImpact] = useState('');
     // ... other state variables

     useEffect(() => {
       // Listen for card pick events via WebSockets or API
       socket.on('cardPicked', (cardData) => {
         setLastPickedCard(cardData.card);
         setSynergyImpact(cardData.synergyImpact);
         setManaCurveImpact(cardData.manaCurveImpact);
         setPowerImpact(cardData.powerImpact);
       });

       // Cleanup on unmount
       return () => {
         socket.off('cardPicked');
       };
     }, []);

     return (
       <div>
         <h1>Draft Navigator Overlay</h1>
         {/* Other components */}
         <PostPickFeedback
           lastPickedCard={lastPickedCard}
           synergyImpact={synergyImpact}
           manaCurveImpact={manaCurveImpact}
           powerImpact={powerImpact}
         />
         {/* Other components */}
       </div>
     );
   };

   export default App;
   

   // server.js

   const express = require('express');
   const http = require('http');
   const socketIo = require('socket.io');
   const { emitCardPicked } = require('./services/cardPickService'); // Implement this service

   const app = express();
   const server = http.createServer(app);
   const io = socketIo(server, {
     cors: {
       origin: '*', // Adjust as needed for security
       methods: ['GET', 'POST'],
     },
   });

   // Middleware and routes setup...

   io.on('connection', (socket) => {
     console.log('New client connected');

     // Join a room based on draft ID
     socket.on('joinDraft', (draftId) => {
       socket.join(draftId);
       console.log(Client joined draft room: ${draftId});
     });

     socket.on('disconnect', () => {
       console.log('Client disconnected');
     });
   });

   // Example endpoint for drafting a card
   app.post('/api/drafts/:draftId/pick', async (req, res) => {
     const { draftId } = req.params;
     const { cardId } = req.body;

     try {
       // Logic to add the drafted card to the database...

       // Calculate impacts
       const impacts = await calculateImpacts(draftId, cardId); // Implement this function

       // Emit cardPicked event to the draft room
       io.to(draftId).emit('cardPicked', {
         card: {
           id: cardId,
           name: 'Sample Card Name', // Replace with actual card name
         },
         synergyImpact: impacts.synergy,
         manaCurveImpact: impacts.manaCurve,
         powerImpact: impacts.power,
       });

       res.status(200).json({ message: 'Card drafted successfully.' });
     } catch (error) {
       console.error('Error drafting card:', error);
       res.status(500).json({ message: 'Failed to draft card.' });
     }
   });

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

   npm install react-toastify
   

   // src/index.jsx

   import React from 'react';
   import ReactDOM from 'react-dom';
   import App from './App';
   import { ToastContainer } from 'react-toastify';
   import 'react-toastify/dist/ReactToastify.css';

   ReactDOM.render(
     <React.StrictMode>
       <App />
       <ToastContainer
         position="top-right"
         autoClose={8000}
         hideProgressBar={false}
         newestOnTop={false}
         closeOnClick
         rtl={false}
         pauseOnFocusLoss
         draggable
         pauseOnHover
       />
     </React.StrictMode>,
     document.getElementById('root')
   );
   

   // src/services/PivotAlertService.js

   import { toast } from 'react-toastify';

   /**
    * Displays a pivot alert notification.
    * @param {string} message - The alert message.
    * @param {string} type - The type of alert ('info', 'warning', 'error', etc.).
    */
   export const showPivotAlert = (message, type = 'warning') => {
     toast[type](message, {
       position: 'top-right',
       autoClose: 10000,
       hideProgressBar: false,
       closeOnClick: true,
       pauseOnHover: true,
       draggable: true,
       progress: undefined,
     });
   };
   

   // src/components/DeckAnalyzer.jsx

   import React, { useEffect } from 'react';
   import PropTypes from 'prop-types';
   import './DeckAnalyzer.css';
   import { showPivotAlert } from '../services/PivotAlertService';

   const DeckAnalyzer = ({ manaCurveData, synergyData }) => {
     useEffect(() => {
       // Example logic to determine if a pivot is needed
       const { overallSynergy, recommendedPivot } = synergyData;

       if (recommendedPivot) {
         const message = 🔄 Consider pivoting to a ${recommendedPivot.color} ${recommendedPivot.archetype} deck for better performance!;
         showPivotAlert(message, 'warning');
       }
     }, [synergyData]);

     const overallSynergy = synergyData.overallSynergy || 0;
     const synergyFeedback =
       overallSynergy > 80
         ? 'Excellent synergy!'
         : overallSynergy > 60
         ? 'Good synergy.'
         : overallSynergy > 40
         ? 'Average synergy.'
         : 'Consider improving synergy.';

     return (
       <div className="deck-analyzer">
         <h2>Deck Analyzer</h2>
         <div className="synergy-section">
           <h3>Synergy Score: {overallSynergy}</h3>
           <p>{synergyFeedback}</p>
         </div>
         <div className="mana-curve-section">
           <h3>Mana Curve Overview</h3>
           {/* Additional analysis or visualization can be added here */}
         </div>
       </div>
     );
   };

   DeckAnalyzer.propTypes = {
     manaCurveData: PropTypes.arrayOf(
       PropTypes.shape({
         manaCost: PropTypes.oneOfType([PropTypes.number, PropTypes.string])
           .isRequired,
         count: PropTypes.number.isRequired,
       })
     ).isRequired,
     synergyData: PropTypes.object.isRequired,
   };

   export default DeckAnalyzer;
   

   /* src/App.css */

   .Toastify__toast--warning {
     background: #ffc107;
     color: #000;
     font-weight: bold;
   }
   

   // src/components/PostPickFeedback.jsx

   import React, { useState, useEffect } from 'react';
   import { Modal, Button } from 'react-bootstrap';
   import PropTypes from 'prop-types';
   import './PostPickFeedback.css'; // Optional: For additional styling

   const PostPickFeedback = ({ lastPickedCard, synergyImpact, manaCurveImpact, powerImpact }) => {
     const [show, setShow] = useState(false);

     useEffect(() => {
       if (lastPickedCard) {
         setShow(true);
       }
     }, [lastPickedCard]);

     const handleClose = () => setShow(false);

     if (!lastPickedCard) return null;

     return (
       <Modal show={show} onHide={handleClose} centered>
         <Modal.Header closeButton>
           <Modal.Title>Card Picked: {lastPickedCard.name}</Modal.Title>
         </Modal.Header>
         <Modal.Body>
           <p><strong>Synergy Impact:</strong> {synergyImpact}</p>
           <p><strong>Mana Curve Impact:</strong> {manaCurveImpact}</p>
           <p><strong>Power Impact:</strong> {powerImpact}</p>
         </Modal.Body>
         <Modal.Footer>
           <Button variant="secondary" onClick={handleClose}>
             Close
           </Button>
         </Modal.Footer>
       </Modal>
     );
   };

   PostPickFeedback.propTypes = {
     lastPickedCard: PropTypes.shape({
       id: PropTypes.string.isRequired,
       name: PropTypes.string.isRequired,
     }),
     synergyImpact: PropTypes.string,
     manaCurveImpact: PropTypes.string,
     powerImpact: PropTypes.string,
   };

   PostPickFeedback.defaultProps = {
     lastPickedCard: null,
     synergyImpact: '',
     manaCurveImpact: '',
     powerImpact: '',
   };

   export default PostPickFeedback;
   

   /* src/components/PostPickFeedback.css */

   .modal-body p {
     margin-bottom: 10px;
     font-size: 16px;
   }

   .modal-title {
     font-weight: bold;
   }
   

   // src/App.jsx

   import React, { useState, useEffect } from 'react';
   import PostPickFeedback from './components/PostPickFeedback';
   // ... other imports

   const App = () => {
     const [lastPickedCard, setLastPickedCard] = useState(null);
     const [synergyImpact, setSynergyImpact] = useState('');
     const [manaCurveImpact, setManaCurveImpact] = useState('');
     const [powerImpact, setPowerImpact] = useState('');
     // ... other state variables

     useEffect(() => {
       // Listen for card pick events via WebSockets or API
       socket.on('cardPicked', (cardData) => {
         setLastPickedCard(cardData.card);
         setSynergyImpact(cardData.synergyImpact);
         setManaCurveImpact(cardData.manaCurveImpact);
         setPowerImpact(cardData.powerImpact);
       });

       // Cleanup on unmount
       return () => {
         socket.off('cardPicked');
       };
     }, []);

     return (
       <div>
         <h1>Draft Navigator Overlay</h1>
         {/* Other components */}
         <PostPickFeedback
           lastPickedCard={lastPickedCard}
           synergyImpact={synergyImpact}
           manaCurveImpact={manaCurveImpact}
           powerImpact={powerImpact}
         />
         {/* Other components */}
       </div>
     );
   };

   export default App;
   

   // server.js

   // ... existing imports and setup

   // Example endpoint for drafting a card
   app.post('/api/drafts/:draftId/pick', async (req, res) => {
     const { draftId } = req.params;
     const { cardId } = req.body;

     try {
       // Logic to add the drafted card to the database...

       // Calculate impacts
       const impacts = await calculateImpacts(draftId, cardId); // Implement this function

       // Emit cardPicked event to the draft room
       io.to(draftId).emit('cardPicked', {
         card: {
           id: cardId,
           name: 'Sample Card Name', // Replace with actual card name
         },
         synergyImpact: impacts.synergy,
         manaCurveImpact: impacts.manaCurve,
         powerImpact: impacts.power,
       });

       res.status(200).json({ message: 'Card drafted successfully.' });
     } catch (error) {
       console.error('Error drafting card:', error);
       res.status(500).json({ message: 'Failed to draft card.' });
     }
   });
   

// services/powerLevelCalculator.js

/**
 * Calculates the power score for a given card.
 * @param {object} card - The card object containing relevant attributes.
 * @returns {number} - The calculated power score.
 */
function calculatePowerScore(card) {
  const { power, toughness, abilities, manaCost, rarity } = card;

  // Define weights
  const POWER_WEIGHT = 2;
  const TOUGHNESS_WEIGHT = 1.5;
  const ABILITY_WEIGHT = 3;
  const MANA_EFFICIENCY_WEIGHT = 2;
  const RARITY_MODIFIER = {
    common: 0,
    uncommon: 10,
    rare: 20,
    mythic: 30,
  };

  // Calculate ability score (example: number of abilities * 5)
  const abilityScore = abilities.length * 5;

  // Calculate mana efficiency (example: impact score / mana cost)
  const impactScore = power * 1.5 + toughness * 1 + abilityScore;
  const manaEfficiency = impactScore / manaCost;

  // Calculate total power score
  const powerScore =
    power * POWER_WEIGHT +
    toughness * TOUGHNESS_WEIGHT +
    abilityScore * ABILITY_WEIGHT +
    manaEfficiency * MANA_EFFICIENCY_WEIGHT +
    (RARITY_MODIFIER[rarity.toLowerCase()] || 0);

  // Normalize to a scale of 0-100
  const normalizedPowerScore = Math.min(powerScore, 100);

  return normalizedPowerScore;
}

module.exports = {
  calculatePowerScore,
};

// services/synergyCalculator.js

/**
 * Calculates the synergy score between two cards.
 * @param {object} cardA - First card object.
 * @param {object} cardB - Second card object.
 * @returns {number} - Synergy score between 0 and 100.
 */
function calculatePairwiseSynergy(cardA, cardB) {
  let synergy = 0;

  // Example: Tribal Synergy
  if (cardA.type === cardB.type && cardA.subtype === cardB.subtype) {
    synergy += 20;
  }

  // Example: Shared Abilities
  const sharedAbilities = cardA.abilities.filter((ability) =>
    cardB.abilities.includes(ability)
  );
  synergy += sharedAbilities.length * 10;

  // Example: Combo Potential
  if (
    (cardA.name === 'Card A' && cardB.name === 'Card B') ||
    (cardA.name === 'Card B' && cardB.name === 'Card A')
  ) {
    synergy += 30;
  }

  // Ensure synergy does not exceed 100
  return Math.min(synergy, 100);
}

/**
 * Calculates the total synergy score for a deck.
 * @param {array} deck - Array of card objects in the deck.
 * @returns {object} - An object mapping each card to its synergy score.
 */
function calculateDeckSynergy(deck) {
  const synergyScores = {};

  deck.forEach((card, index) => {
    let totalSynergy = 0;

    deck.forEach((otherCard, otherIndex) => {
      if (index !== otherIndex) {
        totalSynergy += calculatePairwiseSynergy(card, otherCard);
      }
    });

    // Average synergy score for the card
    const averageSynergy = deck.length > 1 ? totalSynergy / (deck.length - 1) : 0;
    synergyScores[card.id] = Math.min(averageSynergy, 100);
  });

  return synergyScores;
}

module.exports = {
  calculateDeckSynergy,
};

// server.js

const express = require('express');
const http = require('http');
const socketIo = require('socket.io');
const { calculatePowerScore } = require('./services/powerLevelCalculator');
const { calculateDeckSynergy } = require('./services/synergyCalculator');

const app = express();
const server = http.createServer(app);
const io = socketIo(server, {
  cors: {
    origin: '*', // Adjust as needed
    methods: ['GET', 'POST'],
  },
});

// Middleware and routes setup...

io.on('connection', (socket) => {
  console.log('New client connected');

  // Join a draft room
  socket.on('joinDraft', (draftId) => {
    socket.join(draftId);
    console.log(Client joined draft room: ${draftId});
  });

  socket.on('disconnect', () => {
    console.log('Client disconnected');
  });
});

// Endpoint for picking a card
app.post('/api/drafts/:draftId/pick', async (req, res) => {
  const { draftId } = req.params;
  const { cardId } = req.body;

  try {
    // Fetch card data from the database
    const card = await Card.findById(cardId);
    if (!card) {
      return res.status(404).json({ message: 'Card not found.' });
    }

    // Add card to the deck
    await Deck.addCard(draftId, cardId);

    // Fetch updated deck
    const deck = await Deck.getDeck(draftId);

    // Calculate power scores
    const powerScores = deck.cards.map((deckCard) => ({
      id: deckCard.id,
      name: deckCard.name,
      powerScore: calculatePowerScore(deckCard),
    }));

    // Calculate synergy scores
    const synergyScores = calculateDeckSynergy(deck.cards);

    // Emit updates to frontend
    io.to(draftId).emit('deckUpdate', {
      powerScores,
      synergyScores,
    });

    // Optionally, generate recommendations based on updated metrics
    const recommendations = await RecommendationService.generateRecommendations(draftId);
    io.to(draftId).emit('recommendationsUpdate', { recommendations });

    res.status(200).json({ message: 'Card drafted successfully.' });
  } catch (error) {
    console.error('Error drafting card:', error);
    res.status(500).json({ message: 'Failed to draft card.' });
  }
});

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

   npm install chart.js react-chartjs-2
   

  npx create-react-app draft-navigator
  cd draft-navigator
  npm install express mongoose chart.js react-chartjs-2 axios
  

    const mongoose = require('mongoose');

    const CardSchema = new mongoose.Schema({
      name: String,
      manaCost: Number,
      type: String,
      powerScore: Number,
      synergyScore: Number,
      // Add other relevant fields
    });

    module.exports = mongoose.model('Card', CardSchema);
    

    function calculatePowerScore(card) {
      const { attack, defense, abilities, manaCost, rarity } = card;
      const rarityMultiplier = { common: 1, uncommon: 1.2, rare: 1.5, mythic: 2 };
      return (attack * 2 + defense * 1.5 + abilities.length * 1) * rarityMultiplier[rarity];
    }
    

    function calculateSynergyScore(card, deck) {
      let synergy = 0;
      deck.forEach(deckCard => {
        if (deckCard.type === card.type) synergy += 1;
        if (deckCard.abilities.some(ability => card.abilities.includes(ability))) synergy += 1;
        // Add more synergy rules
      });
      return synergy;
    }
    

      import { Bar } from 'react-chartjs-2';

      const ManaCurve = ({ deck }) => {
        const manaCounts = {};
        deck.forEach(card => {
          manaCounts[card.manaCost] = (manaCounts[card.manaCost] || 0) + 1;
        });

        const data = {
          labels: Object.keys(manaCounts),
          datasets: [{
            label: 'Mana Curve',
            data: Object.values(manaCounts),
            backgroundColor: 'rgba(75, 192, 192, 0.6)',
          }],
        };

        return <Bar data={data} />;
      };
      

      import { Bar } from 'react-chartjs-2';

      const SynergyBars = ({ deck }) => {
        const data = {
          labels: deck.map(card => card.name),
          datasets: [{
            label: 'Synergy Score',
            data: deck.map(card => card.synergyScore),
            backgroundColor: 'rgba(153, 102, 255, 0.6)',
          }],
        };

        const options = {
          indexAxis: 'y',
          scales: {
            x: { beginAtZero: true },
          },
        };

        return <Bar data={data} options={options} />;
      };
      

    import { Radar } from 'react-chartjs-2';

    const PowerSynergyRadar = ({ card }) => {
      const data = {
        labels: ['Power', 'Synergy'],
        datasets: [{
          label: card.name,
          data: [card.powerScore, card.synergyScore],
          backgroundColor: 'rgba(255, 99, 132, 0.2)',
          borderColor: 'rgba(255, 99, 132, 1)',
          borderWidth: 1,
        }],
      };

      return <Radar data={data} />;
    };
    

  // server.js

  const express = require('express');
  const mongoose = require('mongoose');
  const Card = require('./models/Card'); // Your Card model
  const app = express();

  app.use(express.json());

  // Connect to MongoDB
  mongoose.connect('mongodb://localhost:27017/mtgdeck', { useNewUrlParser: true, useUnifiedTopology: true });

  // Get all cards
  app.get('/api/cards', async (req, res) => {
    const cards = await Card.find();
    res.json(cards);
  });

  // Add card to deck
  app.post('/api/deck/add', async (req, res) => {
    const { cardId } = req.body;
    const card = await Card.findById(cardId);
    if (!card) return res.status(404).json({ message: 'Card not found' });
    
    // Logic to add card to user's deck
    // This could involve updating a separate Deck collection

    res.json({ message: 'Card added to deck', card });
  });

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

  // src/components/CardList.jsx

  import React, { useEffect, useState } from 'react';
  import axios from 'axios';

  const CardList = ({ addCard }) => {
    const [cards, setCards] = useState([]);

    useEffect(() => {
      const fetchCards = async () => {
        const res = await axios.get('/api/cards');
        setCards(res.data);
      };
      fetchCards();
    }, []);

    return (
      <div>
        <h2>Available Cards</h2>
        <ul>
          {cards.map(card => (
            <li key={card._id}>
              {card.name} - Mana Cost: {card.manaCost}
              <button onClick={() => addCard(card._id)}>Pick</button>
            </li>
          ))}
        </ul>
      </div>
    );
  };

  export default CardList;
  

  // server.js

  const http = require('http').createServer(app);
  const io = require('socket.io')(http, {
    cors: { origin: '*' }
  });

  io.on('connection', (socket) => {
    console.log('a user connected');

    socket.on('addCard', async (cardId) => {
      const card = await Card.findById(cardId);
      if (card) {
        // Update deck logic here
        // Emit updated deck data
        io.emit('deckUpdate', { card });
      }
    });

    socket.on('disconnect', () => {
      console.log('user disconnected');
    });
  });

  http.listen(PORT, () => console.log(Server running on port ${PORT}));
  

  // src/App.jsx

  import React, { useState, useEffect } from 'react';
  import io from 'socket.io-client';
  import CardList from './components/CardList';
  import SynergyBar from './components/SynergyBar';
  import ManaCurve from './components/ManaCurve';
  import PowerSynergyRadar from './components/PowerSynergyRadar';
  import axios from 'axios';

  const socket = io('http://localhost:5000');

  const App = () => {
    const [deck, setDeck] = useState([]);

    useEffect(() => {
      socket.on('deckUpdate', ({ card }) => {
        setDeck(prevDeck => [...prevDeck, card]);
      });
    }, []);

    const addCard = async (cardId) => {
      await axios.post('/api/deck/add', { cardId });
      socket.emit('addCard', cardId);
    };

    return (
      <div>
        <h1>Draft Navigator</h1>
        <CardList addCard={addCard} />
        <ManaCurve deck={deck} />
        <SynergyBar deck={deck} />
        {deck.map(card => (
          <PowerSynergyRadar key={card._id} card={card} />
        ))}
      </div>
    );
  };

  export default App;
  

id,name,mana_cost,type,abilities,power,toughness,rarity
1,Lightning Bolt,1,R instant,Deal 3 damage to any target,,,"common"
2,Shivan Dragon,6,Creature - Dragon,Flying; Firebreathing,5,5,"rare"

[
  {
    "draft_id": "draft123",
    "player_id": "playerA",
    "picks": [
      {"card_id": 1, "pick_number": 1},
      {"card_id": 2, "pick_number": 2}
    ],
    "deck": ["card123", "card456", "card789"]
  },
  // More draft entries...
]

draft-navigator/
│
├── backend/
│   ├── server.js
│   ├── models/
│   │   └── Card.js
│   └── data/
│       ├── cards.csv
│       └── drafts.json
│
├── frontend/
│   ├── src/
│   │   ├── components/
│   │   ├── App.jsx
│   │   └── ...
│   └── ...
│
├── README.md
└── package.json

   npm install express mongoose csv-parser
   

     const mongoose = require('mongoose');

     const CardSchema = new mongoose.Schema({
       name: String,
       mana_cost: Number,
       type: String,
       abilities: [String],
       power: Number,
       toughness: Number,
       rarity: String,
     });

     module.exports = mongoose.model('Card', CardSchema);
     

     const fs = require('fs');
     const csv = require('csv-parser');
     const mongoose = require('mongoose');
     const Card = require('./models/Card');

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

     const results = [];

     fs.createReadStream('./data/cards.csv')
       .pipe(csv())
       .on('data', (data) => results.push(data))
       .on('end', async () => {
         for (const cardData of results) {
           const card = new Card({
             name: cardData.name,
             mana_cost: parseInt(cardData.mana_cost) || 0,
             type: cardData.type,
             abilities: cardData.abilities ? cardData.abilities.split(';') : [],
             power: parseInt(cardData.power) || 0,
             toughness: parseInt(cardData.toughness) || 0,
             rarity: cardData.rarity,
           });
           await card.save();
         }
         mongoose.connection.close();
         console.log('Cards Imported Successfully');
       });
     

     node importCards.js
     

   const express = require('express');
   const mongoose = require('mongoose');
   const Card = require('./models/Card');
   const cors = require('cors');

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

   // Connect to MongoDB
   mongoose.connect('mongodb://localhost:27017/mtgdeck', { useNewUrlParser: true, useUnifiedTopology: true });

   // Get all cards
   app.get('/api/cards', async (req, res) => {
     const cards = await Card.find();
     res.json(cards);
   });

   // Get a single card by ID
   app.get('/api/cards/:id', async (req, res) => {
     const card = await Card.findById(req.params.id);
     if (!card) return res.status(404).json({ message: 'Card not found' });
     res.json(card);
   });

   // Add a card to the deck (for simplicity, let's assume one deck)
   let deck = [];

   app.post('/api/deck/add', async (req, res) => {
     const { cardId } = req.body;
     const card = await Card.findById(cardId);
     if (!card) return res.status(404).json({ message: 'Card not found' });
     deck.push(card);
     res.json({ message: 'Card added to deck', card, deck });
   });

   // Get current deck
   app.get('/api/deck', (req, res) => {
     res.json(deck);
   });

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

   cd frontend
   npm install axios react-chartjs-2 chart.js socket.io-client
   

     import React, { useEffect, useState } from 'react';
     import axios from 'axios';

     const CardList = ({ addCard }) => {
       const [cards, setCards] = useState([]);

       useEffect(() => {
         const fetchCards = async () => {
           const res = await axios.get('http://localhost:5000/api/cards');
           setCards(res.data);
         };
         fetchCards();
       }, []);

       return (
         <div>
           <h2>Available Cards</h2>
           <ul>
             {cards.map(card => (
               <li key={card._id}>
                 <strong>{card.name}</strong> - Mana Cost: {card.mana_cost} - Type: {card.type} - Rarity: {card.rarity}
                 <button onClick={() => addCard(card._id)}>Pick</button>
               </li>
             ))}
           </ul>
         </div>
       );
     };

     export default CardList;
     

     import React from 'react';
     import { Bar } from 'react-chartjs-2';

     const ManaCurve = ({ deck }) => {
       const manaCounts = {};

       deck.forEach(card => {
         const cost = card.mana_cost;
         manaCounts[cost] = (manaCounts[cost] || 0) + 1;
       });

       const data = {
         labels: Object.keys(manaCounts).sort((a, b) => a - b),
         datasets: [{
           label: 'Mana Curve',
           data: Object.values(manaCounts),
           backgroundColor: 'rgba(75, 192, 192, 0.6)',
         }],
       };

       const options = {
         scales: {
           y: {
             beginAtZero: true,
             precision: 0,
           },
         },
       };

       return (
         <div>
           <h2>Mana Curve</h2>
           <Bar data={data} options={options} />
         </div>
       );
     };

     export default ManaCurve;
     

     import React from 'react';
     import { Bar } from 'react-chartjs-2';

     const SynergyBar = ({ deck }) => {
       // Simple synergy calculation: count of shared types
       const synergyScores = deck.map(card => {
         // Example: Synergy based on shared types (e.g., all Creatures)
         const sharedTypes = deck.filter(c => c.type === card.type).length;
         return sharedTypes;
       });

       const data = {
         labels: deck.map(card => card.name),
         datasets: [{
           label: 'Synergy Score',
           data: synergyScores,
           backgroundColor: 'rgba(153, 102, 255, 0.6)',
         }],
       };

       const options = {
         indexAxis: 'y',
         scales: {
           x: {
             beginAtZero: true,
             precision: 0,
           },
         },
       };

       return (
         <div>
           <h2>Synergy Scores</h2>
           <Bar data={data} options={options} />
         </div>
       );
     };

     export default SynergyBar;
     

     import React from 'react';
     import { Radar } from 'react-chartjs-2';

     const PowerSynergyRadar = ({ card }) => {
       // Simple power score based on mana_cost and abilities
       const powerScore = card.mana_cost * 2 + (card.abilities.length * 1.5);
       // Simple synergy score as calculated in SynergyBar
       const synergyScore =  deck.filter(c => c.type === card.type).length;

       const data = {
         labels: ['Power', 'Synergy'],
         datasets: [{
           label: card.name,
           data: [powerScore, synergyScore],
           backgroundColor: 'rgba(255, 99, 132, 0.2)',
           borderColor: 'rgba(255, 99, 132, 1)',
           borderWidth: 1,
         }],
       };

       const options = {
         scales: {
           r: {
             beginAtZero: true,
           },
         },
       };

       return (
         <div>
           <h3>{card.name} - Power vs Synergy</h3>
           <Radar data={data} options={options} />
         </div>
       );
     };

     export default PowerSynergyRadar;
     

     import React, { useState, useEffect } from 'react';
     import axios from 'axios';
     import CardList from './components/CardList';
     import ManaCurve from './components/ManaCurve';
     import SynergyBar from './components/SynergyBar';
     import PowerSynergyRadar from './components/PowerSynergyRadar';

     const App = () => {
       const [deck, setDeck] = useState([]);

       const addCard = async (cardId) => {
         const res = await axios.post('http://localhost:5000/api/deck/add', { cardId });
         setDeck(res.data.deck);
       };

       return (
         <div>
           <h1>Draft Navigator</h1>
           <CardList addCard={addCard} />
           <ManaCurve deck={deck} />
           <SynergyBar deck={deck} />
           {deck.map(card => (
             <PowerSynergyRadar key={card._id} card={card} />
           ))}
         </div>
       );
     };

     export default App;
     

   cd backend
   node server.js
   

   cd frontend
   npm start
   

     function calculatePowerScore(card) {
       const rarityMultiplier = { common: 1, uncommon: 1.2, rare: 1.5, mythic: 2 };
       return (card.mana_cost * 2 + card.abilities.length * 1.5) * (rarityMultiplier[card.rarity.toLowerCase()] || 1);
     }
     

     function calculateSynergyScore(card, deck) {
       let synergy = 0;
       deck.forEach(deckCard => {
         if (deckCard.type === card.type) synergy += 1;
         if (deckCard.abilities.some(ability => card.abilities.includes(ability))) synergy += 1;
       });
       return synergy;
     }
     

   const http = require('http').createServer(app);
   const io = require('socket.io')(http, {
     cors: { origin: '*' }
   });

   io.on('connection', (socket) => {
     console.log('a user connected');

     socket.on('addCard', async (cardId) => {
       const card = await Card.findById(cardId);
       if (card) {
         deck.push(card);
         // Recalculate scores
         const updatedDeck = deck.map(c => ({
           ...c._doc,
           powerScore: calculatePowerScore(c),
           synergyScore: calculateSynergyScore(c, deck),
         }));
         io.emit('deckUpdate', updatedDeck);
       }
     });

     socket.on('disconnect', () => {
       console.log('user disconnected');
     });
   });

   http.listen(PORT, () => console.log(Server running on port ${PORT}));
   

   import React, { useState, useEffect } from 'react';
   import io from 'socket.io-client';
   import CardList from './components/CardList';
   import ManaCurve from './components/ManaCurve';
   import SynergyBar from './components/SynergyBar';
   import PowerSynergyRadar from './components/PowerSynergyRadar';

   const socket = io('http://localhost:5000');

   const App = () => {
     const [deck, setDeck] = useState([]);

     useEffect(() => {
       socket.on('deckUpdate', (updatedDeck) => {
         setDeck(updatedDeck);
       });
     }, []);

     const addCard = (cardId) => {
       socket.emit('addCard', cardId);
     };

     return (
       <div>
         <h1>Draft Navigator</h1>
         <CardList addCard={addCard} />
         <ManaCurve deck={deck} />
         <SynergyBar deck={deck} />
         {deck.map(card => (
           <PowerSynergyRadar key={card._id} card={card} />
         ))}
       </div>
     );
   };

   export default App;
   

const fs = require('fs');
const csv = require('csv-parser');
const mongoose = require('mongoose');
const Card = require('./models/Card');

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

const results = [];

fs.createReadStream('./data/cards.csv')
  .pipe(csv())
  .on('data', (data) => results.push(data))
  .on('end', async () => {
    for (const cardData of results) {
      const card = new Card({
        name: cardData.name,
        mana_cost: parseInt(cardData.mana_cost) || 0,
        type: cardData.type,
        abilities: cardData.abilities ? cardData.abilities.split(';') : [],
        power: parseInt(cardData.power) || 0,
        toughness: parseInt(cardData.toughness) || 0,
        rarity: cardData.rarity,
      });
      await card.save();
    }
    mongoose.connection.close();
    console.log('Cards Imported Successfully');
  });

import React, { useState, useEffect } from 'react';
import io from 'socket.io-client';
import CardList from './components/CardList';
import ManaCurve from './components/ManaCurve';
import SynergyBar from './components/SynergyBar';
import PowerSynergyRadar from './components/PowerSynergyRadar';
import axios from 'axios';

const socket = io('http://localhost:5000');

const App = () => {
  const [deck, setDeck] = useState([]);

  useEffect(() => {
    socket.on('deckUpdate', (updatedDeck) => {
      setDeck(updatedDeck);
    });
  }, []);

  const addCard = (cardId) => {
    socket.emit('addCard', cardId);
  };

  return (
    <div>
      <h1>Draft Navigator</h1>
      <CardList addCard={addCard} />
      <ManaCurve deck={deck} />
      <SynergyBar deck={deck} />
      {deck.map(card => (
        <PowerSynergyRadar key={card._id} card={card} />
      ))}
    </div>
  );
};

export default App;

// Synergy calculation within addCard event
const calculateSynergyScore = (card, deck) => {
  let synergy = 0;
  deck.forEach(deckCard => {
    if (deckCard.type === card.type) synergy += 1;
    if (deckCard.abilities.some(ability => card.abilities.includes(ability))) synergy += 1;
  });
  return synergy;
};

socket.on('addCard', async (cardId) => {
  const card = await Card.findById(cardId);
  if (card) {
    deck.push(card);
    // Recalculate scores
    const updatedDeck = deck.map(c => ({
      ...c._doc,
      powerScore: calculatePowerScore(c),
      synergyScore: calculateSynergyScore(c, deck),
    }));
    io.emit('deckUpdate', updatedDeck);
  }
});