# -*- coding: utf-8 -*-
"""
股票社区 API - Discord 风格
包含：频道、消息、帖子、回复、表情反应等接口
"""

import uuid
from datetime import datetime
from functools import wraps

from flask import Blueprint, request, jsonify, session, g, current_app
from elasticsearch import Elasticsearch
from sqlalchemy import text

# ============================================================
# Blueprint 定义
# ============================================================

community_bp = Blueprint('community', __name__, url_prefix='/api/community')

# ES 客户端
es_client = Elasticsearch(
    hosts=["http://222.128.1.157:19200"],
    request_timeout=30,
    max_retries=3,
    retry_on_timeout=True
)

# 注意：数据库连接从 app.py 的 db 对象获取，不再独立创建
# engine 变量会在 Blueprint 注册后通过 app context 获取

engine = None  # 将在第一次请求时初始化
socketio_instance = None  # 将在注册时设置

def get_db_engine():
    """获取数据库引擎（延迟初始化）"""
    global engine
    if engine is None:
        from flask import current_app
        # 从 app.py 的 SQLAlchemy 实例获取 engine
        from app import db
        engine = db.engine
    return engine


# ============================================================
# 工具函数
# ============================================================

def generate_id():
    """生成唯一 ID"""
    return str(uuid.uuid4()).replace('-', '')[:16]


def get_current_user():
    """获取当前登录用户"""
    user_id = session.get('user_id')
    if not user_id:
        return None
    return {
        'id': str(user_id),
        'username': session.get('username', '匿名用户'),
        'avatar': session.get('avatar', ''),
    }


def login_required(f):
    """登录验证装饰器"""
    @wraps(f)
    def decorated_function(*args, **kwargs):
        user = get_current_user()
        if not user:
            return jsonify({'code': 401, 'message': '请先登录'}), 401
        g.current_user = user
        return f(*args, **kwargs)
    return decorated_function


def get_user_admin_info(user_id):
    """获取用户管理员信息"""
    try:
        with get_db_engine().connect() as conn:
            sql = text("""
                SELECT role, permissions
                FROM community_admins
                WHERE user_id = :user_id
            """)
            print(f"[Community API] 查询管理员信息: user_id={user_id}, type={type(user_id)}")
            result = conn.execute(sql, {'user_id': int(user_id)}).fetchone()
            print(f"[Community API] 查询结果: {result}")
            if result:
                import json
                permissions = result.permissions
                if isinstance(permissions, str):
                    permissions = json.loads(permissions)
                admin_info = {
                    'role': result.role,
                    'permissions': permissions or {},
                    'isAdmin': result.role == 'admin',
                    'isModerator': result.role in ['admin', 'moderator']
                }
                print(f"[Community API] 返回管理员信息: {admin_info}")
                return admin_info
    except Exception as e:
        print(f"[Community API] 获取管理员信息失败: {e}")
        import traceback
        traceback.print_exc()
    return None


def check_permission(user_id, permission):
    """检查用户是否有指定权限"""
    admin_info = get_user_admin_info(user_id)
    if not admin_info:
        return False
    if admin_info['isAdmin']:
        return True
    return admin_info['permissions'].get(permission, False)


def admin_required(permission=None):
    """管理员权限验证装饰器"""
    def decorator(f):
        @wraps(f)
        def decorated_function(*args, **kwargs):
            user = get_current_user()
            if not user:
                return jsonify({'code': 401, 'message': '请先登录'}), 401
            g.current_user = user

            # 检查权限
            if permission:
                if not check_permission(user['id'], permission):
                    return jsonify({'code': 403, 'message': '无权限执行此操作'}), 403
            else:
                admin_info = get_user_admin_info(user['id'])
                if not admin_info:
                    return jsonify({'code': 403, 'message': '需要管理员权限'}), 403

            g.admin_info = get_user_admin_info(user['id'])
            return f(*args, **kwargs)
        return decorated_function
    return decorator


def get_channel_admin_info(channel_id, user_id):
    """获取用户在指定频道的管理员信息"""
    # 先检查是否是超级管理员
    super_admin = get_user_admin_info(user_id)
    if super_admin and super_admin['isAdmin']:
        return {
            'role': 'super_admin',
            'isSuperAdmin': True,
            'isOwner': True,
            'isAdmin': True,
            'isModerator': True,
            'permissions': {
                'delete_channel': True,
                'edit_channel': True,
                'manage_admins': True,
                'pin_messages': True,
                'delete_messages': True,
                'slow_mode': True,
                'lock_channel': True
            }
        }

    # 检查频道管理员
    try:
        with get_db_engine().connect() as conn:
            sql = text("""
                SELECT role, permissions
                FROM community_channel_admins
                WHERE channel_id = :channel_id AND user_id = :user_id
            """)
            result = conn.execute(sql, {
                'channel_id': channel_id,
                'user_id': int(user_id)
            }).fetchone()

            if result:
                import json
                permissions = result.permissions
                if isinstance(permissions, str):
                    permissions = json.loads(permissions)

                role = result.role
                return {
                    'role': role,
                    'isSuperAdmin': False,
                    'isOwner': role == 'owner',
                    'isAdmin': role in ['owner', 'admin'],
                    'isModerator': role in ['owner', 'admin', 'moderator'],
                    'permissions': permissions or {}
                }
    except Exception as e:
        print(f"[Community API] 获取频道管理员信息失败: {e}")

    return None


def check_channel_permission(channel_id, user_id, permission):
    """检查用户是否有指定频道的权限"""
    admin_info = get_channel_admin_info(channel_id, user_id)
    if not admin_info:
        return False
    if admin_info['isSuperAdmin'] or admin_info['isOwner']:
        return True
    return admin_info['permissions'].get(permission, False)


def add_channel_admin(channel_id, user_id, role='owner'):
    """添加频道管理员"""
    try:
        with get_db_engine().connect() as conn:
            # 根据角色设置默认权限
            permissions = {}
            if role == 'owner':
                permissions = {
                    'delete_channel': True,
                    'edit_channel': True,
                    'manage_admins': True,
                    'pin_messages': True,
                    'delete_messages': True,
                    'slow_mode': True,
                    'lock_channel': True
                }
            elif role == 'admin':
                permissions = {
                    'edit_channel': True,
                    'pin_messages': True,
                    'delete_messages': True,
                    'slow_mode': True
                }
            elif role == 'moderator':
                permissions = {
                    'pin_messages': True,
                    'delete_messages': True
                }

            import json
            sql = text("""
                INSERT INTO community_channel_admins (channel_id, user_id, role, permissions)
                VALUES (:channel_id, :user_id, :role, :permissions)
                ON DUPLICATE KEY UPDATE role = :role, permissions = :permissions
            """)
            conn.execute(sql, {
                'channel_id': channel_id,
                'user_id': int(user_id),
                'role': role,
                'permissions': json.dumps(permissions)
            })
            conn.commit()
            return True
    except Exception as e:
        print(f"[Community API] 添加频道管理员失败: {e}")
        return False


def api_response(data=None, message='success', code=200):
    """统一 API 响应格式"""
    return jsonify({
        'code': code,
        'message': message,
        'data': data
    })


def api_error(message, code=400):
    """API 错误响应"""
    return jsonify({
        'code': code,
        'message': message
    }), code if code >= 400 else 400


# ============================================================
# 在线成员 API
# ============================================================

@community_bp.route('/members/online', methods=['GET'])
def get_online_members_api():
    """获取当前在线成员列表"""
    members = get_online_members()
    return api_response(members)


# ============================================================
# 用户管理员状态 API
# ============================================================

@community_bp.route('/me/admin-status', methods=['GET'])
@login_required
def get_my_admin_status():
    """获取当前用户的管理员状态"""
    user = g.current_user
    print(f"[Community API] /me/admin-status 请求, user={user}")
    admin_info = get_user_admin_info(user['id'])
    print(f"[Community API] /me/admin-status admin_info={admin_info}")

    if admin_info:
        return api_response({
            'isAdmin': admin_info['isAdmin'],
            'isModerator': admin_info['isModerator'],
            'role': admin_info['role'],
            'permissions': admin_info['permissions']
        })
    else:
        return api_response({
            'isAdmin': False,
            'isModerator': False,
            'role': None,
            'permissions': {}
        })


@community_bp.route('/channels/<channel_id>/admin-status', methods=['GET'])
@login_required
def get_channel_admin_status(channel_id):
    """获取当前用户在指定频道的管理员状态"""
    user = g.current_user
    admin_info = get_channel_admin_info(channel_id, user['id'])

    if admin_info:
        return api_response({
            'role': admin_info['role'],
            'isSuperAdmin': admin_info['isSuperAdmin'],
            'isOwner': admin_info['isOwner'],
            'isAdmin': admin_info['isAdmin'],
            'isModerator': admin_info['isModerator'],
            'permissions': admin_info['permissions']
        })
    else:
        return api_response({
            'role': None,
            'isSuperAdmin': False,
            'isOwner': False,
            'isAdmin': False,
            'isModerator': False,
            'permissions': {}
        })


@community_bp.route('/channels/<channel_id>/admins', methods=['GET'])
@login_required
def get_channel_admins(channel_id):
    """获取频道管理员列表（包含超级管理员）"""
    try:
        import json
        admins = []

        with get_db_engine().connect() as conn:
            # 1. 先获取全局超级管理员
            # 注意：users 表可能没有 avatar 字段，使用 NULL 作为默认值
            super_admin_sql = text("""
                SELECT ca.user_id, u.username
                FROM community_admins ca
                LEFT JOIN user u ON ca.user_id = u.id
                WHERE ca.role = 'admin'
            """)
            super_admins = conn.execute(super_admin_sql).fetchall()

            for row in super_admins:
                admins.append({
                    'userId': str(row.user_id),
                    'username': row.username or f'用户{row.user_id}',
                    'avatar': None,
                    'role': 'super_admin',  # 特殊标记
                    'isSuperAdmin': True,
                    'permissions': {
                        'delete_channel': True,
                        'edit_channel': True,
                        'manage_admins': True,
                        'pin_messages': True,
                        'delete_messages': True,
                        'slow_mode': True,
                        'lock_channel': True
                    },
                    'createdAt': None
                })

            # 2. 获取频道管理员（排除已在超级管理员列表中的用户）
            super_admin_ids = [str(row.user_id) for row in super_admins]

            # 检查 community_channel_admins 表是否存在
            try:
                sql = text("""
                    SELECT cca.user_id, cca.role, cca.permissions, cca.created_at,
                           u.username
                    FROM community_channel_admins cca
                    LEFT JOIN user u ON cca.user_id = u.id
                    WHERE cca.channel_id = :channel_id
                    ORDER BY
                        CASE cca.role
                            WHEN 'owner' THEN 1
                            WHEN 'admin' THEN 2
                            WHEN 'moderator' THEN 3
                        END
                """)
                result = conn.execute(sql, {'channel_id': channel_id}).fetchall()

                for row in result:
                    # 跳过已在超级管理员列表中的用户
                    if str(row.user_id) in super_admin_ids:
                        continue

                    permissions = row.permissions
                    if isinstance(permissions, str):
                        permissions = json.loads(permissions)

                    admins.append({
                        'userId': str(row.user_id),
                        'username': row.username or f'用户{row.user_id}',
                        'avatar': None,
                        'role': row.role,
                        'isSuperAdmin': False,
                        'permissions': permissions or {},
                        'createdAt': row.created_at.isoformat() if row.created_at else None
                    })
            except Exception as table_err:
                # 表不存在时忽略，只返回超级管理员
                print(f"[Community API] 频道管理员表查询失败（可能表不存在）: {table_err}")

            return api_response(admins)

    except Exception as e:
        print(f"[Community API] 获取频道管理员列表失败: {e}")
        import traceback
        traceback.print_exc()
        return api_error(f'获取管理员列表失败: {str(e)}', 500)


@community_bp.route('/channels/<channel_id>/admins', methods=['POST'])
@login_required
def add_channel_admin_api(channel_id):
    """添加频道管理员（需要 owner 或超级管理员权限）"""
    user = g.current_user

    # 检查权限
    if not check_channel_permission(channel_id, user['id'], 'manage_admins'):
        return api_error('无权限管理频道管理员', 403)

    data = request.get_json()
    target_user_id = data.get('userId')
    role = data.get('role', 'moderator')

    if not target_user_id:
        return api_error('请指定用户ID')

    if role not in ['admin', 'moderator']:
        return api_error('无效的角色，只能设置 admin 或 moderator')

    # 不能设置为 owner（owner 只能是创建者）
    if add_channel_admin(channel_id, target_user_id, role):
        return api_response({'success': True, 'message': f'已添加 {role}'})
    else:
        return api_error('添加管理员失败', 500)


@community_bp.route('/channels/<channel_id>/admins/<user_id>', methods=['DELETE'])
@login_required
def remove_channel_admin_api(channel_id, user_id):
    """移除频道管理员（需要 owner 或超级管理员权限）"""
    current_user = g.current_user

    # 检查权限
    if not check_channel_permission(channel_id, current_user['id'], 'manage_admins'):
        return api_error('无权限管理频道管理员', 403)

    # 不能移除 owner
    target_admin = get_channel_admin_info(channel_id, user_id)
    if target_admin and target_admin['isOwner'] and not target_admin['isSuperAdmin']:
        return api_error('不能移除频道创建者', 400)

    try:
        with get_db_engine().connect() as conn:
            sql = text("""
                DELETE FROM community_channel_admins
                WHERE channel_id = :channel_id AND user_id = :user_id
            """)
            conn.execute(sql, {
                'channel_id': channel_id,
                'user_id': int(user_id)
            })
            conn.commit()
            return api_response({'success': True, 'message': '已移除管理员'})
    except Exception as e:
        print(f"[Community API] 移除频道管理员失败: {e}")
        return api_error(f'移除管理员失败: {str(e)}', 500)


# ============================================================
# 频道相关 API
# ============================================================

@community_bp.route('/channels', methods=['GET'])
def get_channels():
    """
    获取频道列表（按分类组织）
    返回格式：[{ id, name, icon, channels: [...] }, ...]
    """
    try:
        with get_db_engine().connect() as conn:
            # 查询分类
            categories_sql = text("""
                SELECT id, name, icon, position, is_collapsible, is_system
                FROM community_categories
                ORDER BY position
            """)
            categories_result = conn.execute(categories_sql).fetchall()

            # 查询频道
            channels_sql = text("""
                SELECT
                    c.id, c.category_id, c.name, c.type, c.topic, c.position,
                    c.concept_code, c.slow_mode, c.is_readonly, c.is_system,
                    c.subscriber_count, c.message_count, c.last_message_at,
                    cc.concept_name, cc.stock_count, cc.is_hot
                FROM community_channels c
                LEFT JOIN community_concept_channels cc ON c.concept_code = cc.concept_code
                WHERE c.is_visible = 1
                ORDER BY c.position
            """)
            channels_result = conn.execute(channels_sql).fetchall()

        # 组装数据
        channels_by_category = {}
        for ch in channels_result:
            cat_id = ch.category_id
            if cat_id not in channels_by_category:
                channels_by_category[cat_id] = []
            channels_by_category[cat_id].append({
                'id': ch.id,
                'categoryId': ch.category_id,
                'name': ch.name,
                'type': ch.type,
                'topic': ch.topic,
                'position': ch.position,
                'conceptCode': ch.concept_code,
                'slowMode': ch.slow_mode or 0,
                'isReadonly': bool(ch.is_readonly),
                'isSystem': bool(ch.is_system),
                'subscriberCount': ch.subscriber_count or 0,
                'messageCount': ch.message_count or 0,
                'lastMessageAt': ch.last_message_at.isoformat() if ch.last_message_at else None,
                'conceptName': ch.concept_name,
                'stockCount': ch.stock_count,
                'isHot': bool(ch.is_hot) if ch.is_hot is not None else False,
            })

        result = []
        for cat in categories_result:
            result.append({
                'id': cat.id,
                'name': cat.name,
                'icon': cat.icon or '',
                'position': cat.position,
                'isCollapsible': bool(cat.is_collapsible),
                'isSystem': bool(cat.is_system),
                'channels': channels_by_category.get(cat.id, [])
            })

        return api_response(result)

    except Exception as e:
        print(f"[Community API] 获取频道列表失败: {e}")
        return api_error(f'获取频道列表失败: {str(e)}', 500)


@community_bp.route('/channels/<channel_id>', methods=['GET'])
def get_channel(channel_id):
    """获取单个频道详情"""
    try:
        with get_db_engine().connect() as conn:
            sql = text("""
                SELECT
                    c.*, cc.concept_name, cc.stock_count, cc.is_hot
                FROM community_channels c
                LEFT JOIN community_concept_channels cc ON c.concept_code = cc.concept_code
                WHERE c.id = :channel_id
            """)
            result = conn.execute(sql, {'channel_id': channel_id}).fetchone()

        if not result:
            return api_error('频道不存在', 404)

        return api_response({
            'id': result.id,
            'categoryId': result.category_id,
            'name': result.name,
            'type': result.type,
            'topic': result.topic,
            'conceptCode': result.concept_code,
            'slowMode': result.slow_mode or 0,
            'isReadonly': bool(result.is_readonly),
            'subscriberCount': result.subscriber_count or 0,
            'messageCount': result.message_count or 0,
            'conceptName': result.concept_name,
            'stockCount': result.stock_count,
            'isHot': bool(result.is_hot) if result.is_hot is not None else False,
        })

    except Exception as e:
        return api_error(f'获取频道失败: {str(e)}', 500)


@community_bp.route('/channels', methods=['POST'])
@login_required
def create_channel():
    """
    创建新频道
    请求体: { name, type, topic?, categoryId }
    """
    try:
        user = g.current_user
        data = request.get_json()

        name = data.get('name', '').strip()
        channel_type = data.get('type', 'text')
        topic = data.get('topic', '').strip()
        category_id = data.get('categoryId')

        if not name:
            return api_error('频道名称不能为空')

        if len(name) > 50:
            return api_error('频道名称不能超过50个字符')

        if channel_type not in ['text', 'forum', 'voice', 'announcement', 'prediction']:
            return api_error('无效的频道类型')

        channel_id = f"ch_{generate_id()}"
        now = datetime.utcnow()

        with get_db_engine().connect() as conn:
            # 如果没有指定分类，使用默认分类（自由讨论）
            if not category_id:
                default_cat_sql = text("""
                    SELECT id FROM community_categories
                    WHERE name = '自由讨论' OR name LIKE '%讨论%'
                    ORDER BY position
                    LIMIT 1
                """)
                default_cat = conn.execute(default_cat_sql).fetchone()
                if default_cat:
                    category_id = default_cat.id
                else:
                    # 如果没有找到，使用第一个分类
                    first_cat_sql = text("SELECT id FROM community_categories ORDER BY position LIMIT 1")
                    first_cat = conn.execute(first_cat_sql).fetchone()
                    if first_cat:
                        category_id = first_cat.id
                    else:
                        return api_error('没有可用的分类，请先创建分类')

            # 获取当前分类下最大的 position
            max_pos_sql = text("""
                SELECT COALESCE(MAX(position), 0) as max_pos
                FROM community_channels
                WHERE category_id = :category_id
            """)
            max_pos_result = conn.execute(max_pos_sql, {'category_id': category_id}).fetchone()
            next_position = (max_pos_result.max_pos or 0) + 1

            # 插入新频道
            insert_sql = text("""
                INSERT INTO community_channels
                (id, category_id, name, type, topic, position, slow_mode, is_readonly,
                 is_visible, is_system, subscriber_count, message_count, created_at, updated_at)
                VALUES
                (:id, :category_id, :name, :type, :topic, :position, 0, 0,
                 1, 0, 0, 0, :now, :now)
            """)
            conn.execute(insert_sql, {
                'id': channel_id,
                'category_id': category_id,
                'name': name,
                'type': channel_type,
                'topic': topic,
                'position': next_position,
                'now': now,
            })
            conn.commit()

        # 将创建者设为频道管理员（owner）
        add_channel_admin(channel_id, user['id'], role='owner')

        # 返回创建的频道信息
        response_data = {
            'id': channel_id,
            'categoryId': category_id,
            'name': name,
            'type': channel_type,
            'topic': topic,
            'position': next_position,
            'slowMode': 0,
            'isReadonly': False,
            'isSystem': False,
            'subscriberCount': 0,
            'messageCount': 0,
            'createdAt': now.isoformat(),
            'isOwner': True,  # 创建者自动是 owner
        }

        print(f"[Community API] 创建频道成功: {channel_id} - {name}, 创建者: {user['id']}")
        return api_response(response_data)

    except Exception as e:
        print(f"[Community API] 创建频道失败: {e}")
        import traceback
        traceback.print_exc()
        return api_error(f'创建频道失败: {str(e)}', 500)


@community_bp.route('/channels/<channel_id>/subscribe', methods=['POST'])
@login_required
def subscribe_channel(channel_id):
    """订阅频道"""
    try:
        user = g.current_user
        subscription_id = generate_id()

        with get_db_engine().connect() as conn:
            # 检查是否已订阅
            check_sql = text("""
                SELECT id FROM community_subscriptions
                WHERE user_id = :user_id AND channel_id = :channel_id
            """)
            existing = conn.execute(check_sql, {
                'user_id': user['id'],
                'channel_id': channel_id
            }).fetchone()

            if existing:
                return api_response(message='已订阅')

            # 创建订阅
            insert_sql = text("""
                INSERT INTO community_subscriptions (id, user_id, channel_id, notification_level)
                VALUES (:id, :user_id, :channel_id, 'all')
            """)
            conn.execute(insert_sql, {
                'id': subscription_id,
                'user_id': user['id'],
                'channel_id': channel_id
            })

            # 更新订阅数
            update_sql = text("""
                UPDATE community_channels
                SET subscriber_count = subscriber_count + 1
                WHERE id = :channel_id
            """)
            conn.execute(update_sql, {'channel_id': channel_id})
            conn.commit()

        return api_response(message='订阅成功')

    except Exception as e:
        return api_error(f'订阅失败: {str(e)}', 500)


@community_bp.route('/channels/<channel_id>/unsubscribe', methods=['POST'])
@login_required
def unsubscribe_channel(channel_id):
    """取消订阅频道"""
    try:
        user = g.current_user

        with get_db_engine().connect() as conn:
            # 删除订阅
            delete_sql = text("""
                DELETE FROM community_subscriptions
                WHERE user_id = :user_id AND channel_id = :channel_id
            """)
            result = conn.execute(delete_sql, {
                'user_id': user['id'],
                'channel_id': channel_id
            })

            if result.rowcount > 0:
                # 更新订阅数
                update_sql = text("""
                    UPDATE community_channels
                    SET subscriber_count = GREATEST(subscriber_count - 1, 0)
                    WHERE id = :channel_id
                """)
                conn.execute(update_sql, {'channel_id': channel_id})

            conn.commit()

        return api_response(message='取消订阅成功')

    except Exception as e:
        return api_error(f'取消订阅失败: {str(e)}', 500)


# ============================================================
# 消息相关 API（即时聊天）
# ============================================================

@community_bp.route('/channels/<channel_id>/messages', methods=['POST'])
@login_required
def send_message(channel_id):
    """发送消息"""
    try:
        user = g.current_user
        data = request.get_json()

        # 检查频道类型和权限
        with get_db_engine().connect() as conn:
            channel_sql = text("""
                SELECT type, is_readonly FROM community_channels WHERE id = :channel_id
            """)
            channel = conn.execute(channel_sql, {'channel_id': channel_id}).fetchone()
            if not channel:
                return api_error('频道不存在', 404)

            # 公告频道只有管理员可以发消息
            if channel.type == 'announcement':
                admin_info = get_channel_admin_info(channel_id, user['id'])
                if not admin_info or not admin_info.get('isAdmin'):
                    return api_error('只有管理员可以在公告频道发送消息', 403)

            # 只读频道不能发消息
            if channel.is_readonly:
                admin_info = get_channel_admin_info(channel_id, user['id'])
                if not admin_info or not admin_info.get('isAdmin'):
                    return api_error('该频道为只读频道', 403)

        content = data.get('content', '').strip()
        if not content:
            return api_error('消息内容不能为空')

        message_id = generate_id()
        now = datetime.utcnow()

        # 将 Markdown 图片语法转换为 HTML（支持 base64 图片）
        content_html = parse_markdown_images(content)

        # 构建消息文档
        message_doc = {
            'id': message_id,
            'channel_id': channel_id,
            'thread_id': data.get('threadId'),
            'author_id': user['id'],
            'author_name': user['username'],
            'author_avatar': user.get('avatar', ''),
            'content': content,
            'content_html': content_html,  # Markdown 转换后的 HTML
            'type': 'text',
            'mentioned_users': data.get('mentionedUsers', []),
            'mentioned_stocks': data.get('mentionedStocks', []),
            'mentioned_everyone': data.get('mentionedEveryone', False),
            'reply_to': data.get('replyTo'),
            'reactions': {},
            'reaction_count': 0,
            'is_pinned': False,
            'is_edited': False,
            'is_deleted': False,
            'created_at': now.isoformat(),
        }

        # 写入 ES
        es_client.index(
            index='community_messages',
            id=message_id,
            document=message_doc,
            refresh=True
        )

        # 更新频道最后消息时间和消息数
        with get_db_engine().connect() as conn:
            update_sql = text("""
                UPDATE community_channels
                SET message_count = message_count + 1,
                    last_message_id = :message_id,
                    last_message_at = :now
                WHERE id = :channel_id
            """)
            conn.execute(update_sql, {
                'message_id': message_id,
                'now': now,
                'channel_id': channel_id
            })
            conn.commit()

        # 转换字段名为 camelCase
        response_data = {
            'id': message_doc['id'],
            'channelId': message_doc['channel_id'],
            'threadId': message_doc['thread_id'],
            'authorId': message_doc['author_id'],
            'authorName': message_doc['author_name'],
            'authorAvatar': message_doc['author_avatar'],
            'content': message_doc['content'],
            'type': message_doc['type'],
            'mentionedUsers': message_doc['mentioned_users'],
            'mentionedStocks': message_doc['mentioned_stocks'],
            'replyTo': message_doc['reply_to'],
            'reactions': message_doc['reactions'],
            'reactionCount': message_doc['reaction_count'],
            'isPinned': message_doc['is_pinned'],
            'isEdited': message_doc['is_edited'],
            'createdAt': message_doc['created_at'],
        }

        # 通过 WebSocket 广播新消息给频道内的其他用户
        if socketio_instance:
            socketio_instance.emit(
                'MESSAGE_CREATE',
                response_data,
                room=channel_id,
                namespace='/community'
            )

        return api_response(response_data)

    except Exception as e:
        print(f"[Community API] 发送消息失败: {e}")
        return api_error(f'发送消息失败: {str(e)}', 500)


@community_bp.route('/messages/<message_id>/reactions', methods=['POST'])
@login_required
def add_reaction(message_id):
    """添加表情反应"""
    try:
        user = g.current_user
        data = request.get_json()
        emoji = data.get('emoji')

        if not emoji:
            return api_error('请选择表情')

        # 获取当前消息
        result = es_client.get(index='community_messages', id=message_id)
        message = result['_source']

        # 更新 reactions
        reactions = message.get('reactions', {})
        if emoji not in reactions:
            reactions[emoji] = []

        if user['id'] not in reactions[emoji]:
            reactions[emoji].append(user['id'])

        # 计算总数
        reaction_count = sum(len(users) for users in reactions.values())

        # 更新 ES
        es_client.update(
            index='community_messages',
            id=message_id,
            doc={'reactions': reactions, 'reaction_count': reaction_count},
            refresh=True
        )

        return api_response(message='添加成功')

    except Exception as e:
        return api_error(f'添加表情失败: {str(e)}', 500)


@community_bp.route('/messages/<message_id>/reactions/<emoji>', methods=['DELETE'])
@login_required
def remove_reaction(message_id, emoji):
    """移除表情反应"""
    try:
        user = g.current_user

        # 获取当前消息
        result = es_client.get(index='community_messages', id=message_id)
        message = result['_source']

        # 更新 reactions
        reactions = message.get('reactions', {})
        if emoji in reactions and user['id'] in reactions[emoji]:
            reactions[emoji].remove(user['id'])
            if not reactions[emoji]:
                del reactions[emoji]

        # 计算总数
        reaction_count = sum(len(users) for users in reactions.values())

        # 更新 ES
        es_client.update(
            index='community_messages',
            id=message_id,
            doc={'reactions': reactions, 'reaction_count': reaction_count},
            refresh=True
        )

        return api_response(message='移除成功')

    except Exception as e:
        return api_error(f'移除表情失败: {str(e)}', 500)


# ============================================================
# Forum 帖子相关 API
# ============================================================

def parse_markdown_images(content):
    """
    将 Markdown 图片语法转换为 HTML img 标签
    支持 ![alt](url) 格式，包括 base64 data URL
    """
    import re
    # 匹配 ![alt](url) 格式
    pattern = r'!\[([^\]]*)\]\(([^)]+)\)'

    def replace_image(match):
        alt = match.group(1) or '图片'
        url = match.group(2)
        return f'<img src="{url}" alt="{alt}" style="max-width: 100%; border-radius: 8px; margin: 16px 0;" />'

    html = re.sub(pattern, replace_image, content)
    # 将换行转换为 <br>
    html = html.replace('\n', '<br />')
    return html


@community_bp.route('/channels/<channel_id>/posts', methods=['POST'])
@login_required
def create_post(channel_id):
    """创建帖子"""
    try:
        user = g.current_user
        data = request.get_json()

        title = data.get('title', '').strip()
        content = data.get('content', '').strip()

        if not title:
            return api_error('标题不能为空')
        if not content:
            return api_error('内容不能为空')

        post_id = generate_id()
        now = datetime.utcnow()

        # 将 Markdown 图片语法转换为 HTML
        content_html = parse_markdown_images(content)

        # 构建帖子文档
        post_doc = {
            'id': post_id,
            'channel_id': channel_id,
            'author_id': user['id'],
            'author_name': user['username'],
            'author_avatar': user.get('avatar', ''),
            'title': title,
            'content': content,
            'content_html': content_html,  # Markdown 转换后的 HTML
            'tags': data.get('tags', []),
            'stock_symbols': data.get('stockSymbols', []),
            'is_pinned': False,
            'is_locked': False,
            'is_deleted': False,
            'reply_count': 0,
            'view_count': 0,
            'like_count': 0,
            'last_reply_at': None,
            'last_reply_by': None,
            'created_at': now.isoformat(),
            'updated_at': now.isoformat(),
        }

        # 写入 ES
        es_client.index(
            index='community_forum_posts',
            id=post_id,
            document=post_doc,
            refresh=True
        )

        # 更新频道消息数
        with get_db_engine().connect() as conn:
            update_sql = text("""
                UPDATE community_channels
                SET message_count = message_count + 1,
                    last_message_at = :now
                WHERE id = :channel_id
            """)
            conn.execute(update_sql, {'now': now, 'channel_id': channel_id})
            conn.commit()

        # 转换字段名
        response_data = {
            'id': post_doc['id'],
            'channelId': post_doc['channel_id'],
            'authorId': post_doc['author_id'],
            'authorName': post_doc['author_name'],
            'authorAvatar': post_doc['author_avatar'],
            'title': post_doc['title'],
            'content': post_doc['content'],
            'tags': post_doc['tags'],
            'stockSymbols': post_doc['stock_symbols'],
            'isPinned': post_doc['is_pinned'],
            'isLocked': post_doc['is_locked'],
            'replyCount': post_doc['reply_count'],
            'viewCount': post_doc['view_count'],
            'likeCount': post_doc['like_count'],
            'createdAt': post_doc['created_at'],
        }

        return api_response(response_data)

    except Exception as e:
        print(f"[Community API] 创建帖子失败: {e}")
        return api_error(f'创建帖子失败: {str(e)}', 500)


@community_bp.route('/posts/<post_id>/like', methods=['POST'])
@login_required
def like_post(post_id):
    """点赞帖子"""
    try:
        # 更新 ES（简单实现，生产环境应该用单独的点赞表防止重复）
        es_client.update(
            index='community_forum_posts',
            id=post_id,
            script={
                'source': 'ctx._source.like_count += 1',
                'lang': 'painless'
            },
            refresh=True
        )

        return api_response(message='点赞成功')

    except Exception as e:
        return api_error(f'点赞失败: {str(e)}', 500)


@community_bp.route('/posts/<post_id>/view', methods=['POST'])
def increment_view(post_id):
    """增加帖子浏览量"""
    try:
        es_client.update(
            index='community_forum_posts',
            id=post_id,
            script={
                'source': 'ctx._source.view_count += 1',
                'lang': 'painless'
            }
        )
        return api_response(message='success')

    except Exception as e:
        # 浏览量统计失败不影响主流程
        return api_response(message='success')


@community_bp.route('/posts/<post_id>/replies', methods=['POST'])
@login_required
def create_reply(post_id):
    """创建帖子回复"""
    try:
        user = g.current_user
        data = request.get_json()

        content = data.get('content', '').strip()
        if not content:
            return api_error('回复内容不能为空')

        reply_id = generate_id()
        now = datetime.utcnow()

        # 获取帖子信息
        post_result = es_client.get(index='community_forum_posts', id=post_id)
        post = post_result['_source']

        # 将 Markdown 图片语法转换为 HTML
        content_html = parse_markdown_images(content)

        # 构建回复文档
        reply_doc = {
            'id': reply_id,
            'post_id': post_id,
            'channel_id': post['channel_id'],
            'author_id': user['id'],
            'author_name': user['username'],
            'author_avatar': user.get('avatar', ''),
            'content': content,
            'content_html': content_html,  # Markdown 转换后的 HTML
            'reply_to': data.get('replyTo'),
            'reactions': {},
            'like_count': 0,
            'is_solution': False,
            'is_deleted': False,
            'created_at': now.isoformat(),
        }

        # 写入 ES
        es_client.index(
            index='community_forum_replies',
            id=reply_id,
            document=reply_doc,
            refresh=True
        )

        # 更新帖子的回复数和最后回复时间
        es_client.update(
            index='community_forum_posts',
            id=post_id,
            script={
                'source': '''
                    ctx._source.reply_count += 1;
                    ctx._source.last_reply_at = params.now;
                    ctx._source.last_reply_by = params.author_name;
                ''',
                'lang': 'painless',
                'params': {
                    'now': now.isoformat(),
                    'author_name': user['username']
                }
            },
            refresh=True
        )

        # 转换字段名
        response_data = {
            'id': reply_doc['id'],
            'postId': reply_doc['post_id'],
            'channelId': reply_doc['channel_id'],
            'authorId': reply_doc['author_id'],
            'authorName': reply_doc['author_name'],
            'authorAvatar': reply_doc['author_avatar'],
            'content': reply_doc['content'],
            'replyTo': reply_doc['reply_to'],
            'likeCount': reply_doc['like_count'],
            'createdAt': reply_doc['created_at'],
        }

        return api_response(response_data)

    except Exception as e:
        print(f"[Community API] 创建回复失败: {e}")
        return api_error(f'创建回复失败: {str(e)}', 500)


# ============================================================
# 文件上传接口
# ============================================================

import os
from werkzeug.utils import secure_filename

# 允许的图片扩展名
ALLOWED_EXTENSIONS = {'png', 'jpg', 'jpeg', 'gif', 'webp'}
# 上传目录（相对于 Flask 应用根目录）
UPLOAD_FOLDER = 'public/uploads/community'
# 最大文件大小 10MB
MAX_FILE_SIZE = 10 * 1024 * 1024


def allowed_file(filename):
    """检查文件扩展名是否允许"""
    return '.' in filename and \
           filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS


@community_bp.route('/upload/image', methods=['POST'])
@login_required
def upload_image():
    """
    上传图片
    返回 base64 编码的图片数据，可直接嵌入帖子内容中存储到 ES
    """
    import base64

    try:
        if 'file' not in request.files:
            return api_error('没有选择文件', 400)

        file = request.files['file']

        if file.filename == '':
            return api_error('没有选择文件', 400)

        if not allowed_file(file.filename):
            return api_error('不支持的文件格式，仅支持 PNG、JPG、GIF、WebP', 400)

        # 读取文件内容
        file_content = file.read()
        size = len(file_content)

        if size > MAX_FILE_SIZE:
            return api_error('文件大小超过限制（最大 10MB）', 400)

        # 获取文件扩展名和 MIME 类型
        ext = file.filename.rsplit('.', 1)[1].lower()
        mime_types = {
            'png': 'image/png',
            'jpg': 'image/jpeg',
            'jpeg': 'image/jpeg',
            'gif': 'image/gif',
            'webp': 'image/webp'
        }
        mime_type = mime_types.get(ext, 'image/jpeg')

        # 转换为 base64
        base64_data = base64.b64encode(file_content).decode('utf-8')
        data_url = f"data:{mime_type};base64,{base64_data}"

        # 生成唯一标识
        filename = f"{generate_id()}.{ext}"

        return api_response({
            'url': data_url,  # base64 data URL，可直接用于 img src
            'filename': filename,
            'size': size,
            'type': mime_type
        })

    except Exception as e:
        print(f"[Community API] 上传图片失败: {e}")
        import traceback
        traceback.print_exc()
        return api_error(f'上传失败: {str(e)}', 500)


# ============================================================
# ES 代理接口（前端直接查询 ES）
# ============================================================

@community_bp.route('/es/<index>/_search', methods=['POST'])
def es_search_proxy(index):
    """
    ES 搜索代理
    允许的索引：community_messages, community_forum_posts, community_forum_replies
    """
    allowed_indices = [
        'community_messages',
        'community_forum_posts',
        'community_forum_replies',
        'community_notifications'
    ]

    if index not in allowed_indices:
        return api_error('不允许访问该索引', 403)

    try:
        body = request.get_json()
        print(f"[Community API] ES 搜索请求: index={index}, body={body}")

        # 尝试使用不同的 API 调用方式（兼容不同版本的 elasticsearch-py）
        try:
            # 新版本 API
            result = es_client.search(index=index, body=body)
        except TypeError:
            # 旧版本 API，参数可能不同
            result = es_client.search(index=index, **body)

        # 处理结果格式
        if hasattr(result, 'body'):
            result = result.body
        elif hasattr(result, '__getitem__'):
            pass  # 已经是 dict
        else:
            result = dict(result)

        print(f"[Community API] ES 搜索成功: 返回 {result.get('hits', {}).get('total', {})} 条结果")

        return jsonify(result)

    except Exception as e:
        print(f"[Community API] ES 搜索失败: {e}")
        import traceback
        traceback.print_exc()
        # 返回更详细的错误信息
        return jsonify({
            'error': str(e),
            'type': type(e).__name__,
            'index': index,
            'body': body if 'body' in dir() else None
        }), 500


# ============================================================
# WebSocket 事件处理（需要在 app.py 中注册）
# ============================================================
# 在线用户管理
# ============================================================

# 在线用户字典: {user_id: {sid: socket_id, username: str, avatar: str, connected_at: datetime}}
online_users = {}
# Socket ID 到用户 ID 的映射: {socket_id: user_id}
sid_to_user = {}


def get_online_members():
    """获取当前在线用户列表"""
    return [
        {
            'userId': str(user_id),
            'username': info['username'],
            'avatar': info.get('avatar', ''),
            'isOnline': True,
            'connectedAt': info['connected_at'].isoformat() if info.get('connected_at') else None,
        }
        for user_id, info in online_users.items()
    ]


def register_community_socketio(socketio):
    """
    注册社区 WebSocket 事件
    在 app.py 中调用：register_community_socketio(socketio)
    """
    global socketio_instance
    socketio_instance = socketio

    from flask_socketio import join_room, leave_room, emit
    from flask import request

    @socketio.on('connect', namespace='/community')
    def handle_connect():
        user_id = session.get('user_id')
        username = session.get('username', '匿名用户')
        avatar = session.get('avatar', '')
        sid = request.sid

        if user_id:
            # 记录在线用户
            online_users[user_id] = {
                'sid': sid,
                'username': username,
                'avatar': avatar,
                'connected_at': datetime.utcnow()
            }
            sid_to_user[sid] = user_id

            # 广播用户上线事件
            emit('MEMBER_ONLINE', {
                'userId': str(user_id),
                'username': username,
                'avatar': avatar,
            }, broadcast=True, include_self=False)

            print(f'[Community Socket] User {username}({user_id}) connected, online: {len(online_users)}')
        else:
            print('[Community Socket] Anonymous client connected')

    @socketio.on('disconnect', namespace='/community')
    def handle_disconnect():
        sid = request.sid
        user_id = sid_to_user.pop(sid, None)

        if user_id and user_id in online_users:
            username = online_users[user_id].get('username', '匿名')
            del online_users[user_id]

            # 广播用户下线事件
            emit('MEMBER_OFFLINE', {
                'userId': str(user_id),
            }, broadcast=True)

            print(f'[Community Socket] User {username}({user_id}) disconnected, online: {len(online_users)}')

    @socketio.on('SUBSCRIBE_CHANNEL', namespace='/community')
    def handle_subscribe(data):
        channel_id = data.get('channelId')
        if channel_id:
            join_room(channel_id)
            print(f'[Community Socket] Joined room: {channel_id}')

    @socketio.on('UNSUBSCRIBE_CHANNEL', namespace='/community')
    def handle_unsubscribe(data):
        channel_id = data.get('channelId')
        if channel_id:
            leave_room(channel_id)
            print(f'[Community Socket] Left room: {channel_id}')

    @socketio.on('SEND_MESSAGE', namespace='/community')
    def handle_send_message(data):
        """通过 WebSocket 发送消息（实时广播）"""
        channel_id = data.get('channelId')
        # 广播给频道内所有用户
        emit('MESSAGE_CREATE', data, room=channel_id, include_self=False)

    @socketio.on('START_TYPING', namespace='/community')
    def handle_start_typing(data):
        channel_id = data.get('channelId')
        user_id = session.get('user_id')
        user_name = session.get('username', '匿名')
        emit('TYPING_START', {
            'channelId': channel_id,
            'userId': user_id,
            'userName': user_name
        }, room=channel_id, include_self=False)

    @socketio.on('STOP_TYPING', namespace='/community')
    def handle_stop_typing(data):
        channel_id = data.get('channelId')
        user_id = session.get('user_id')
        emit('TYPING_STOP', {
            'channelId': channel_id,
            'userId': user_id
        }, room=channel_id, include_self=False)

    print('✅ Community WebSocket 事件已注册')