const express = require('express');
const router = express.Router();
const { Club, Member, User, Feature, ClubFeature, ActivityLog, SubscriptionPlan, Meeting, MeetingParticipant, ClubSubscription } = require('../models');
const clubController = require('../controllers/clubController');
const { sequelize } = require('../models/index');
const { Op } = require('sequelize');
const { authenticateJWT, authorizeRoles } = require('../middleware/authMiddleware');

// 관리자 인증 미들웨어
const adminMiddleware = (req, res, next) => {
    if (req.user && (req.user.role === 'admin' || req.user.role === 'superadmin')) {
        next();
    } else {
        res.status(403).json({ message: '관리자 권한이 필요합니다.' });
    }
};

// 활동 로그 기록 함수
const logActivity = async (userId, type, description) => {
    try {
        await ActivityLog.create({
            userId,
            type,
            description
        });
    } catch (error) {
        console.error('활동 로그 기록 중 오류:', error);
    }
};

// 모든 관리자 라우트에 인증과 admin 권한 검사 미들웨어 적용
router.use(authenticateJWT);
router.use(authorizeRoles('admin', 'superadmin'));

// 대시보드 데이터 조회
router.get('/dashboard', async (req, res) => {
    try {
        const [
            totalUsers,
            totalClubs,
            activeSubscriptions,
            recentUsers,
            recentClubs,
            recentSubscriptions
        ] = await Promise.all([
            // 전체 사용자 수
            User.count(),
            
            // 전체 클럽 수
            Club.count(),
            
            // 활성 구독 수
            ClubSubscription.count({
                where: {
                    status: 'active'
                }
            }),
            
            // 최근 가입한 사용자
            User.findAll({
                limit: 5,
                order: [['createdAt', 'DESC']],
                attributes: ['id', 'username', 'name', 'email', 'role', 'createdAt']
            }),
            
            // 최근 생성된 클럽
            Club.findAll({
                limit: 5,
                order: [['createdAt', 'DESC']],
                attributes: ['id', 'name', 'memberCount', 'createdAt'],
                include: [{
                    model: User,
                    as: 'owner',
                    attributes: ['id', 'name']
                }]
            }),
            
            // 최근 구독 내역
            ClubSubscription.findAll({
                limit: 5,
                order: [['createdAt', 'DESC']],
                include: [
                    {
                        model: Club,
                        attributes: ['id', 'name']
                    },
                    {
                        model: SubscriptionPlan,
                        attributes: ['id', 'name', 'price']
                    }
                ]
            })
        ]);

        // 월별 통계 데이터 (최근 6개월)
        const sixMonthsAgo = new Date();
        sixMonthsAgo.setMonth(sixMonthsAgo.getMonth() - 5);
        
        const [userStats, clubStats, subscriptionStats] = await Promise.all([
            // 월별 사용자 가입 통계
            User.findAll({
                where: {
                    createdAt: {
                        [Op.gte]: sixMonthsAgo
                    }
                },
                attributes: [
                    [sequelize.fn('DATE_FORMAT', sequelize.col('createdAt'), '%Y-%m'), 'month'],
                    [sequelize.fn('COUNT', sequelize.col('id')), 'count']
                ],
                group: [sequelize.fn('DATE_FORMAT', sequelize.col('createdAt'), '%Y-%m')],
                order: [[sequelize.fn('DATE_FORMAT', sequelize.col('createdAt'), '%Y-%m'), 'ASC']]
            }),
            
            // 월별 클럽 생성 통계
            Club.findAll({
                where: {
                    createdAt: {
                        [Op.gte]: sixMonthsAgo
                    }
                },
                attributes: [
                    [sequelize.fn('DATE_FORMAT', sequelize.col('createdAt'), '%Y-%m'), 'month'],
                    [sequelize.fn('COUNT', sequelize.col('id')), 'count']
                ],
                group: [sequelize.fn('DATE_FORMAT', sequelize.col('createdAt'), '%Y-%m')],
                order: [[sequelize.fn('DATE_FORMAT', sequelize.col('createdAt'), '%Y-%m'), 'ASC']]
            }),
            
            // 월별 구독 통계
            ClubSubscription.findAll({
                where: {
                    createdAt: {
                        [Op.gte]: sixMonthsAgo
                    }
                },
                attributes: [
                    [sequelize.fn('DATE_FORMAT', sequelize.col('createdAt'), '%Y-%m'), 'month'],
                    [sequelize.fn('COUNT', sequelize.col('id')), 'count']
                ],
                group: [sequelize.fn('DATE_FORMAT', sequelize.col('createdAt'), '%Y-%m')],
                order: [[sequelize.fn('DATE_FORMAT', sequelize.col('createdAt'), '%Y-%m'), 'ASC']]
            })
        ]);

        res.json({
            summary: {
                totalUsers,
                totalClubs,
                activeSubscriptions
            },
            recent: {
                users: recentUsers,
                clubs: recentClubs,
                subscriptions: recentSubscriptions.map(sub => ({
                    ...sub.toJSON(),
                    expiryDate: sub.endDate
                }))
            },
            stats: {
                users: userStats,
                clubs: clubStats,
                subscriptions: subscriptionStats
            }
        });

        await logActivity(req.user.id, 'VIEW_DASHBOARD', '관리자 대시보드를 조회했습니다.');
    } catch (error) {
        console.error('대시보드 데이터 조회 중 오류:', error);
        res.status(500).json({ message: '서버 오류가 발생했습니다.' });
    }
});

// 클럽 통계 정보 가져오기
router.get('/clubs/stats', async (req, res) => {
    try {
        // 전체 클럽 수 조회
        const totalCount = await Club.count();
        
        // 활성 클럽 수 조회 (status가 'active'인 클럽)
        const activeCount = await Club.count({
            where: { status: 'active' }
        });
        
        // 구독 상태별 클럽 수 조회
        const subscriptionStats = await ClubSubscription.findAll({
            attributes: ['status', [sequelize.fn('COUNT', sequelize.col('id')), 'count']],
            group: ['status']
        });
        
        // 최근 생성된 클럽 5개 조회
        const recentClubs = await Club.findAll({
            attributes: ['id', 'name', 'memberCount', 'createdAt', 'status'],
            order: [['createdAt', 'DESC']],
            limit: 5,
            include: [{
                model: User,
                as: 'owner',
                attributes: ['name', 'email']
            }]
        });
        
        const subscriptions = {
            active: 0,
            expired: 0,
            suspended: 0
        };
        
        subscriptionStats.forEach(stat => {
            subscriptions[stat.status] = parseInt(stat.getDataValue('count'));
        });

        res.json({
            totalCount,
            activeCount,
            subscriptions,
            recentClubs: recentClubs.map(club => ({
                ...club.toJSON(),
                isActive: club.status === 'active'
            }))
        });

        // 활동 로그 기록
        await logActivity(req.user.id, 'VIEW_STATS', '클럽 통계 정보를 조회했습니다.');
    } catch (error) {
        console.error('클럽 통계 정보 조회 중 오류:', error);
        res.status(500).json({ message: '서버 오류가 발생했습니다.' });
    }
});

// 클럽 통계 가져오기
router.get('/clubs/stats', async (req, res) => {
    try {
        // 전체 클럽 수
        const totalCount = await Club.count();

        // 활성 클럽 수 (status가 active인 클럽)
        const activeCount = await Club.count({
            where: { status: 'active' }
        });

        // 최근 가입한 클럽 수 (최근 7일)
        const newCount = await Club.count({
            where: {
                createdAt: {
                    [Op.gte]: new Date(new Date() - 7 * 24 * 60 * 60 * 1000)
                }
            }
        });

        // 평균 회원 수
        const avgMemberCount = await Club.findOne({
            attributes: [
                [sequelize.fn('AVG', sequelize.col('memberCount')), 'avgMembers']
            ],
            raw: true
        });

        res.json({
            totalCount,
            activeCount,
            newCount,
            averageMemberCount: Math.round(avgMemberCount.avgMembers || 0)
        });

        await logActivity(req.user.id, 'VIEW_CLUB_STATS', '클럽 통계를 조회했습니다.');
    } catch (error) {
        console.error('클럽 통계 조회 중 오류:', error);
        res.status(500).json({ message: '서버 오류가 발생했습니다.' });
    }
});

// 기능 통계 가져오기
router.get('/features/stats', async (req, res) => {
    try {
        // 전체 기능 수
        const totalCount = await Feature.count();

        // 활성화된 기능 수 (status가 active인 기능)
        const activeCount = await Feature.count({
            where: { status: 'active' }
        });

        // 클럽별 기능 사용 현황
        const usageStats = await ClubFeature.findAll({
            attributes: [
                'featureId',
                [sequelize.fn('COUNT', sequelize.col('ClubFeature.id')), 'usageCount']
            ],
            include: [{
                model: Feature,
                attributes: ['name']
            }],
            group: ['featureId', 'Feature.id', 'Feature.name'],
            raw: true
        });

        // 최근 추가된 기능 (최근 30일)
        const newCount = await Feature.count({
            where: {
                createdAt: {
                    [Op.gte]: new Date(new Date() - 30 * 24 * 60 * 60 * 1000)
                }
            }
        });

        res.json({
            totalCount,
            activeCount,
            newCount,
            usageStats: usageStats.map(stat => ({
                featureName: stat['Feature.name'],
                usageCount: parseInt(stat.usageCount)
            }))
        });

        await logActivity(req.user.id, 'VIEW_FEATURE_STATS', '기능 통계를 조회했습니다.');
    } catch (error) {
        console.error('기능 통계 조회 중 오류:', error);
        res.status(500).json({ message: '서버 오류가 발생했습니다.' });
    }
});

// 사용자 목록 가져오기
router.get('/users', async (req, res) => {
    try {
        const users = await User.findAll({
            attributes: ['id', 'name', 'email', 'role', 'status', 'createdAt'],
            order: [['createdAt', 'DESC']]
        });

        res.json(users);

        // 활동 로그 기록
        await logActivity(req.user.id, 'VIEW_USERS', '사용자 목록을 조회했습니다.');
    } catch (error) {
        console.error('사용자 목록 조회 중 오류:', error);
        res.status(500).json({ message: '서버 오류가 발생했습니다.' });
    }
});

// 특정 사용자 조회
router.get('/users/:id', async (req, res) => {
    try {
        const { id } = req.params;
        const user = await User.findByPk(id, {
            attributes: ['id', 'username', 'name', 'email', 'role', 'status', 'createdAt']
        });

        if (!user) {
            return res.status(404).json({ message: '사용자를 찾을 수 없습니다.' });
        }

        res.json(user);
        await logActivity(req.user.id, 'VIEW_USER', `사용자 ${id}의 정보를 조회했습니다.`);
    } catch (error) {
        console.error('사용자 조회 중 오류:', error);
        res.status(500).json({ message: '서버 오류가 발생했습니다.' });
    }
});

// 사용자 정보 수정
router.put('/users/:id', async (req, res) => {
    try {
        const { id } = req.params;
        const { username, name, email, role, status } = req.body;

        const user = await User.findByPk(id);
        if (!user) {
            return res.status(404).json({ message: '사용자를 찾을 수 없습니다.' });
        }

        // 관리자는 자신의 role을 변경할 수 없음
        if (req.user.id === parseInt(id) && role && role !== user.role) {
            return res.status(403).json({ message: '자신의 권한을 변경할 수 없습니다.' });
        }

        await user.update({
            username,
            name,
            email,
            role,
            status
        });

        const updatedUser = await User.findByPk(id, {
            attributes: ['id', 'username', 'name', 'email', 'role', 'status', 'createdAt']
        });

        res.json(updatedUser);
        await logActivity(req.user.id, 'UPDATE_USER', `사용자 ${id}의 정보를 수정했습니다.`);
    } catch (error) {
        console.error('사용자 수정 중 오류:', error);
        if (error.name === 'SequelizeUniqueConstraintError') {
            return res.status(400).json({ message: '이미 사용 중인 이메일 또는 사용자명입니다.' });
        }
        res.status(500).json({ message: '서버 오류가 발생했습니다.' });
    }
});

// 사용자 삭제
router.delete('/users/:id', async (req, res) => {
    try {
        const { id } = req.params;

        // 자기 자신은 삭제할 수 없음
        if (req.user.id === parseInt(id)) {
            return res.status(403).json({ message: '자신의 계정은 삭제할 수 없습니다.' });
        }

        const user = await User.findByPk(id);
        if (!user) {
            return res.status(404).json({ message: '사용자를 찾을 수 없습니다.' });
        }

        await user.destroy();

        res.json({ message: '사용자가 삭제되었습니다.' });
        await logActivity(req.user.id, 'DELETE_USER', `사용자 ${id}를 삭제했습니다.`);
    } catch (error) {
        console.error('사용자 삭제 중 오류:', error);
        res.status(500).json({ message: '서버 오류가 발생했습니다.' });
    }
});

// 클럽 목록 가져오기
router.get('/clubs', async (req, res) => {
    try {
        const clubs = await Club.findAll({
            attributes: [
                'id',
                'name',
                'location',
                'createdAt',
                [sequelize.literal('(SELECT COUNT(*) FROM Members WHERE Members.clubId = Club.id)'), 'memberCount']
            ],
            include: [{
                model: User,
                as: 'owner',
                attributes: ['id', 'name', 'email']
            }],
            order: [['createdAt', 'DESC']]
        });

        res.json(clubs);

        // 활동 로그 기록
        await logActivity(req.user.id, 'VIEW_CLUBS', '클럽 목록을 조회했습니다.');
    } catch (error) {
        console.error('클럽 목록 조회 중 오류:', error);
        res.status(500).json({ message: '서버 오류가 발생했습니다.' });
    }
});

// 구독 목록 가져오기
router.get('/subscriptions', async (req, res) => {
    try {
        const subscriptions = await ClubSubscription.findAll({
            include: [
                {
                    model: Club,
                    attributes: ['id', 'name']
                },
                {
                    model: SubscriptionPlan,
                    include: [Feature]
                }
            ],
            order: [['createdAt', 'DESC']]
        });

        const formattedSubscriptions = subscriptions.map(subscription => {
            const data = subscription.toJSON();
            data.expiryDate = data.endDate;
            delete data.endDate;
            return data;
        });

        res.json(formattedSubscriptions);

        await logActivity(req.user.id, 'VIEW_SUBSCRIPTIONS', '구독 목록을 조회했습니다.');
    } catch (error) {
        console.error('구독 목록 조회 중 오류:', error);
        res.status(500).json({ message: '서버 오류가 발생했습니다.' });
    }
});

// 구독 통계 가져오기
router.get('/subscriptions/stats', async (req, res) => {
    try {
        // 전체 구독 수
        const totalSubscriptions = await ClubSubscription.count();

        // 활성 구독 수
        const activeSubscriptions = await ClubSubscription.count({
            where: { status: 'active' }
        });

        // 만료된 구독 수
        const expiredSubscriptions = await ClubSubscription.count({
            where: { status: 'expired' }
        });

        // 플랜별 구독 통계
        const planStats = await ClubSubscription.findAll({
            attributes: [
                'planId',
                [sequelize.fn('COUNT', sequelize.col('ClubSubscription.id')), 'count']
            ],
            include: [{
                model: SubscriptionPlan,
                attributes: ['name', 'price']
            }],
            group: ['planId', 'SubscriptionPlan.id', 'SubscriptionPlan.name', 'SubscriptionPlan.price'],
            raw: true
        });

        // 월별 구독 통계 (최근 6개월)
        const sixMonthsAgo = new Date();
        sixMonthsAgo.setMonth(sixMonthsAgo.getMonth() - 5);
        
        const monthlyStats = await ClubSubscription.findAll({
            attributes: [
                [sequelize.fn('DATE_FORMAT', sequelize.col('ClubSubscription.createdAt'), '%Y-%m'), 'month'],
                [sequelize.fn('COUNT', sequelize.col('ClubSubscription.id')), 'count']
            ],
            where: {
                createdAt: {
                    [Op.gte]: sixMonthsAgo
                }
            },
            group: [sequelize.fn('DATE_FORMAT', sequelize.col('ClubSubscription.createdAt'), '%Y-%m')],
            order: [[sequelize.fn('DATE_FORMAT', sequelize.col('ClubSubscription.createdAt'), '%Y-%m'), 'ASC']],
            raw: true
        });

        // 총 매출 계산
        const totalRevenue = planStats.reduce((sum, stat) => {
            return sum + (stat['SubscriptionPlan.price'] * parseInt(stat.count));
        }, 0);

        res.json({
            summary: {
                totalSubscriptions,
                activeSubscriptions,
                expiredSubscriptions,
                totalRevenue
            },
            planStats: planStats.map(stat => ({
                planName: stat['SubscriptionPlan.name'],
                planPrice: stat['SubscriptionPlan.price'],
                count: parseInt(stat.count),
                revenue: stat['SubscriptionPlan.price'] * parseInt(stat.count)
            })),
            monthlyStats: monthlyStats.map(stat => ({
                month: stat.month,
                count: parseInt(stat.count)
            }))
        });

        await logActivity(req.user.id, 'VIEW_SUBSCRIPTION_STATS', '구독 통계를 조회했습니다.');
    } catch (error) {
        console.error('구독 통계 조회 중 오류:', error);
        res.status(500).json({ message: '서버 오류가 발생했습니다.' });
    }
});

// 이벤트 목록 가져오기
router.get('/events', async (req, res) => {
    try {
        const events = await Meeting.findAll({
            include: [Club],
            order: [['date', 'DESC']]
        });

        const formattedEvents = events.map(event => ({
            id: event.id,
            title: event.title,
            date: event.date,
            status: event.status,
            teamCount: event.teamCount,
            gameCount: event.gameCount,
            participantCount: event.participantCount,
            clubName: event.Club.name,
            location: event.location
        }));

        res.json(formattedEvents);

        await logActivity(req.user.id, 'VIEW_EVENTS', '이벤트 목록을 조회했습니다.');
    } catch (error) {
        console.error('이벤트 목록 조회 중 오류:', error);
        res.status(500).json({ message: '서버 오류가 발생했습니다.' });
    }
});

// 이벤트 참가자 목록 가져오기
router.get('/events/:id/participants', async (req, res) => {
    try {
        const { id } = req.params;

        const event = await Meeting.findByPk(id, {
            include: [{
                model: MeetingParticipant,
                include: [Member]
            }]
        });

        if (!event) {
            return res.status(404).json({ message: '이벤트를 찾을 수 없습니다.' });
        }

        const participants = event.MeetingParticipants.map(p => ({
            id: p.id,
            memberId: p.memberId,
            memberName: p.Member.name,
            teamNumber: p.teamNumber,
            status: p.status,
            attendance: p.attendance,
            paymentStatus: p.paymentStatus,
            registeredAt: p.createdAt
        }));

        res.json(participants);

        await logActivity(req.user.id, 'VIEW_EVENT_PARTICIPANTS', `이벤트 참가자 목록을 조회했습니다.`);
    } catch (error) {
        console.error('이벤트 참가자 목록 조회 중 오류:', error);
        res.status(500).json({ message: '서버 오류가 발생했습니다.' });
    }
});

// 클럽 회원 목록 조회
router.get('/clubs/:id/members', async (req, res) => {
    try {
        const { id } = req.params;
        
        const members = await Member.findAll({
            where: { clubId: id },
            include: [{
                model: User,
                attributes: ['id', 'name', 'email']
            }],
            order: [['createdAt', 'DESC']]
        });

        res.json(members);

        // 활동 로그 기록
        await logActivity(req.user.id, 'VIEW_CLUB_MEMBERS', `클럽 ${id}의 회원 목록을 조회했습니다.`);
    } catch (error) {
        console.error('클럽 회원 목록 조회 중 오류:', error);
        res.status(500).json({ message: '서버 오류가 발생했습니다.' });
    }
});

// 클럽 회원 추가
router.post('/clubs/:id/members', async (req, res) => {
    try {
        const { id } = req.params;
        const { name, gender, memberType, userId } = req.body;

        const member = await Member.create({
            clubId: id,
            userId,
            name,
            gender,
            memberType,
            joinDate: new Date(),
            status: 'active'
        });

        res.status(201).json(member);

        // 활동 로그 기록
        await logActivity(req.user.id, 'ADD_CLUB_MEMBER', `클럽 ${id}에 새 회원을 추가했습니다.`);
    } catch (error) {
        console.error('클럽 회원 추가 중 오류:', error);
        res.status(500).json({ message: '서버 오류가 발생했습니다.' });
    }
});

// 클럽 회원 정보 수정
router.put('/clubs/:id/members/:memberId', async (req, res) => {
    try {
        const { id, memberId } = req.params;
        const updateData = req.body;

        const member = await Member.findOne({
            where: { 
                id: memberId,
                clubId: id
            }
        });

        if (!member) {
            return res.status(404).json({ message: '회원을 찾을 수 없습니다.' });
        }

        await member.update(updateData);

        res.json(member);

        // 활동 로그 기록
        await logActivity(req.user.id, 'UPDATE_CLUB_MEMBER', `클럽 ${id}의 회원 정보를 수정했습니다.`);
    } catch (error) {
        console.error('클럽 회원 정보 수정 중 오류:', error);
        res.status(500).json({ message: '서버 오류가 발생했습니다.' });
    }
});

// 클럽 회원 삭제
router.delete('/clubs/:id/members/:memberId', async (req, res) => {
    try {
        const { id, memberId } = req.params;

        const member = await Member.findOne({
            where: { 
                id: memberId,
                clubId: id
            }
        });

        if (!member) {
            return res.status(404).json({ message: '회원을 찾을 수 없습니다.' });
        }

        await member.destroy();

        res.json({ message: '회원이 삭제되었습니다.' });

        // 활동 로그 기록
        await logActivity(req.user.id, 'DELETE_CLUB_MEMBER', `클럽 ${id}의 회원을 삭제했습니다.`);
    } catch (error) {
        console.error('클럽 회원 삭제 중 오류:', error);
        res.status(500).json({ message: '서버 오류가 발생했습니다.' });
    }
});

// 활동 로그 목록 조회
router.get('/activity-logs', async (req, res) => {
    try {
        const page = parseInt(req.query.page) || 1;
        const limit = parseInt(req.query.limit) || 20;
        const offset = (page - 1) * limit;

        const logs = await ActivityLog.findAndCountAll({
            include: [{
                model: User,
                as: 'User',
                attributes: ['username', 'name']
            }],
            order: [['createdAt', 'DESC']],
            limit,
            offset
        });

        res.json({
            logs: logs.rows.map(log => ({
                id: log.id,
                type: log.type,
                description: log.description,
                createdAt: log.createdAt,
                user: {
                    username: log.User.username,
                    name: log.User.name
                }
            })),
            totalPages: Math.ceil(logs.count / limit),
            currentPage: page,
            totalItems: logs.count
        });

        await logActivity(req.user.id, 'VIEW_ACTIVITY_LOGS', '활동 로그를 조회했습니다.');
    } catch (error) {
        console.error('활동 로그 조회 중 오류:', error);
        res.status(500).json({ message: '서버 오류가 발생했습니다.' });
    }
});

// 구독 플랜 목록 조회
router.get('/subscriptions/plans', async (req, res) => {
    try {
        const plans = await SubscriptionPlan.findAll({
            include: [{
                model: Feature,
                through: { attributes: [] }
            }],
            order: [['price', 'ASC']]
        });

        res.json(plans);

        await logActivity(req.user.id, 'VIEW_SUBSCRIPTION_PLANS', '구독 플랜 목록을 조회했습니다.');
    } catch (error) {
        console.error('구독 플랜 목록 조회 중 오류:', error);
        res.status(500).json({ message: '서버 오류가 발생했습니다.' });
    }
});

// 구독 플랜 생성
router.post('/subscriptions/plans', async (req, res) => {
    try {
        const { name, description, price, duration, features } = req.body;

        const plan = await SubscriptionPlan.create({
            name,
            description,
            price,
            duration
        });

        if (features && features.length > 0) {
            await plan.setFeatures(features);
        }

        res.status(201).json(plan);

        await logActivity(req.user.id, 'CREATE_SUBSCRIPTION_PLAN', `새 구독 플랜 "${name}"을(를) 생성했습니다.`);
    } catch (error) {
        console.error('구독 플랜 생성 중 오류:', error);
        res.status(500).json({ message: '서버 오류가 발생했습니다.' });
    }
});

// 구독 플랜 수정
router.put('/subscriptions/plans/:id', async (req, res) => {
    try {
        const { id } = req.params;
        const { name, description, price, duration, features } = req.body;

        const plan = await SubscriptionPlan.findByPk(id);
        if (!plan) {
            return res.status(404).json({ message: '구독 플랜을 찾을 수 없습니다.' });
        }

        await plan.update({
            name,
            description,
            price,
            duration
        });

        if (features) {
            await plan.setFeatures(features);
        }

        res.json(plan);

        await logActivity(req.user.id, 'UPDATE_SUBSCRIPTION_PLAN', `구독 플랜 "${name}"을(를) 수정했습니다.`);
    } catch (error) {
        console.error('구독 플랜 수정 중 오류:', error);
        res.status(500).json({ message: '서버 오류가 발생했습니다.' });
    }
});

// 구독 플랜 삭제
router.delete('/subscriptions/plans/:id', async (req, res) => {
    try {
        const { id } = req.params;

        const plan = await SubscriptionPlan.findByPk(id);
        if (!plan) {
            return res.status(404).json({ message: '구독 플랜을 찾을 수 없습니다.' });
        }

        await plan.destroy();

        res.json({ message: '구독 플랜이 삭제되었습니다.' });

        await logActivity(req.user.id, 'DELETE_SUBSCRIPTION_PLAN', `구독 플랜 "${plan.name}"을(를) 삭제했습니다.`);
    } catch (error) {
        console.error('구독 플랜 삭제 중 오류:', error);
        res.status(500).json({ message: '서버 오류가 발생했습니다.' });
    }
});

// 기능 목록 조회
router.get('/features', async (req, res) => {
    try {
        const features = await Feature.findAll({
            order: [['name', 'ASC']]
        });

        res.json(features);

        await logActivity(req.user.id, 'VIEW_FEATURES', '기능 목록을 조회했습니다.');
    } catch (error) {
        console.error('기능 목록 조회 중 오류:', error);
        res.status(500).json({ message: '서버 오류가 발생했습니다.' });
    }
});

// 기능 생성
router.post('/features', async (req, res) => {
    try {
        const { name, description, category } = req.body;

        const feature = await Feature.create({
            name,
            description,
            category
        });

        res.status(201).json(feature);

        await logActivity(req.user.id, 'CREATE_FEATURE', `새 기능 "${name}"을(를) 생성했습니다.`);
    } catch (error) {
        console.error('기능 생성 중 오류:', error);
        res.status(500).json({ message: '서버 오류가 발생했습니다.' });
    }
});

// 기능 수정
router.put('/features/:id', async (req, res) => {
    try {
        const { id } = req.params;
        const { name, description, category } = req.body;

        const feature = await Feature.findByPk(id);
        if (!feature) {
            return res.status(404).json({ message: '기능을 찾을 수 없습니다.' });
        }

        await feature.update({
            name,
            description,
            category
        });

        res.json(feature);

        await logActivity(req.user.id, 'UPDATE_FEATURE', `기능 "${name}"을(를) 수정했습니다.`);
    } catch (error) {
        console.error('기능 수정 중 오류:', error);
        res.status(500).json({ message: '서버 오류가 발생했습니다.' });
    }
});

// 기능 삭제
router.delete('/features/:id', async (req, res) => {
    try {
        const { id } = req.params;

        const feature = await Feature.findByPk(id);
        if (!feature) {
            return res.status(404).json({ message: '기능을 찾을 수 없습니다.' });
        }

        await feature.destroy();

        res.json({ message: '기능이 삭제되었습니다.' });

        await logActivity(req.user.id, 'DELETE_FEATURE', `기능 "${feature.name}"을(를) 삭제했습니다.`);
    } catch (error) {
        console.error('기능 삭제 중 오류:', error);
        res.status(500).json({ message: '서버 오류가 발생했습니다.' });
    }
});

// 구독 생성
router.post('/subscriptions', async (req, res) => {
    try {
        const { clubId, planId, startDate, expiryDate, status } = req.body;
        console.log('구독 생성 요청:', { clubId, planId, startDate, expiryDate, status });

        // 트랜잭션 시작
        const result = await sequelize.transaction(async (t) => {
            // 클럽과 플랜이 존재하는지 확인
            const [club, plan] = await Promise.all([
                Club.findByPk(clubId, { transaction: t }),
                SubscriptionPlan.findByPk(planId, {
                    include: [Feature],
                    transaction: t
                })
            ]);

            if (!club) {
                throw new Error('클럽을 찾을 수 없습니다.');
            }

            if (!plan) {
                throw new Error('구독 플랜을 찾을 수 없습니다.');
            }

            // 기존 활성 구독이 있는지 확인
            const existingSubscription = await ClubSubscription.findOne({
                where: {
                    clubId,
                    status: 'active'
                },
                transaction: t
            });

            if (existingSubscription) {
                throw new Error('이미 활성화된 구독이 있습니다.');
            }

            // 구독 생성
            const subscription = await ClubSubscription.create({
                clubId,
                planId,
                startDate: startDate || new Date(),
                endDate: expiryDate,
                status: status || 'active',
                price: plan.price
            }, { transaction: t });

            // 플랜의 기능들을 클럽에 연결
            if (plan.Features && plan.Features.length > 0) {
                const features = plan.Features.map(feature => ({
                    clubId,
                    featureId: feature.id,
                    enabled: true,
                    expiryDate,
                    createdAt: new Date(),
                    updatedAt: new Date()
                }));

                await ClubFeature.bulkCreate(features, {
                    transaction: t,
                    fields: ['clubId', 'featureId', 'enabled', 'expiryDate', 'createdAt', 'updatedAt']
                });
            }

            return { subscription, features: plan.Features };
        });

        // 응답 데이터 구성
        const response = result.subscription.toJSON();
        response.expiryDate = response.endDate;
        delete response.endDate;
        response.features = result.features;

        res.status(201).json(response);

        await logActivity(req.user.id, 'CREATE_SUBSCRIPTION', `클럽 ${clubId}의 새 구독을 생성했습니다.`);
    } catch (error) {
        console.error('구독 생성 중 오류 발생:', error);
        console.error('오류 상세:', error.stack);
        res.status(error.message.includes('찾을 수 없습니다') ? 404 : 
                  error.message.includes('이미 활성화된') ? 400 : 500)
           .json({ message: error.message || '서버 오류가 발생했습니다.' });
    }
});

// 구독 수정
router.put('/subscriptions/:id', async (req, res) => {
    try {
        const { id } = req.params;
        const { planId, startDate, expiryDate, status } = req.body;

        const subscription = await ClubSubscription.findByPk(id, {
            include: [Club, SubscriptionPlan]
        });

        if (!subscription) {
            return res.status(404).json({ message: '구독을 찾을 수 없습니다.' });
        }

        // 플랜이 변경되는 경우 새 플랜 확인
        let newPlan = null;
        if (planId && planId !== subscription.planId) {
            newPlan = await SubscriptionPlan.findByPk(planId);
            if (!newPlan) {
                return res.status(404).json({ message: '구독 플랜을 찾을 수 없습니다.' });
            }
        }

        // 구독 정보 업데이트
        await subscription.update({
            planId: planId || subscription.planId,
            startDate: startDate || subscription.startDate,
            endDate: expiryDate || subscription.endDate,
            status: status || subscription.status,
            price: newPlan ? newPlan.price : subscription.price
        });

        // 플랜이 변경된 경우 기능도 업데이트
        if (newPlan) {
            const planFeatures = await newPlan.getFeatures();
            await subscription.Club.setFeatures(planFeatures);
        }

        // 업데이트된 구독 정보 조회
        const updatedSubscription = await ClubSubscription.findByPk(id, {
            include: [{
                model: SubscriptionPlan,
                include: [Feature]
            }]
        });

        // endDate를 expiryDate로 변환
        const result = updatedSubscription.toJSON();
        result.expiryDate = result.endDate;
        delete result.endDate;

        res.json(result);

        await logActivity(req.user.id, 'UPDATE_SUBSCRIPTION', `구독 ${id}를 수정했습니다.`);
    } catch (error) {
        console.error('구독 수정 중 오류:', error);
        res.status(500).json({ message: '서버 오류가 발생했습니다.' });
    }
});

// 구독 삭제
router.delete('/subscriptions/:id', async (req, res) => {
    try {
        const { id } = req.params;

        const subscription = await ClubSubscription.findByPk(id);
        if (!subscription) {
            return res.status(404).json({ message: '구독을 찾을 수 없습니다.' });
        }

        // 구독과 관련된 기능들을 제거
        const club = await Club.findByPk(subscription.clubId);
        if (club) {
            await club.setFeatures([]);
        }

        await subscription.destroy();

        res.json({ message: '구독이 삭제되었습니다.' });

        await logActivity(req.user.id, 'DELETE_SUBSCRIPTION', `구독 ${id}를 삭제했습니다.`);
    } catch (error) {
        console.error('구독 삭제 중 오류:', error);
        res.status(500).json({ message: '서버 오류가 발생했습니다.' });
    }
});

// 구독 목록 조회
router.get('/subscriptions', async (req, res) => {
    try {
        const subscriptions = await ClubSubscription.findAll({
            include: [{
                model: Club,
                attributes: ['id', 'name']
            }, {
                model: SubscriptionPlan,
                include: [Feature]
            }],
            order: [['createdAt', 'DESC']]
        });

        const formattedSubscriptions = subscriptions.map(subscription => {
            const data = subscription.toJSON();
            data.expiryDate = data.endDate;
            delete data.endDate;
            return data;
        });

        res.json(formattedSubscriptions);

        await logActivity(req.user.id, 'VIEW_SUBSCRIPTIONS', '구독 목록을 조회했습니다.');
    } catch (error) {
        console.error('구독 목록 조회 중 오류:', error);
        res.status(500).json({ message: '서버 오류가 발생했습니다.' });
    }
});

// 특정 구독 조회
router.get('/subscriptions/:id', async (req, res) => {
    try {
        const { id } = req.params;

        const subscription = await ClubSubscription.findByPk(id, {
            include: [{
                model: Club,
                attributes: ['id', 'name']
            }, {
                model: SubscriptionPlan,
                include: [Feature]
            }]
        });

        if (!subscription) {
            return res.status(404).json({ message: '구독을 찾을 수 없습니다.' });
        }

        res.json(subscription);

        await logActivity(req.user.id, 'VIEW_SUBSCRIPTION', `구독 ${id}를 조회했습니다.`);
    } catch (error) {
        console.error('구독 조회 중 오류:', error);
        res.status(500).json({ message: '서버 오류가 발생했습니다.' });
    }
});

// 특정 플랜의 구독 목록 조회
router.get('/subscriptions/plans/:planId/subscriptions', async (req, res) => {
    try {
        const { planId } = req.params;

        const subscriptions = await ClubSubscription.findAll({
            where: {
                planId
            },
            include: [
                {
                    model: Club,
                    attributes: ['id', 'name']
                },
                {
                    model: SubscriptionPlan,
                    include: [Feature]
                }
            ],
            order: [['createdAt', 'DESC']]
        });

        const formattedSubscriptions = subscriptions.map(subscription => {
            const data = subscription.toJSON();
            data.expiryDate = data.endDate;
            delete data.endDate;
            return data;
        });

        res.json(formattedSubscriptions);

        await logActivity(req.user.id, 'VIEW_PLAN_SUBSCRIPTIONS', `플랜 ${planId}의 구독 목록을 조회했습니다.`);
    } catch (error) {
        console.error('플랜별 구독 목록 조회 중 오류:', error);
        res.status(500).json({ message: '서버 오류가 발생했습니다.' });
    }
});

// 클럽 상세 조회
router.get('/clubs/:id', async (req, res) => {
    try {
        const { id } = req.params;
        const club = await Club.findByPk(id, {
            include: [
                {
                    model: User,
                    as: 'owner',
                    attributes: ['id', 'name', 'email']
                },
                {
                    model: ClubFeature,
                    include: [{
                        model: Feature,
                        attributes: ['id', 'name', 'code', 'description']
                    }]
                },
                {
                    model: ClubSubscription,
                    where: {
                        status: 'active'
                    },
                    required: false,
                    include: [{
                        model: SubscriptionPlan,
                        include: [Feature]
                    }]
                }
            ]
        });

        if (!club) {
            return res.status(404).json({ message: '클럽을 찾을 수 없습니다.' });
        }

        // 응답 데이터 구성
        const response = club.toJSON();
        
        // 활성 구독이 있는 경우 구독 정보 포맷팅
        if (response.ClubSubscriptions && response.ClubSubscriptions.length > 0) {
            const subscription = response.ClubSubscriptions[0];
            response.activeSubscription = {
                id: subscription.id,
                startDate: subscription.startDate,
                expiryDate: subscription.endDate,
                plan: subscription.SubscriptionPlan
            };
        }
        delete response.ClubSubscriptions;

        // 기능 정보 포맷팅
        const formattedFeatures = response.ClubFeatures.map(feature => ({
            ...feature.Feature,
            enabled: feature.enabled,
            expiryDate: feature.expiryDate
        }));
        response.features = formattedFeatures;
        delete response.ClubFeatures;

        res.json(response);
        await logActivity(req.user.id, 'VIEW_CLUB', `클럽 ${id}의 정보를 조회했습니다.`);
    } catch (error) {
        console.error('클럽 조회 중 오류:', error);
        res.status(500).json({ message: '서버 오류가 발생했습니다.' });
    }
});

// 새 클럽 생성
router.post('/clubs', authenticateJWT, clubController.createClub);

// 클럽 수정
router.put('/clubs/:id', authenticateJWT, clubController.updateClub);

// 클럽 기능 관리
router.put('/clubs/:id/features', async (req, res) => {
    const t = await sequelize.transaction();
    
    try {
        const { id } = req.params;
        const { features } = req.body;

        const club = await Club.findByPk(id, { transaction: t });
        if (!club) {
            await t.rollback();
            return res.status(404).json({ message: '클럽을 찾을 수 없습니다.' });
        }

        // 기존 기능 목록 조회
        const existingFeatures = await ClubFeature.findAll({
            where: { clubId: id },
            transaction: t
        });

        // 기능 업데이트 또는 생성
        for (const feature of features) {
            const existingFeature = existingFeatures.find(ef => ef.featureId === feature.id);
            
            if (existingFeature) {
                await existingFeature.update({
                    enabled: feature.enabled,
                    expiryDate: feature.expiryDate
                }, { transaction: t });
            } else {
                await ClubFeature.create({
                    clubId: id,
                    featureId: feature.id,
                    enabled: feature.enabled,
                    expiryDate: feature.expiryDate
                }, { transaction: t });
            }
        }

        // 제거된 기능 처리
        const featureIds = features.map(f => f.id);
        await ClubFeature.destroy({
            where: {
                clubId: id,
                featureId: {
                    [Op.notIn]: featureIds
                }
            },
            transaction: t
        });

        await t.commit();

        // 업데이트된 클럽 정보 조회
        const updatedClub = await Club.findByPk(id, {
            include: [{
                model: Feature,
                through: {
                    attributes: ['enabled', 'expiryDate']
                }
            }]
        });

        const response = updatedClub.toJSON();
        response.features = response.Features.map(feature => ({
            ...feature,
            enabled: feature.ClubFeature.enabled,
            expiryDate: feature.ClubFeature.expiryDate
        }));
        delete response.Features;

        res.json(response);
        await logActivity(req.user.id, 'UPDATE_CLUB_FEATURES', `클럽 ${id}의 기능을 수정했습니다.`);
    } catch (error) {
        await t.rollback();
        console.error('클럽 기능 수정 중 오류:', error);
        res.status(500).json({ message: '서버 오류가 발생했습니다.' });
    }
});

// 에러 처리 미들웨어
const errorHandler = (err, req, res, next) => {
    console.error('에러 발생:', err);
    res.status(500).json({ 
        message: '서버 오류가 발생했습니다.',
        error: process.env.NODE_ENV === 'development' ? err.message : undefined
    });
};

router.use(errorHandler);

module.exports = router;
