import db from "../config/database.js";
import Wallet from "../models/Wallet.js";

class UserService {
    static async getUserByUserId(userId) {
        try {
            return await db.getAsync(
                'SELECT * FROM users WHERE id = ?',
                [String(userId)]
            );
        } catch (error) {
            console.error('Error getting user:', error);
            throw error;
        }
    }

    static async getUserByTelegramId(telegramId) {
        try {
            return await db.getAsync(
                'SELECT * FROM users WHERE telegram_id = ?',
                [String(telegramId)]
            );
        } catch (error) {
            console.error('Error getting user:', error);
            throw error;
        }
    }

    static async getDetailedUserByTelegramId(telegramId) {
        try {
            return await db.getAsync(`
                SELECT 
                    u.*,
                    COUNT(DISTINCT p.id) as purchase_count,
                    COALESCE(SUM(p.total_price), 0) as total_spent,
                    COUNT(DISTINCT cw.id) as crypto_wallet_count,
                    COUNT(DISTINCT cw2.id) as archived_wallet_count
                FROM users u
                    LEFT JOIN purchases p ON u.id = p.user_id
                    LEFT JOIN crypto_wallets cw ON u.id = cw.user_id AND cw.wallet_type NOT LIKE '%_%'
                    LEFT JOIN crypto_wallets cw2 ON u.id = cw2.user_id AND cw2.wallet_type LIKE '%_%'
                WHERE u.telegram_id = ?
                GROUP BY u.id
            `, [telegramId.toString()]);
        } catch (error) {
            console.error('Error getting user stats:', error);
            throw error;
        }
    }

    static async createUser(userData) {
        try {
            const existingUser = await this.getUserByTelegramId(userData?.telegram_id);

            if (existingUser) {
                return existingUser.id;
            }

            const fields = Object.keys(userData);
            const values = [];

            for (const field of fields) {
                values.push(userData[field]);
            }

            const marks = [];
            for (let i = 0; i < fields.length; i++) {
                marks.push("?");
            }

            const query = [
                `INSERT INTO users (${fields.join(', ')})`,
                `VALUES (${marks.join(', ')})`
            ].join("");

            await db.runAsync('BEGIN TRANSACTION');
            const result = await db.runAsync(query, [values]);
            await db.runAsync('COMMIT');
            return result.lastID;
        } catch (error) {
            await db.runAsync('ROLLBACK');
            console.error('Error creating user:', error);
            throw error;
        }
    }

    static async updateUser(userId, newUserData) {}

    static async deleteUser() {}

    static async recalculateUserBalanceByTelegramId(telegramId) {
        const user = await this.getUserByTelegramId(telegramId);

        if (!user) {
            return;
        }

        const archivedBalance = await Wallet.getArchivedWalletsBalance(user.id);
        const activeBalance = await Wallet.getActiveWalletsBalance(user.id);

        const purchases = await db.getAsync(
            `SELECT SUM(total_price) as total_sum FROM purchases WHERE user_id = ?`,
            [user.id]
        );

        const userTotalBalance = (activeBalance + archivedBalance) - (purchases?.total_sum || 0);

        await db.runAsync(`UPDATE users SET total_balance = ? WHERE id = ?`, [userTotalBalance, user.id]);
    }

    static async updateUserLocation(telegramId, country, city, district) {
        await db.runAsync(
            'UPDATE users SET country = ?, city = ?, district = ? WHERE telegram_id = ?',
            [country, city, district, telegramId.toString()]
        );
    }

    static async updateUserStatus(telegramId, status) {
        // statuses
        // 0 - active
        // 1 - deleted
        // 2 - blocked

        try {
            await db.runAsync('BEGIN TRANSACTION');

            // Update user status
            await db.runAsync('UPDATE users SET status = ? WHERE telegram_id = ?', [status, telegramId.toString()]);

            // Commit transaction
            await db.runAsync('COMMIT');
        } catch (e) {
            await db.runAsync("ROLLBACK");
            console.error('Error deleting user:', e);
            throw e;
        }
    }
}

export default UserService;