const { pool } = require('../config/database');

// 创建群组表
const createGroupTable = async () => {
    try {
        await pool.query(`
            CREATE TABLE IF NOT EXISTS groups (
                id INT AUTO_INCREMENT PRIMARY KEY,
                group_id VARCHAR(50) NOT NULL UNIQUE,
                group_name VARCHAR(100) NOT NULL,
                creator_id VARCHAR(50) NOT NULL,
                is_active BOOLEAN DEFAULT TRUE,
                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
            )
        `);
    } catch (error) {
        console.error('创建群组表失败:', error);
    }
};

// 初始化表
createGroupTable();

// 群组相关方法
const Group = {
    // 获取所有群组
    findAll: async () => {
        try {
            const [rows] = await pool.query('SELECT * FROM groups ORDER BY created_at DESC');
            return rows;
        } catch (error) {
            console.error('查询群组列表失败:', error);
            throw error;
        }
    },

    // 根据ID查找群组
    findById: async (id) => {
        try {
            const [rows] = await pool.query(
                'SELECT * FROM groups WHERE id = ?',
                [id]
            );
            return rows[0];
        } catch (error) {
            console.error('查询群组失败:', error);
            throw error;
        }
    },

    // 根据群组ID查找群组
    findByGroupId: async (groupId) => {
        const [rows] = await pool.query(
            'SELECT * FROM groups WHERE group_id = ?',
            [groupId]
        );
        return rows[0];
    },

    // 创建群组
    create: async ({ 
        group_id, 
        group_name, 
        group_type = 'group',
        creator_id,
        admin_id,
        in_fee_rate = 0,
        in_exchange_rate = 1,
        out_fee_rate = 0,
        out_exchange_rate = 1
    }) => {
        try {
            const [result] = await pool.query(
                `INSERT INTO groups (
                    group_id, 
                    group_name, 
                    group_type,
                    creator_id,
                    admin_id,
                    in_fee_rate,
                    in_exchange_rate,
                    out_fee_rate,
                    out_exchange_rate
                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
                [
                    group_id,
                    group_name,
                    group_type,
                    creator_id,
                    admin_id,
                    in_fee_rate,
                    in_exchange_rate,
                    out_fee_rate,
                    out_exchange_rate
                ]
            );
            return result.insertId;
        } catch (error) {
            console.error('创建群组失败:', error);
            throw error;
        }
    },

    // 更新群组
    update: async (id, { 
        group_name, 
        is_active, 
        in_fee_rate, 
        in_exchange_rate, 
        out_fee_rate, 
        out_exchange_rate 
    }) => {
        try {
            const [result] = await pool.query(
                `UPDATE groups 
                SET group_name = ?,
                    is_active = ?,
                    in_fee_rate = ?,
                    in_exchange_rate = ?,
                    out_fee_rate = ?,
                    out_exchange_rate = ?,
                    updated_at = CURRENT_TIMESTAMP
                WHERE id = ?`,
                [
                    group_name,
                    is_active,
                    in_fee_rate,
                    in_exchange_rate,
                    out_fee_rate,
                    out_exchange_rate,
                    id
                ]
            );

            if (result.affectedRows === 0) {
                throw new Error('群组不存在');
            }

            return result;
        } catch (error) {
            console.error('更新群组失败:', error);
            throw error;
        }
    },

    // 删除群组
    delete: async (id) => {
        try {
            const [result] = await pool.query('DELETE FROM groups WHERE id = ?', [id]);
            if (result.affectedRows === 0) {
                throw new Error('群组不存在');
            }
            return result;
        } catch (error) {
            console.error('删除群组失败:', error);
            throw error;
        }
    },

    // 添加操作人
    addOperator: async (groupId, { operator_id, operator_username, added_by }) => {
        try {
            // 获取当前群组信息
            const [group] = await pool.query(
                'SELECT operators FROM groups WHERE group_id = ?',
                [groupId]
            );

            if (!group[0]) {
                throw new Error('群组不存在');
            }

            // 解析现有的操作人列表，如果为null则初始化为空数组
            const operators = group[0].operators ? JSON.parse(group[0].operators) : [];

            // 检查操作人是否已存在
            if (operators.some(op => op.operator_id === operator_id)) {
                throw new Error('该用户已经是操作人');
            }

            // 添加新操作人
            operators.push({
                operator_id,
                operator_username,
                added_by,
                added_at: new Date().toISOString()
            });

            // 更新群组
            await pool.query(
                'UPDATE groups SET operators = ? WHERE group_id = ?',
                [JSON.stringify(operators), groupId]
            );

            return true;
        } catch (error) {
            console.error('添加操作人失败:', error);
            throw error;
        }
    },

    // 检查用户是否是操作人
    isOperator: async (groupId, operatorId) => {
        try {
            const [group] = await pool.query(
                'SELECT operators FROM groups WHERE group_id = ?',
                [groupId]
            );

            if (!group[0] || !group[0].operators) {
                return false;
            }

            const operators = JSON.parse(group[0].operators);
            return operators.some(op => op.operator_id === operatorId);
        } catch (error) {
            console.error('检查操作人状态失败:', error);
            throw error;
        }
    },

    // 获取群组的所有操作人
    getOperators: async (groupId) => {
        try {
            const [group] = await pool.query(
                'SELECT operators FROM groups WHERE group_id = ?',
                [groupId]
            );

            if (!group[0] || !group[0].operators) {
                return [];
            }

            return JSON.parse(group[0].operators);
        } catch (error) {
            console.error('获取群组操作人列表失败:', error);
            throw error;
        }
    },

    // 删除操作人
    removeOperator: async (groupId, operatorId) => {
        try {
            // 获取当前群组信息
            const [group] = await pool.query(
                'SELECT operators FROM groups WHERE group_id = ?',
                [groupId]
            );

            if (!group[0] || !group[0].operators) {
                throw new Error('群组不存在或没有操作人');
            }

            // 解析现有的操作人列表
            const operators = JSON.parse(group[0].operators);

            // 过滤掉要删除的操作人
            const updatedOperators = operators.filter(op => op.operator_id !== operatorId);

            // 如果操作人列表没有变化，说明要删除的操作人不存在
            if (operators.length === updatedOperators.length) {
                return false;
            }

            // 更新群组
            await pool.query(
                'UPDATE groups SET operators = ? WHERE group_id = ?',
                [JSON.stringify(updatedOperators), groupId]
            );

            return true;
        } catch (error) {
            console.error('删除操作人失败:', error);
            throw error;
        }
    }
};

module.exports = Group;