OpenParty/core/database/DatabaseManager.js

const sqlite3 = require('sqlite3').verbose();
const path = require('path');
const { getSavefilePath } = require('../helper');
const Logger = require('../utils/logger');

const DB_PATH = path.join(getSavefilePath(), 'openparty.db');

class DatabaseManager {
    constructor() {
        this.logger = new Logger('DatabaseManager');
        if (DatabaseManager._instance) {
            this.logger.info('Returning existing instance.');
            return DatabaseManager._instance;
        }
        this._db = null;
        DatabaseManager._instance = this;
        this.logger.info('New instance created.');
    }

    static getInstance() {
        if (!DatabaseManager._instance) {
            DatabaseManager._instance = new DatabaseManager();
        }
        return DatabaseManager._instance;
    }

    initialize() {
        if (this._db) {
            this.logger.info('Database already initialized (this._db is set).');
            return Promise.resolve(this._db);
        }

        this.logger.info('Starting database initialization...');
        return new Promise((resolve, reject) => {
            this._db = new sqlite3.Database(DB_PATH, (err) => {
                if (err) {
                    this.logger.error('Error connecting to database:', err.message);
                    this._db = null;
                    reject(err);
                } else {
                    this.logger.info('Connected to the SQLite database. this._db is now set.');
                    this._db.serialize(() => {
                        // Create most_played table
                        this._db.run(`CREATE TABLE IF NOT EXISTS most_played (
                            mapName TEXT PRIMARY KEY,
                            playCount INTEGER DEFAULT 0
                        )`, (err) => {
                            if (err) {
                                this.logger.error('Error creating most_played table:', err.message);
                                return reject(err);
                            }
                        });

                        // Create leaderboard table
                        this._db.run(`CREATE TABLE IF NOT EXISTS leaderboard (
                            id INTEGER PRIMARY KEY AUTOINCREMENT,
                            mapName TEXT NOT NULL,
                            profileId TEXT NOT NULL,
                            username TEXT NOT NULL,
                            score INTEGER NOT NULL,
                            timestamp TEXT NOT NULL,
                            UNIQUE(mapName, profileId)
                        )`, (err) => {
                            if (err) {
                                this.logger.error('Error creating leaderboard table:', err.message);
                                return reject(err);
                            }
                        });

                        // Create dotw (Dance of the Week) table
                        this._db.run(`CREATE TABLE IF NOT EXISTS dotw (
                            id INTEGER PRIMARY KEY AUTOINCREMENT,
                            mapName TEXT NOT NULL,
                            profileId TEXT NOT NULL,
                            username TEXT NOT NULL,
                            score INTEGER NOT NULL,
                            timestamp TEXT NOT NULL,
                            weekNumber INTEGER NOT NULL,
                            gameVersion TEXT,
                            rank INTEGER,
                            name TEXT,
                            avatar TEXT,
                            country TEXT,
                            platformId TEXT,
                            alias TEXT,
                            aliasGender INTEGER,
                            jdPoints INTEGER,
                            portraitBorder TEXT,
                            UNIQUE(mapName, profileId, weekNumber)
                        )`, (err) => {
                            if (err) {
                                this.logger.error('Error creating dotw table:', err.message);
                                return reject(err);
                            }
                        });

                        // Create user_profiles table
                        this._db.run(`CREATE TABLE IF NOT EXISTS user_profiles (
                            profileId TEXT PRIMARY KEY,
                            name TEXT,
                            alias TEXT,
                            aliasGender INTEGER,
                            avatar TEXT,
                            country TEXT,
                            createdAt TEXT,
                            ticket TEXT,
                            platformId TEXT,
                            jdPoints INTEGER,
                            portraitBorder TEXT,
                            -- Store scores and songsPlayed as JSON strings
                            scores TEXT, 
                            songsPlayed TEXT,
                            favorites TEXT
                        )`, (err) => {
                            if (err) {
                                this.logger.error('Error creating user_profiles table:', err.message);
                                reject(err);
                            } else {
                                this.logger.info('All tables created. Resolving initialize promise.');
                                resolve(this._db);
                            }
                        });
                    });
                }
            });
        });
    }

    getDb() {
        this.logger.info(`getDb() called. this._db is: ${this._db ? 'set' : 'null'}`);
        if (!this._db) {
            throw new Error('DatabaseManager: Database not initialized. Call initialize() first.');
        }
        return this._db;
    }
}

module.exports = DatabaseManager;