const express = require('express');
const router = express.Router();
const { getDb } = require('../dbPool');
const { requireAuth, requireAdmin } = require('../middlewares/auth');

/**
 * 모든 페이지 목록 조회
 * GET /api/pages
 */
router.get('/pages', requireAuth, async (req, res) => {
  try {
    const db = await getDb();
    const [pages] = await db.query(`
      SELECT id, page_key, page_name, page_path, category, description, is_admin_only, display_order
      FROM pages
      ORDER BY display_order, page_name
    `);

    res.json({ success: true, data: pages });
  } catch (error) {
    console.error('페이지 목록 조회 오류:', error);
    res.status(500).json({ success: false, error: '페이지 목록을 불러오는데 실패했습니다.' });
  }
});

/**
 * 특정 사용자의 페이지 접근 권한 조회
 * GET /api/users/:userId/page-access
 */
router.get('/users/:userId/page-access', requireAuth, async (req, res) => {
  try {
    const { userId } = req.params;
    const db = await getDb();

    // 사용자의 역할 확인
    const [userRows] = await db.query(`
      SELECT u.user_id, u.username, u.role_id, r.name as role_name
      FROM users u
      LEFT JOIN roles r ON u.role_id = r.id
      WHERE u.user_id = ?
    `, [userId]);

    if (userRows.length === 0) {
      return res.status(404).json({ success: false, error: '사용자를 찾을 수 없습니다.' });
    }

    const user = userRows[0];

    // Admin/System Admin인 경우 모든 페이지 접근 가능
    if (user.role_name === 'Admin' || user.role_name === 'System Admin') {
      const [allPages] = await db.query(`
        SELECT id, page_key, page_name, page_path, category, is_admin_only
        FROM pages
        ORDER BY display_order, page_name
      `);

      const pageAccess = allPages.map(page => ({
        page_id: page.id,
        page_key: page.page_key,
        page_name: page.page_name,
        page_path: page.page_path,
        category: page.category,
        is_admin_only: page.is_admin_only,
        can_access: true,
        is_default: true // Admin은 기본적으로 모든 권한 보유
      }));

      return res.json({ success: true, data: { user, pageAccess } });
    }

    // 일반 사용자의 페이지 접근 권한 조회
    const [pageAccess] = await db.query(`
      SELECT
        p.id as page_id,
        p.page_key,
        p.page_name,
        p.page_path,
        p.category,
        p.is_admin_only,
        COALESCE(upa.can_access, p.is_default_accessible, 0) as can_access,
        upa.granted_at,
        u2.username as granted_by_username
      FROM pages p
      LEFT JOIN user_page_access upa ON p.id = upa.page_id AND upa.user_id = ?
      LEFT JOIN users u2 ON upa.granted_by = u2.user_id
      WHERE p.is_admin_only = 0
      ORDER BY p.display_order, p.page_name
    `, [userId]);

    res.json({ success: true, data: { user, pageAccess } });
  } catch (error) {
    console.error('페이지 접근 권한 조회 오류:', error);
    res.status(500).json({ success: false, error: '페이지 접근 권한을 불러오는데 실패했습니다.' });
  }
});

/**
 * 사용자에게 페이지 접근 권한 부여/회수
 * POST /api/users/:userId/page-access
 * Body: { pageIds: [1, 2, 3], canAccess: true }
 */
router.post('/users/:userId/page-access', requireAuth, async (req, res) => {
  try {
    const { userId } = req.params;
    const { pageIds, canAccess } = req.body;
    const adminUserId = req.user.user_id; // 권한을 부여하는 Admin의 user_id

    // Admin 권한 확인
    const db = await getDb();
    const [adminRows] = await db.query(`
      SELECT u.role_id, r.name as role_name
      FROM users u
      LEFT JOIN roles r ON u.role_id = r.id
      WHERE u.user_id = ?
    `, [adminUserId]);

    if (adminRows.length === 0 || (adminRows[0].role_name !== 'Admin' && adminRows[0].role_name !== 'System Admin')) {
      return res.status(403).json({ success: false, error: '권한이 없습니다. Admin 계정만 사용자 권한을 관리할 수 있습니다.' });
    }

    // 사용자 존재 확인
    const [userRows] = await db.query('SELECT user_id FROM users WHERE user_id = ?', [userId]);
    if (userRows.length === 0) {
      return res.status(404).json({ success: false, error: '사용자를 찾을 수 없습니다.' });
    }

    // 페이지 접근 권한 업데이트
    for (const pageId of pageIds) {
      // 기존 권한 확인
      const [existing] = await db.query(
        'SELECT * FROM user_page_access WHERE user_id = ? AND page_id = ?',
        [userId, pageId]
      );

      if (existing.length > 0) {
        // 업데이트
        await db.query(
          'UPDATE user_page_access SET can_access = ?, granted_at = NOW(), granted_by = ? WHERE user_id = ? AND page_id = ?',
          [canAccess ? 1 : 0, adminUserId, userId, pageId]
        );
      } else {
        // 삽입
        await db.query(
          'INSERT INTO user_page_access (user_id, page_id, can_access, granted_by) VALUES (?, ?, ?, ?)',
          [userId, pageId, canAccess ? 1 : 0, adminUserId]
        );
      }
    }

    res.json({ success: true, message: '페이지 접근 권한이 업데이트되었습니다.' });
  } catch (error) {
    console.error('페이지 접근 권한 부여 오류:', error);
    res.status(500).json({ success: false, error: '페이지 접근 권한을 업데이트하는데 실패했습니다.' });
  }
});

/**
 * 특정 페이지의 접근 권한 회수
 * DELETE /api/users/:userId/page-access/:pageId
 */
router.delete('/users/:userId/page-access/:pageId', requireAuth, async (req, res) => {
  try {
    const { userId, pageId } = req.params;
    const adminUserId = req.user.user_id;

    // Admin 권한 확인
    const db = await getDb();
    const [adminRows] = await db.query(`
      SELECT u.role_id, r.name as role_name
      FROM users u
      LEFT JOIN roles r ON u.role_id = r.id
      WHERE u.user_id = ?
    `, [adminUserId]);

    if (adminRows.length === 0 || (adminRows[0].role_name !== 'Admin' && adminRows[0].role_name !== 'System Admin')) {
      return res.status(403).json({ success: false, error: '권한이 없습니다.' });
    }

    // 접근 권한 삭제
    await db.query(
      'DELETE FROM user_page_access WHERE user_id = ? AND page_id = ?',
      [userId, pageId]
    );

    res.json({ success: true, message: '페이지 접근 권한이 회수되었습니다.' });
  } catch (error) {
    console.error('페이지 접근 권한 회수 오류:', error);
    res.status(500).json({ success: false, error: '페이지 접근 권한을 회수하는데 실패했습니다.' });
  }
});

/**
 * 모든 사용자의 페이지 접근 권한 요약 조회 (Admin용)
 * GET /api/page-access/summary
 */
router.get('/page-access/summary', requireAuth, async (req, res) => {
  try {
    const adminUserId = req.user.user_id;

    // Admin 권한 확인
    const db = await getDb();
    const [adminRows] = await db.query(`
      SELECT u.role_id, r.name as role_name
      FROM users u
      LEFT JOIN roles r ON u.role_id = r.id
      WHERE u.user_id = ?
    `, [adminUserId]);

    if (adminRows.length === 0 || (adminRows[0].role_name !== 'Admin' && adminRows[0].role_name !== 'System Admin')) {
      return res.status(403).json({ success: false, error: '권한이 없습니다.' });
    }

    // 모든 사용자와 페이지 권한 조회
    const [summary] = await db.query(`
      SELECT
        u.user_id,
        u.username,
        u.name,
        r.name as role_name,
        COUNT(DISTINCT upa.page_id) as accessible_pages_count,
        (SELECT COUNT(*) FROM pages WHERE is_admin_only = 0) as total_pages_count
      FROM users u
      LEFT JOIN roles r ON u.role_id = r.id
      LEFT JOIN user_page_access upa ON u.user_id = upa.user_id AND upa.can_access = 1
      WHERE r.name NOT IN ('Admin', 'System Admin')
      GROUP BY u.user_id, u.username, u.name, r.name
      ORDER BY u.username
    `);

    res.json({ success: true, data: summary });
  } catch (error) {
    console.error('페이지 접근 권한 요약 조회 오류:', error);
    res.status(500).json({ success: false, error: '페이지 접근 권한 요약을 불러오는데 실패했습니다.' });
  }
});

module.exports = router;