app.js

const express = require('express');
const { Pool } = require('pg');
const path = require('path');
const multer = require('multer');
const ExcelJS = require('exceljs');
const passport = require('passport');
const GoogleStrategy = require('passport-google-oauth20').Strategy;
const session = require('express-session');
// ===================================
// КРИТИЧЕСКИЙ ФИКС: ЗАГРУЗКА И ОБЪЯВЛЕНИЕ ПЕРЕМЕННЫХ
// ===================================
require('dotenv').config(); 

const GOOGLE_CLIENT_ID = process.env.GOOGLE_CLIENT_ID;
const GOOGLE_CLIENT_SECRET = process.env.GOOGLE_CLIENT_SECRET;
const CALLBACK_URL = 'http://localhost:3000/auth/google/callback'; 
const SESSION_SECRET = process.env.SESSION_SECRET || 'b7e6f1c2a4d9e8f0f5a6b7c8d9e0f1dksfwaaaaaadasd2f3a4';

// Проверка, что ID загружен корректно
console.log('Client ID загружен:', GOOGLE_CLIENT_ID ? 'Да' : 'Нет'); 
if (!GOOGLE_CLIENT_ID) {
    console.warn("ВНИМАНИЕ: GOOGLE_CLIENT_ID отсутствует в .env! Авторизация не будет работать.");
}
// ===================================

const app = express();

app.use(express.json());
app.use(express.static(path.join(__dirname, 'public')));

// Настройка подключения к базе данных
const pool = new Pool({
    user: process.env.DB_USER, 
    host: process.env.DB_HOST,
    database: process.env.DB_DATABASE,
    password: process.env.DB_PASSWORD,
    port: process.env.DB_PORT,
});

// Настройка multer для временного хранения файлов в памяти
const storage = multer.memoryStorage();
const upload = multer({ storage: storage });

// ======================================
// ВСПОМОГАТЕЛЬНЫЕ ФУНКЦИИ ДЛЯ PASSPORT
// ======================================

// 1. Поиск пользователя по Google ID
async function findUserByGoogleId(googleId) {
    const result = await pool.query('SELECT * FROM users WHERE google_id = $1', [googleId]);
    return result.rows[0];
}

// 2. Создание нового пользователя
async function createUser(userData) {
    const { google_id, email, name } = userData;
    const result = await pool.query(
        'INSERT INTO users(google_id, email, name) VALUES($1, $2, $3) RETURNING id, google_id, email, name', 
        [google_id, email, name]
    );
    return result.rows[0];
}

// 3. Поиск пользователя по внутреннему ID (для deserializeUser)
async function findUserById(id) {
    const result = await pool.query('SELECT id, name FROM users WHERE id = $1', [id]);
    return result.rows[0];
}

// Вспомогательная функция для поиска ID по имени (теперь УЧИТЫВАЕТ user_id для items!)
async function findId(tableName, name, userId) {
    if (!name) return null;
    
    // КЛЮЧЕВОЕ ИСПРАВЛЕНИЕ: Всегда используем user_id для поиска по имени, 
    // чтобы предотвратить ссылку на чужие элементы, кроме items, где это может быть не нужно, 
    // но в целях импорта лучше использовать
    let query = `SELECT id FROM ${tableName} WHERE name = $1`;
    let params = [name];
    
    if (tableName === 'houses' || tableName === 'rooms' || tableName === 'items') { 
        // ИСПРАВЛЕНИЕ: Добавляем user_id для items!
        query = `SELECT id FROM ${tableName} WHERE name = $1 AND user_id = $2`;
        params = [name, userId];
    }
    
    const result = await pool.query(query, params);
    return result.rows.length > 0 ? result.rows[0].id : null;
}

// Вспомогательная функция для построения пути (нужно убедиться, что она не возвращает чужие данные)
async function buildPath(itemId) {
    // NOTE: Здесь не добавляем user_id, так как мы полагаемся, что itemId уже получен 
    // из безопасного search-роута, который фильтрует по user_id.
    const path = [];
    let currentId = itemId;
    let limit = 10;
    while (currentId && limit > 0) {
        const itemResult = await pool.query('SELECT * FROM items WHERE id = $1', [currentId]);
        const item = itemResult.rows[0];
        if (!item) break;
        path.unshift(item.name);
        if (item.parent_item_id) {
            currentId = item.parent_item_id;
        } else if (item.room_id) {
            const roomResult = await pool.query('SELECT * FROM rooms WHERE id = $1', [item.room_id]);
            const room = roomResult.rows[0];
            if (room) {
                path.unshift(room.name);
                const houseResult = await pool.query('SELECT * FROM houses WHERE id = $1', [room.house_id]);
                const house = houseResult.rows[0];
                if (house) {
                    path.unshift(house.name);
                }
            }
            break;
        } else {
            break;
        }
        limit--;
    }
    return path.join(' > ');
}


// ======================================
// НАСТРОЙКА PASSPORT И СЕССИЙ
// ======================================

app.use(session({
    secret: SESSION_SECRET,
    resave: false,
    saveUninitialized: true,
    cookie: { secure: false } 
}));
app.use(passport.initialize());
app.use(passport.session());

// --------------------------------------
// 1. СТРАТЕГИЯ GOOGLE
// --------------------------------------

passport.use(new GoogleStrategy({
    clientID: GOOGLE_CLIENT_ID,
    clientSecret: GOOGLE_CLIENT_SECRET,
    callbackURL: CALLBACK_URL
},
async function(accessToken, refreshToken, profile, done) {
    try {
        const googleId = profile.id;
        const email = profile.emails[0].value;
        const name = profile.displayName;
        
        let user = await findUserByGoogleId(googleId);

        if (user) {
            return done(null, user);
        } else {
            const newUser = await createUser({
                google_id: googleId,
                email: email,
                name: name
            });
            return done(null, newUser);
        }
    } catch (error) {
        console.error('Ошибка авторизации/БД:', error.stack);
        return done(error, null);
    }
}));

// --------------------------------------
// 2. СЕРИАЛИЗАЦИЯ/ДЕСЕРИАЛИЗАЦИЯ
// --------------------------------------

passport.serializeUser((user, done) => {
    done(null, user.id); 
});

passport.deserializeUser(async (id, done) => {
    try {
        const user = await findUserById(id);
        done(null, user); 
    } catch (error) {
        done(error, null);
    }
});

// --------------------------------------
// 3. МАРШРУТЫ АВТОРИЗАЦИИ
// --------------------------------------

app.get('/auth/google',
    passport.authenticate('google', { 
        scope: ['profile', 'email']
    })
);

app.get('/auth/google/callback',
    passport.authenticate('google', { 
        failureRedirect: '/' 
    }),
    (req, res) => {
        res.redirect('/'); 
    }
);

app.get('/logout', (req, res, next) => {
    req.logout((err) => {
        if (err) { return next(err); }
        res.redirect('/');
    });
});

// ======================================
// ФУНКЦИЯ ПРОВЕРКИ АВТОРИЗАЦИИ (МИДЛВАР)
// ======================================

function ensureAuthenticated(req, res, next) {
    if (req.isAuthenticated()) {
        return next();
    }
    // Если пользователь не авторизован, добавляем роут для фронтенда /api/check-auth
    res.status(401).json({ error: 'Необходима авторизация' });
}

// ======================================
// ДОБАВЛЕНИЕ РОУТА ДЛЯ ПРОВЕРКИ АУТЕНТИФИКАЦИИ
// ======================================

app.get('/api/check-auth', (req, res) => {
    if (req.isAuthenticated()) {
        res.status(200).json({ authenticated: true, user: { id: req.user.id, name: req.user.name } });
    } else {
        res.status(401).json({ authenticated: false });
    }
});

// =========================================================
// ОСНОВНЫЕ РОУТЫ
// =========================================================

// Роут для главной страницы (ВАЖНО: теперь он просто отдает HTML)
app.get('/', (req, res) => {
    res.sendFile(path.join(__dirname, 'public', 'index.html'));
});

// Пример роута для проверки авторизации (защищен)
app.get('/profile', ensureAuthenticated, (req, res) => {
    res.send(`Привет, ${req.user.name}! Твой внутренний ID: ${req.user.id}`);
});


// =========================================================
// CRUD роуты для Houses (Обновлено: фильтрация по user_id)
// =========================================================

// GET /api/houses (ФИЛЬТРАЦИЯ)
app.get('/api/houses', ensureAuthenticated, async (req, res) => {
    try {
        const userId = req.user.id;
        const result = await pool.query('SELECT * FROM houses WHERE user_id = $1', [userId]);
        res.status(200).json(result.rows);
    } catch (err) {
        console.error(err.stack);
        res.status(500).json({ error: 'Ошибка при получении списка домов.' });
    }
});

// POST /api/houses (ДОБАВЛЕНИЕ user_id и ИСПРАВЛЕНИЕ db.query на pool.query)

app.post('/api/houses', ensureAuthenticated, async (req, res) => {
    try {
        const { name } = req.body;
        const userId = req.user.id; 

        if (!userId) {
            return res.status(401).json({ error: 'Пользователь не аутентифицирован.' });
        }
        
        // КЛЮЧЕВОЕ ИСПРАВЛЕНИЕ: Замена db.query на pool.query
        const result = await pool.query( 
            'INSERT INTO houses (user_id, name) VALUES ($1, $2) RETURNING id',
            [userId, name] 
        );

        res.status(201).json({ id: result.rows[0].id, name });
    } catch (err) {
        console.error('Ошибка при добавлении дома:', err);
        res.status(500).json({ error: 'Ошибка сервера при добавлении дома.' });
    }
});

// DELETE /api/houses/:id (ФИЛЬТРАЦИЯ)
app.delete('/api/houses/:id', ensureAuthenticated, async (req, res) => {
    try {
        const { id } = req.params;
        const userId = req.user.id;
        const result = await pool.query('DELETE FROM houses WHERE id = $1 AND user_id = $2 RETURNING *', [id, userId]);
        if (result.rowCount === 0) {
            return res.status(404).json({ error: 'Дом не найден или не принадлежит вам.' });
        }
        res.status(200).json({ message: 'Дом успешно удален.' });
    } catch (err) {
        console.error(err.stack);
        res.status(500).json({ error: 'Ошибка при удалении дома.' });
    }
});

// PUT /api/houses/:id (ФИЛЬТРАЦИЯ)
app.put('/api/houses/:id', ensureAuthenticated, async (req, res) => {
    try {
        const { id } = req.params;
        const { name } = req.body;
        const userId = req.user.id;
        const result = await pool.query('UPDATE houses SET name = $1 WHERE id = $2 AND user_id = $3 RETURNING *', [name, id, userId]);
        if (result.rowCount === 0) {
            return res.status(404).json({ error: 'Дом не найден или не принадлежит вам.' });
        }
        res.status(200).json(result.rows[0]);
    } catch (err) {
        console.error(err.stack);
        res.status(500).json({ error: 'Ошибка при обновлении дома.' });
    }
});

// GET /api/houses/:id (ПОИСК ПО ID И ФИЛЬТРАЦИЯ)
app.get('/api/houses/:id', ensureAuthenticated, async (req, res) => {
    try {
        const { id } = req.params;
        const userId = req.user.id;
        const result = await pool.query('SELECT * FROM houses WHERE id = $1 AND user_id = $2', [id, userId]);
        if (result.rowCount === 0) {
            return res.status(404).json({ error: 'Дом не найден или не принадлежит вам.' });
        }
        res.status(200).json(result.rows[0]);
    } catch (err) {
        console.error(err.stack);
        res.status(500).json({ error: 'Ошибка сервера.' });
    }
});


// =========================================================
// CRUD роуты для Rooms (Обновлено: фильтрация по user_id)
// =========================================================

// GET /api/rooms (ФИЛЬТРАЦИЯ)
app.get('/api/rooms', ensureAuthenticated, async (req, res) => {
    try {
        const { house_id } = req.query;
        const userId = req.user.id;
        
        if (!house_id) {
            // Получаем все комнаты пользователя, если house_id не указан
            const result = await pool.query('SELECT * FROM rooms WHERE user_id = $1', [userId]);
            return res.status(200).json(result.rows);
        }

        // Проверяем, принадлежит ли дом пользователю, прежде чем искать комнаты в нем
        const houseCheck = await pool.query('SELECT id FROM houses WHERE id = $1 AND user_id = $2', [house_id, userId]);
        if (houseCheck.rowCount === 0) {
            return res.status(403).json({ error: 'Дом не найден или не принадлежит вам.' });
        }
        
        const result = await pool.query('SELECT * FROM rooms WHERE house_id = $1 AND user_id = $2', [house_id, userId]);
        res.status(200).json(result.rows);
    } catch (err) {
        console.error(err.stack);
        res.status(500).json({ error: 'Ошибка при получении списка комнат.' });
    }
});

// POST /api/rooms (ДОБАВЛЕНИЕ user_id и проверка house_id)
app.post('/api/rooms', ensureAuthenticated, async (req, res) => {
    try {
        const { name, house_id } = req.body;
        const userId = req.user.id;
        
        // Проверка, принадлежит ли дом пользователю
        const houseCheck = await pool.query('SELECT id FROM houses WHERE id = $1 AND user_id = $2', [house_id, userId]);
        if (houseCheck.rowCount === 0) {
            return res.status(403).json({ error: 'Невозможно добавить комнату: Дом не найден или не принадлежит вам.' });
        }
        
        const newRoom = await pool.query('INSERT INTO rooms(name, house_id, user_id) VALUES($1, $2, $3) RETURNING *', [name, house_id, userId]);
        const roomData = newRoom.rows[0];
        roomData.type = 'room';
        res.status(201).json(roomData);
    } catch (err) {
        console.error(err.stack);
        res.status(500).json({ error: 'Ошибка при добавлении комнаты.' });
    }
});

// DELETE /api/rooms/:id (ФИЛЬТРАЦИЯ)
app.delete('/api/rooms/:id', ensureAuthenticated, async (req, res) => {
    try {
        const { id } = req.params;
        const userId = req.user.id;
        const result = await pool.query('DELETE FROM rooms WHERE id = $1 AND user_id = $2 RETURNING *', [id, userId]);
        if (result.rowCount === 0) {
            return res.status(404).json({ error: 'Комната не найдена или не принадлежит вам.' });
        }
        res.status(200).json({ message: 'Комната успешно удалена.' });
    } catch (err) {
        console.error(err.stack);
        res.status(500).json({ error: 'Ошибка при удалении комнаты.' });
    }
});

// PUT /api/rooms/:id (ФИЛЬТРАЦИЯ)
app.put('/api/rooms/:id', ensureAuthenticated, async (req, res) => {
    try {
        const { id } = req.params;
        const { name } = req.body;
        const userId = req.user.id;
        const result = await pool.query('UPDATE rooms SET name = $1 WHERE id = $2 AND user_id = $3 RETURNING *', [name, id, userId]);
        if (result.rowCount === 0) {
            return res.status(404).json({ error: 'Комната не найдена или не принадлежит вам.' });
        }
        res.status(200).json(result.rows[0]);
    } catch (err) {
        console.error(err.stack);
        res.status(500).json({ error: 'Ошибка при обновлении комнаты.' });
    }
});


// =========================================================
// CRUD роуты для Items (Обновлено: фильтрация по user_id)
// =========================================================

// GET /api/items (ФИЛЬТРАЦИЯ)
app.get('/api/items', ensureAuthenticated, async (req, res) => {
    try {
        const { room_id, parent_item_id } = req.query;
        const userId = req.user.id;
        let query = 'SELECT * FROM items WHERE user_id = $1';
        let params = [userId];

        if (room_id) {
            query += ' AND room_id = $2 AND parent_item_id IS NULL';
            params.push(room_id);
            // Проверка принадлежности комнаты пользователю
            const roomCheck = await pool.query('SELECT id FROM rooms WHERE id = $1 AND user_id = $2', [room_id, userId]);
            if (roomCheck.rowCount === 0) {
                return res.status(403).json({ error: 'Комната не найдена или не принадлежит вам.' });
            }
        } else if (parent_item_id) {
            query += ' AND parent_item_id = $2';
            params.push(parent_item_id);
            // Проверка принадлежности родительского предмета пользователю
            const itemCheck = await pool.query('SELECT id FROM items WHERE id = $1 AND user_id = $2', [parent_item_id, userId]);
            if (itemCheck.rowCount === 0) {
                return res.status(403).json({ error: 'Родительский предмет не найден или не принадлежит вам.' });
            }
        } else {
            // Если ни того, ни другого нет, возвращаем все предметы пользователя, привязанные к комнатам:
            query += ' AND room_id IS NOT NULL AND parent_item_id IS NULL';
        }

        const result = await pool.query(query, params);
        res.status(200).json(result.rows);
    } catch (err) {
        console.error(err.stack);
        res.status(500).json({ error: 'Ошибка при получении списка предметов.' });
    }
});

// POST /api/items (ДОБАВЛЕНИЕ user_id и проверка принадлежности)
app.post('/api/items', ensureAuthenticated, async (req, res) => {
    const { name, type, description, room_id, parent_item_id } = req.body; 
    const userId = req.user.id;
    try {
        if (!room_id && !parent_item_id) {
            return res.status(400).json({ error: 'Предмет должен находиться либо в комнате, либо в другом предмете.' });
        }

        if (room_id) {
            // Проверка, принадлежит ли комната пользователю
            const roomCheck = await pool.query('SELECT id FROM rooms WHERE id = $1 AND user_id = $2', [room_id, userId]);
            if (roomCheck.rowCount === 0) {
                return res.status(403).json({ error: 'Комната не найдена или не принадлежит вам.' });
            }
        }
        
        if (parent_item_id) {
            // Проверка, принадлежит ли родительский предмет пользователю
            const itemCheck = await pool.query('SELECT id FROM items WHERE id = $1 AND user_id = $2', [parent_item_id, userId]);
            if (itemCheck.rowCount === 0) {
                return res.status(403).json({ error: 'Родительский предмет не найден или не принадлежит вам.' });
            }
        }

        const newItem = await pool.query(
            'INSERT INTO items(name, type, description, room_id, parent_item_id, user_id) VALUES($1, $2, $3, $4, $5, $6) RETURNING *',
            [name, type, description, room_id, parent_item_id, userId]
        );
        res.status(201).json(newItem.rows[0]);
    } catch (err) {
        console.error(err.stack);
        res.status(500).json({ error: 'Ошибка при добавлении предмета.' });
    }
});

// DELETE /api/items/:id (ФИЛЬТРАЦИЯ)
app.delete('/api/items/:id', ensureAuthenticated, async (req, res) => {
    try {
        const { id } = req.params;
        const userId = req.user.id;
        const result = await pool.query('DELETE FROM items WHERE id = $1 AND user_id = $2 RETURNING *', [id, userId]);
        if (result.rowCount === 0) {
            return res.status(404).json({ error: 'Предмет не найден или не принадлежит вам.' });
        }
        res.status(200).json({ message: 'Предмет успешно удален.' });
    } catch (err) {
        console.error(err.stack);
        res.status(500).json({ error: 'Ошибка при удалении предмета.' });
    }
});

// PUT /api/items/:id (ФИЛЬТРАЦИЯ)
app.put('/api/items/:id', ensureAuthenticated, async (req, res) => {
    try {
        const { id } = req.params;
        const { name } = req.body;
        const userId = req.user.id;
        const result = await pool.query('UPDATE items SET name = $1 WHERE id = $2 AND user_id = $3 RETURNING *', [name, id, userId]);
        if (result.rowCount === 0) {
            return res.status(404).json({ error: 'Предмет не найден или не принадлежит вам.' });
        }
        res.status(200).json(result.rows[0]);
    } catch (err) {
        console.error(err.stack);
        res.status(500).json({ error: 'Ошибка при обновлении предмета.' });
    }
});


// =========================================================
// Ghost Locations (Обновлено: фильтрация по user_id)
// =========================================================

// GET /api/ghost_locations (ФИЛЬТРАЦИЯ)
app.get('/api/ghost_locations', ensureAuthenticated, async (req, res) => {
    try {
        const { item_id } = req.query;
        const userId = req.user.id;

        if (!item_id) {
            return res.status(400).json({ error: 'Не указан ID предмета.' });
        }
        
        // Проверяем, принадлежит ли предмет пользователю
        const itemCheck = await pool.query('SELECT id FROM items WHERE id = $1 AND user_id = $2', [item_id, userId]);
        if (itemCheck.rowCount === 0) {
            return res.status(403).json({ error: 'Предмет не найден или не принадлежит вам.' });
        }

        const result = await pool.query('SELECT location_name FROM ghost_locations WHERE item_id = $1 AND user_id = $2', [item_id, userId]);
        
        res.status(200).json({ locations: result.rows });
    } catch (err) {
        console.error(err.stack);
        res.status(500).json({ error: 'Ошибка при получении мест-призраков.' });
    }
});

// POST /api/ghost_locations (ДОБАВЛЕНИЕ user_id)
app.post('/api/ghost_locations', ensureAuthenticated, async (req, res) => {
    try {
        const { item_id, location_name } = req.body;
        const userId = req.user.id;
        
        if (!item_id || !location_name) {
            return res.status(400).json({ error: 'Отсутствует ID предмета или название места.' });
        }

        // Проверяем, принадлежит ли предмет пользователю
        const itemCheck = await pool.query('SELECT id FROM items WHERE id = $1 AND user_id = $2', [item_id, userId]);
        if (itemCheck.rowCount === 0) {
            return res.status(403).json({ error: 'Предмет не найден или не принадлежит вам.' });
        }
        
        const result = await pool.query('INSERT INTO ghost_locations (item_id, location_name, user_id) VALUES ($1, $2, $3) RETURNING id', [item_id, location_name, userId]);
        
        res.status(201).json({ success: true, newId: result.rows[0].id });
    } catch (err) {
        console.error(err.stack);
        res.status(500).json({ error: 'Ошибка при добавлении места-призрака.' });
    }
});

// =========================================================
// Роут для поиска (Обновлено: фильтрация по user_id)
// =========================================================

// GET /api/search (ФИЛЬТРАЦИЯ)
app.get('/api/search', ensureAuthenticated, async (req, res) => {
    try {
        const { name, id } = req.query;
        const userId = req.user.id;
        
        if (!name && !id) {
            return res.status(400).json({ error: 'Не указано имя или ID предмета.' });
        }

        let searchResults;
        
        if (id) {
            searchResults = await pool.query('SELECT id, name, type, room_id, parent_item_id FROM items WHERE id = $1 AND user_id = $2', [id, userId]);
        } else {
            searchResults = await pool.query('SELECT id, name, type, room_id, parent_item_id FROM items WHERE name ILIKE $1 AND user_id = $2', [`%${name}%`, userId]);
        }

        if (searchResults.rows.length === 0) {
            return res.status(404).json({ message: 'Предмет не найден.' });
        }

        const foundItemsWithPaths = [];

        for (const item of searchResults.rows) {
            // ПРОВЕРКА: Убедитесь, что buildPath работает с объектами pool и не вытягивает чужие данные
            const path = await buildPath(item.id); 
            foundItemsWithPaths.push({
                id: item.id,
                name: item.name,
                type: item.type,
                path: path
            });
        }

        res.status(200).json({ items: foundItemsWithPaths });
        
    } catch (err) {
        console.error(err.stack);
        res.status(500).json({ error: 'Ошибка при поиске.' });
    }
});


// =========================================================
// Роуты для импорта/экспорта (Обновлено: фильтрация по user_id)
// =========================================================

app.post('/api/upload-excel', upload.single('excelFile'), ensureAuthenticated, async (req, res) => {
    const userId = req.user.id;
    try {
        if (!req.file) {
            return res.status(400).json({ error: 'Файл не загружен.' });
        }

        const workbook = new ExcelJS.Workbook();
        await workbook.xlsx.load(req.file.buffer);
        const worksheet = workbook.getWorksheet(1);
        const rows = worksheet.getRows(2, worksheet.rowCount);

        const client = await pool.connect();
        try {
            await client.query('BEGIN');
            for (const row of rows) {
                const name = row.getCell(1).value;
                const type = row.getCell(2).value;
                const description = row.getCell(3).value;
                const houseName = row.getCell(4).value;
                const roomName = row.getCell(5).value;
                const parentItemName = row.getCell(6).value;

                let houseId = null;
                let roomId = null;
                let parentItemId = null;

                if (houseName) {
                    // Ищем дом, принадлежащий текущему пользователю
                    houseId = await findId('houses', houseName, userId);
                    if (!houseId) {
                        // Создаем новый дом, привязывая его к пользователю
                        const newHouse = await client.query('INSERT INTO houses(name, user_id) VALUES($1, $2) RETURNING id', [houseName, userId]);
                        houseId = newHouse.rows[0].id;
                    }
                }

                if (roomName && houseId) {
                    // Ищем комнату, принадлежащую текущему пользователю
                    roomId = await findId('rooms', roomName, userId);
                    if (!roomId) {
                        // Создаем новую комнату, привязывая к дому и пользователю
                        const newRoom = await client.query('INSERT INTO rooms(name, house_id, user_id) VALUES($1, $2, $3) RETURNING id', [roomName, houseId, userId]);
                        roomId = newRoom.rows[0].id;
                    }
                }

                if (parentItemName) {
                    // Ищем родительский предмет ТОЛЬКО среди предметов пользователя
                    parentItemId = await findId('items', parentItemName, userId);
                }

                if (name) {
                    // Вставляем новый предмет, привязывая его к пользователю
                    await client.query(
                        'INSERT INTO items(name, type, description, room_id, parent_item_id, user_id) VALUES($1, $2, $3, $4, $5, $6)',
                        [name, type, description, roomId, parentItemId, userId]
                    );
                }
            }
            await client.query('COMMIT');
            res.status(200).json({ message: 'Данные успешно импортированы.' });
        } catch (dbError) {
            await client.query('ROLLBACK');
            throw dbError;
        } finally {
            client.release();
        }
    } catch (err) {
        console.error(err.stack);
        res.status(500).json({ error: 'Ошибка при импорте данных.' });
    }
});

app.get('/api/export-excel', ensureAuthenticated, async (req, res) => {
    const userId = req.user.id;
    try {
        // Получаем ТОЛЬКО предметы текущего пользователя
        const items = await pool.query('SELECT * FROM items WHERE user_id = $1', [userId]);
        const workbook = new ExcelJS.Workbook();
        const worksheet = workbook.addWorksheet('Инвентаризация');

        worksheet.columns = [
            { header: 'Название', key: 'name', width: 30 },
            { header: 'Тип', key: 'type', width: 15 },
            { header: 'Описание', key: 'description', width: 40 },
            { header: 'Дом', key: 'house', width: 20 },
            { header: 'Комната', key: 'room', width: 20 },
            { header: 'Родительский элемент', key: 'parent_item', width: 20 }
        ];

        for (const item of items.rows) {
            let roomName = '';
            let houseName = '';
            let parentItemName = '';

            if (item.room_id) {
                // Проверяем, что комната принадлежит пользователю (хотя по item_id уже должно быть)
                const room = await pool.query('SELECT name, house_id FROM rooms WHERE id = $1 AND user_id = $2', [item.room_id, userId]);
                if (room.rows[0]) {
                    roomName = room.rows[0].name;
                    // Проверяем, что дом принадлежит пользователю
                    const house = await pool.query('SELECT name FROM houses WHERE id = $1 AND user_id = $2', [room.rows[0].house_id, userId]);
                    if (house.rows[0]) {
                        houseName = house.rows[0].name;
                    }
                }
            }

            if (item.parent_item_id) {
                // Проверяем, что родительский предмет принадлежит пользователю
                const parentItem = await pool.query('SELECT name FROM items WHERE id = $1 AND user_id = $2', [item.parent_item_id, userId]);
                if (parentItem.rows[0]) {
                    parentItemName = parentItem.rows[0].name;
                }
            }

            worksheet.addRow({
                name: item.name,
                type: item.type,
                description: item.description,
                house: houseName,
                room: roomName,
                parent_item: parentItemName
            });
        }

        res.setHeader(
            'Content-Type',
            'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
        );
        res.setHeader(
            'Content-Disposition',
            'attachment; filename=' + 'inventory_export.xlsx'
        );

        await workbook.xlsx.write(res);
        res.end();
    } catch (err) {
        console.error(err.stack);
        res.status(500).json({ error: 'Ошибка при экспорте данных.' });
    }
});

// Роутер приглашений/шаринга создаётся и подключается в server.js,
// чтобы туда передать pool и ensureAuthenticated.
// Экспортируем app, pool и ensureAuthenticated для server.js
module.exports = { app, pool, ensureAuthenticated };