database_manager.py

    

import sqlite3
from datetime import datetime
import json

class DatabaseManager:
    def __init__(self, db_path):
        self.db_path = db_path
        self.conn = sqlite3.connect(self.db_path)

    def insert_game(self, game):
        """Insert a game into the database"""
        with self.conn:
            self.conn.execute('''
                INSERT OR IGNORE INTO games (
                    name, min_requirements, recommended_requirements, min_cpu_score, min_gpu_score, min_ram, min_storage, source,
                    steam_url, gog_url, epic_url, youtube_trailer
                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
            ''', (
                game.get('name'),
                game.get('min_requirements'),
                game.get('recommended_requirements'),
                game.get('min_cpu_score', 0),
                game.get('min_gpu_score', 0),
                game.get('min_ram', 0),
                game.get('min_storage', 0),
                game.get('source', 'Unknown'),
                game.get('steam_url'),
                game.get('gog_url'),
                game.get('epic_url'),
                game.get('youtube_trailer')
            ))
    
    def get_compatible_games(self, system_specs):
        """Get games compatible with the given system specs"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            cursor.execute('''
                SELECT name, min_requirements, recommended_requirements, 
                       min_cpu_score, min_gpu_score, min_ram, min_storage, source,
                       steam_url, gog_url, epic_url, youtube_trailer
                FROM games
                ORDER BY name
            ''')
            
            rows = cursor.fetchall()
            conn.close()
            
            games = []
            for row in rows:
                game = {
                    'name': row[0],
                    'min_requirements': row[1],
                    'recommended_requirements': row[2],
                    'min_cpu_score': row[3],
                    'min_gpu_score': row[4],
                    'min_ram': row[5],
                    'min_storage': row[6],
                    'source': row[7],
                    'steam_url': row[8],
                    'gog_url': row[9],
                    'epic_url': row[10],
                    'youtube_trailer': row[11]
                }
                # Check basic compatibility
                if self.is_game_compatible(game, system_specs):
                    games.append(game)
            
            return games
            
        except Exception as e:
            print(f"Error getting compatible games: {e}")
            return []
    
    def is_game_compatible(self, game, system_specs):
        """Check if a game is compatible with system specs"""
        try:
            # Treat None as 0 for all min_* fields
            min_cpu_score = game.get('min_cpu_score', 0) or 0
            min_gpu_score = game.get('min_gpu_score', 0) or 0
            min_ram = game.get('min_ram', 0) or 0
            min_storage = game.get('min_storage', 0) or 0

            cpu_ok = system_specs.get('cpu_score', 0) >= min_cpu_score
            gpu_ok = system_specs.get('gpu_score', 0) >= min_gpu_score
            ram_ok = system_specs.get('ram', 0) >= min_ram
            storage_ok = system_specs.get('storage', 0) >= min_storage

            # Return true if at least 50% of requirements are met (more lenient)
            requirements_met = sum([cpu_ok, gpu_ok, ram_ok, storage_ok])
            return requirements_met >= 2

        except Exception as e:
            print(f"Error checking game compatibility: {e}")
            return False
    
    def search_games(self, search_term):
        """Search for games by name"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            cursor.execute('''
                SELECT name, min_requirements, recommended_requirements, 
                       min_cpu_score, min_gpu_score, min_ram, min_storage, source,
                       steam_url, gog_url, epic_url, youtube_trailer
                FROM games
                WHERE name LIKE ?
                ORDER BY name
            ''', (f'%{search_term}%',))
            
            rows = cursor.fetchall()
            conn.close()
            
            games = []
            for row in rows:
                games.append({
                    'name': row[0],
                    'min_requirements': row[1],
                    'recommended_requirements': row[2],
                    'min_cpu_score': row[3],
                    'min_gpu_score': row[4],
                    'min_ram': row[5],
                    'min_storage': row[6],
                    'source': row[7],
                    'steam_url': row[8],
                    'gog_url': row[9],
                    'epic_url': row[10],
                    'youtube_trailer': row[11]
                })
            
            return games
            
        except Exception as e:
            print(f"Error searching games: {e}")
            return []
    
    def update_system_specs(self, system_specs):
        """Update cached system specifications"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            # Delete existing specs (we only keep one record)
            cursor.execute("DELETE FROM system_specs")
            
            # Insert new specs
            cursor.execute('''
                INSERT INTO system_specs 
                (cpu_info, gpu_info, ram_gb, storage_gb, os_info, cpu_score, gpu_score, last_updated)
                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
            ''', (
                system_specs.get('cpu', ''),
                system_specs.get('gpu', ''),
                system_specs.get('ram', 0),
                system_specs.get('storage', 0),
                system_specs.get('os', ''),
                system_specs.get('cpu_score', 0),
                system_specs.get('gpu_score', 0),
                datetime.now()
            ))
            
            conn.commit()
            conn.close()
            
        except Exception as e:
            print(f"Error updating system specs: {e}")
    
    def get_system_specs(self):
        """Get cached system specifications"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            cursor.execute('''
                SELECT cpu_info, gpu_info, ram_gb, storage_gb, os_info, cpu_score, gpu_score
                FROM system_specs
                ORDER BY last_updated DESC
                LIMIT 1
            ''')
            
            row = cursor.fetchone()
            conn.close()
            
            if row:
                return {
                    'cpu': row[0],
                    'gpu': row[1],
                    'ram': row[2],
                    'storage': row[3],
                    'os': row[4],
                    'cpu_score': row[5],
                    'gpu_score': row[6]
                }
            
            return {}
            
        except Exception as e:
            print(f"Error getting system specs: {e}")
            return {}
    
    def get_game_count(self):
        """Get total number of games in database"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            cursor.execute("SELECT COUNT(*) FROM games")
            count = cursor.fetchone()[0]
            
            conn.close()
            return count
            
        except Exception as e:
            print(f"Error getting game count: {e}")
            return 0