app.py

import threading

from extuner import common
from flask import Flask, render_template, jsonify, request, send_file, make_response, Response
from collections import deque
import psutil
import platform
import socket
import subprocess
import os
import json
import time
import shutil
import re
from datetime import datetime, timedelta
import requests
from pathlib import Path

# 导入AI服务
from ai_service import ai_service


from security_scanner import start_new_scan, get_specified_scan_status, SecurityScanner

app = Flask(__name__)

# 配置
app.config['SECRET_KEY'] = 'your-secret-key-here'

# 初始化实时CPU监控
try:
    from extuner.category.get_cpu_info import RealTimeCPU
    from extuner.common.global_call import GlobalCall
    real_time_cpu_monitor = RealTimeCPU(interval=2)
    real_time_cpu_monitor.start_broadcasting()
    print("CPU实时监控已启动")
except ImportError as e:
    print(f"无法导入实时CPU监控: {e}")
    real_time_cpu_monitor = None
except Exception as e:
    print(f"启动实时CPU监控失败: {e}")
    real_time_cpu_monitor = None

# 初始化实时内存监控
try:
    from extuner.category.get_memory_info import RealTimeMemory
    from extuner.common.global_call import GlobalCall
    real_time_memory_monitor = RealTimeMemory(interval=2)
    real_time_memory_monitor.start_broadcasting()
    print("内存实时监控已启动")
except ImportError as e:
    print(f"无法导入实时内存监控: {e}")
    real_time_memory_monitor = None
except Exception as e:
    print(f"启动实时内存监控失败: {e}")
    real_time_memory_monitor = None

# 初始化实时网络监控
try:
    from extuner.category.get_net_info import RealTimeNet
    from extuner.common.global_call import GlobalCall
    real_time_net_monitor = RealTimeNet(interval=2)
    real_time_net_monitor.start_broadcasting()
    print("网络实时监控已启动")
except ImportError as e:
    print(f"无法导入实时网络监控: {e}")
    real_time_net_monitor = None
except Exception as e:
    print(f"启动实时网络监控失败: {e}")
    real_time_net_monitor = None

# 初始化实时磁盘监控
try:
    from extuner.category.get_disk_info import RealTimeDisk
    from extuner.common.global_call import GlobalCall
    real_time_disk_monitor = RealTimeDisk(interval=2)
    real_time_disk_monitor.start_broadcasting()
    print("磁盘实时监控已启动")
except ImportError as e:
    print(f"无法导入实时磁盘监控: {e}")
    real_time_disk_monitor = None
except Exception as e:
    print(f"启动实时磁盘监控失败: {e}")
    real_time_disk_monitor = None

try:
    from extuner.category.get_system_message import RealTimeSysMessage
    from extuner.common.global_call import GlobalCall
    real_time_sys_message_monitor = RealTimeSysMessage(interval=2)
    real_time_sys_message_monitor.start_broadcasting()
    print("系统消息实时监控已启动")
except ImportError as e:
    print(f"无法导入系统消息实时监控: {e}")
    real_time_sys_message_monitor = None
except Exception as e:
    print(f"启动系统消息实时监控失败: {e}")
    real_time_sys_message_monitor = None

# 全局日志缓存和计数器
log_cache = deque(maxlen=10000)  # 最多缓存10000条日志
log_level_stats = {'info': 0, 'warn': 0, 'error': 0, 'total': 0}
log_cache_lock = threading.Lock()  # 线程安全锁


# 添加CORS支持
@app.after_request
def after_request(response):
    response.headers.add('Access-Control-Allow-Origin', '*')
    response.headers.add('Access-Control-Allow-Headers', 'Content-Type,Authorization')
    response.headers.add('Access-Control-Allow-Methods', 'GET,PUT,POST,DELETE,OPTIONS')
    return response

def get_external_ip():
    """获取外部IP地址"""
    try:
        response = requests.get('https://api.ipify.org?format=text', timeout=5)
        return response.text.strip()
    except:
        return "获取失败"

def get_internal_ip():
    """获取内部IP地址"""
    try:
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        s.connect(("8.8.8.8", 80))
        ip = s.getsockname()[0]
        s.close()
        return ip
    except:
        return "127.0.0.1"

def format_bytes(bytes_value):
    """格式化字节数"""
    if bytes_value == 0:
        return "0 B"
    
    units = ['B', 'KB', 'MB', 'GB', 'TB']
    unit_index = 0
    
    while bytes_value >= 1024 and unit_index < len(units) - 1:
        bytes_value /= 1024
        unit_index += 1
    
    return f"{bytes_value:.2f} {units[unit_index]}"

def format_uptime(seconds):
    """格式化运行时间"""
    days = seconds // 86400
    hours = (seconds % 86400) // 3600
    minutes = (seconds % 3600) // 60
    
    if days > 0:
        return f"{days}天 {hours}小时 {minutes}分钟"
    elif hours > 0:
        return f"{hours}小时 {minutes}分钟"
    else:
        return f"{minutes}分钟"

def parse_extune_data():
    """解析extune输出的数据文件"""
    extune_data_path = os.path.join(os.path.dirname(__file__), 'extuner', 'extunerData')
    
    result = {
        'hostname': '未知',
        'system_name': '未知',
        'kernel_version': '未知',
        'external_ip': '获取失败',
        'internal_ip': '未知',
        'cpu_model': '未知',
        'cpu_architecture': '未知',
        'cpu_count': 0,
        'memory_total': '未知',
        'memory_free': '未知',
        'disk_total': '未知',
        'disk_info': '未知',
        'network_info': '未知',
        'os_version': '未知',
        'gcc_version': '未知',
        'glibc_version': '未知',
        'jdk_version': '未知',
        'uptime_days': '0 天',
        'last_update': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
    }
    
    try:
        # 解析CPU信息
        cpu_file = os.path.join(extune_data_path, 'CPUInfo.txt')
        if os.path.exists(cpu_file):
            with open(cpu_file, 'r', encoding='utf-8') as f:
                cpu_content = f.read()
                
                # 提取CPU型号
                cpu_match = re.search(r'Model name:\s*(.+)', cpu_content)
                if cpu_match:
                    result['cpu_model'] = cpu_match.group(1).strip()
                
                # 提取CPU架构
                arch_match = re.search(r'Architecture:\s*(.+)', cpu_content)
                if arch_match:
                    result['cpu_architecture'] = arch_match.group(1).strip()
                
                # 提取CPU核心数
                cpu_count_match = re.search(r'CPU\(s\):\s*(\d+)', cpu_content)
                if cpu_count_match:
                    result['cpu_count'] = int(cpu_count_match.group(1))
        
        # 解析内存信息
        mem_file = os.path.join(extune_data_path, 'memInfo.txt')
        if os.path.exists(mem_file):
            with open(mem_file, 'r', encoding='utf-8') as f:
                mem_content = f.read()
                
                # 提取总内存
                mem_total_match = re.search(r'MemTotal:\s*(\d+)\s*kB', mem_content)
                if mem_total_match:
                    mem_kb = int(mem_total_match.group(1))
                    mem_bytes = mem_kb * 1024
                    result['memory_total'] = format_bytes(mem_bytes)
                
                # 提取空闲内存
                mem_free_match = re.search(r'MemFree:\s*(\d+)\s*kB', mem_content)
                if mem_free_match:
                    mem_free_kb = int(mem_free_match.group(1))
                    mem_free_bytes = mem_free_kb * 1024
                    result['memory_free'] = format_bytes(mem_free_bytes)
        
        # 解析磁盘信息
        disk_file = os.path.join(extune_data_path, 'diskInfo.txt')
        if os.path.exists(disk_file):
            with open(disk_file, 'r', encoding='utf-8') as f:
                disk_content = f.read()
                
                # 提取磁盘总容量
                disk_match = re.search(r'Disk /dev/sda: ([\d.]+) GiB', disk_content)
                if disk_match:
                    disk_gb = float(disk_match.group(1))
                    disk_bytes = int(disk_gb * 1024 * 1024 * 1024)
                    result['disk_total'] = format_bytes(disk_bytes)
                    result['disk_info'] = f"sda: {disk_gb} GiB"
        
        # 解析网络信息
        net_file = os.path.join(extune_data_path, 'netInfo.txt')
        if os.path.exists(net_file):
            with open(net_file, 'r', encoding='utf-8') as f:
                net_content = f.read()
                
                # 提取网络接口信息
                interface_match = re.search(r'NAME\s+UUID\s+TYPE\s+DEVICE\s*\n(\w+)', net_content)
                if interface_match:
                    result['network_info'] = interface_match.group(1)
                
                # 提取内部IP（从网络配置中获取）
                # 这里需要根据实际的网络配置格式调整
                ip_match = re.search(r'inet (192\.168\.\d+\.\d+)', net_content)
                if ip_match:
                    result['internal_ip'] = ip_match.group(1)
        
        # 解析系统参数信息
        sys_file = os.path.join(extune_data_path, 'sysParamInfo.txt')
        if os.path.exists(sys_file):
            with open(sys_file, 'r', encoding='utf-8') as f:
                sys_content = f.read()
                
                # 从sysctl输出中提取主机名
                hostname_match = re.search(r'kernel\.hostname = (.+)', sys_content)
                if hostname_match:
                    result['hostname'] = hostname_match.group(1).strip()
                
                # 从sysctl输出中提取内核版本
                kernel_match = re.search(r'kernel\.osrelease = (.+)', sys_content)
                if kernel_match:
                    result['kernel_version'] = kernel_match.group(1).strip()
                
                # 从sysctl输出中提取操作系统类型
                os_match = re.search(r'kernel\.ostype = (.+)', sys_content)
                if os_match:
                    result['system_name'] = os_match.group(1).strip()
                
                # 尝试获取更详细的系统版本信息
                kylin_match = re.search(r'kernel\.kylinversion = (.+)', sys_content)
                if kylin_match:
                    result['os_version'] = kylin_match.group(1).strip()
        
        # 解析系统消息以获取GCC版本
        sys_msg_file = os.path.join(extune_data_path, 'systemMessage.txt')
        if os.path.exists(sys_msg_file):
            with open(sys_msg_file, 'r', encoding='utf-8') as f:
                sys_msg_content = f.read()
                
                # 提取GCC版本
                gcc_match = re.search(r'gcc version ([\d.]+)', sys_msg_content)
                if gcc_match:
                    result['gcc_version'] = gcc_match.group(1)
        
        # 尝试获取Glibc版本（通常需要执行命令）
        try:
            glibc_result = subprocess.run(['ldd', '--version'], capture_output=True, text=True, timeout=5)
            if glibc_result.returncode == 0:
                glibc_match = re.search(r'ldd \(GNU libc\) ([\d.]+)', glibc_result.stdout)
                if glibc_match:
                    result['glibc_version'] = glibc_match.group(1)
        except:
            result['glibc_version'] = '未知'
        
        # 尝试获取JDK版本
        try:
            java_result = subprocess.run(['java', '-version'], capture_output=True, text=True, timeout=5)
            if java_result.returncode == 0:
                java_match = re.search(r'version "([^"]+)"', java_result.stderr)
                if java_match:
                    result['jdk_version'] = java_match.group(1)
        except:
            result['jdk_version'] = '未安装'
        
        # 获取外部IP（实时获取）
        result['external_ip'] = get_external_ip()
        
        # 计算运行天数（使用psutil获取）
        try:
            boot_time = psutil.boot_time()
            uptime_seconds = int(time.time() - boot_time)
            uptime_days = uptime_seconds // 86400
            result['uptime_days'] = f"{uptime_days} 天"
        except:
            result['uptime_days'] = "0 天"
            
    except Exception as e:
        print(f"解析extune数据时出错: {e}")
    
    return result

# 路由定义
@app.route('/')
def desktop():
    """Windows 10 桌面主页"""
    return render_template('desktop.html')

@app.route('/system-info')
def system_info():
    """系统信息页面"""
    return render_template('system_info.html')

@app.route('/file-manager')
def file_manager():
    """文件管理器页面"""
    return render_template('file_manager.html')

@app.route('/task-manager')
def task_manager():
    """任务管理器页面"""
    return render_template('task_manager.html')

@app.route('/network-monitor')
def network_monitor():
    """网络监控页面"""
    return render_template('network_monitor.html')

@app.route('/performance-monitor')
def performance_monitor():
    """性能监控页面"""
    return render_template('performance_monitor.html')

@app.route('/security-center')
def security_center():
    """安全中心页面"""
    return render_template('security_center.html')

@app.route('/terminal')
def terminal():
    """终端页面"""
    return render_template('terminal.html')

@app.route('/settings')
def settings():
    """设置页面"""
    return render_template('settings.html')

@app.route('/ai-chat')
def ai_chat():
    """AI对话页面"""
    return render_template('ai_chat.html')

@app.route('/test-js')
def test_js():
    """JavaScript测试页面"""
    return render_template('test_js.html')

# API 路由
@app.route('/system_info.json')
def get_system_info_json():
    """提供预生成的系统信息JSON文件"""
    try:
        json_file_path = os.path.join(os.path.dirname(__file__), 'system_info.json')
        if os.path.exists(json_file_path):
            return send_file(json_file_path, mimetype='application/json')
        else:
            # 如果JSON文件不存在，返回404
            return jsonify({'error': 'system_info.json文件不存在'}), 404
    except Exception as e:
        return jsonify({'error': str(e)}), 500


@app.route('/api/system-status')
def system_status():
    """获取系统状态信息（使用实时CPU数据）"""
    try:
        # 从全局广播获取CPU数据
        cpu_data = GlobalCall.real_time_cpu_data
        if not cpu_data:
            # 如果实时数据不可用，使用psutil作为后备
            cpu_percent = psutil.cpu_percent(interval=1)
            cpu_percent_per_core = [psutil.cpu_percent(interval=1, percpu=True)[i] for i in range(psutil.cpu_count())]
            cpu_count = psutil.cpu_count()
            cpu_name = f"Unknown CPU ({cpu_count} cores)"
            load_avg = psutil.getloadavg() if hasattr(psutil, 'getloadavg') else [0, 0, 0]
            cpu_freq = psutil.cpu_freq().current if hasattr(psutil, 'cpu_freq') else 0
            logical_cpu_count = psutil.cpu_count(logical=True)
            usr = 0
            nice = 0
            sys = 0
            iowait = 0
            irq = 0
            soft = 0
            steal = 0
            guest = 0
            gnice = 0
            idle = 0
            # 进程信息
            processes = []
            for proc in psutil.process_iter(['pid', 'name', 'cpu_percent', 'memory_percent']):
                try:
                    proc_info = proc.info
                    if proc_info['cpu_percent'] > 0 or proc_info['memory_percent'] > 0:
                        processes.append(proc_info)
                except (psutil.NoSuchProcess, psutil.AccessDenied):
                    continue

            # 按CPU使用率排序，取前10个
            top_processes = sorted(processes, key=lambda x: x['cpu_percent'] or 0, reverse=True)[:10]

        else:
            # 使用RealTimeCPU提供的数据
            cpu_percent = cpu_data['total_usage']
            cpu_percent_per_core = cpu_data['core_usage']
            cpu_count = cpu_data['cpu_count']
            cpu_name = cpu_data['model_name']
            load_avg = cpu_data['load_avg']
            cpu_freq = cpu_data['cpu_freq']
            logical_cpu_count = cpu_data['logical_cpu_count']
            top_processes = cpu_data['top_processes']
            usr = cpu_data['usr']
            nice = cpu_data['nice']
            sys = cpu_data['sys']
            iowait = cpu_data['iowait']
            irq = cpu_data['irq']
            soft = cpu_data['soft']
            steal = cpu_data['steal']
            guest = cpu_data['guest']
            gnice = cpu_data['gnice']
            idle = cpu_data['idle']

        # 从全局广播获取内存数据
        memory_data = GlobalCall.real_time_mem_data
        if not memory_data:
            # 如果实时内存数据不可用，使用psutil作为后备
            memory = psutil.virtual_memory()
            swap = psutil.swap_memory()
        else:
            # 使用RealTimeMemory提供的数据
            memory = type('obj', (object,), {
                'total': memory_data['mem_total'],
                'used': memory_data['mem_used'],
                'free': memory_data['mem_free'],
                'percent': memory_data['mem_percent'],
                'cached': memory_data['mem_cached'],
                'buffers': memory_data['mem_buffers']
            })()
            swap = type('obj', (object,), {
                'total': memory_data['swap_total'],
                'used': memory_data['swap_used'],
                'free': memory_data['swap_free'],
                'percent': memory_data['swap_percent']
            })()

        # 网络详细信息 - 从全局广播获取网络数据
        net_data = GlobalCall.real_time_net_data
        if not net_data:
            # 如果实时网络数据不可用，使用psutil作为后备
            net_io = psutil.net_io_counters()
            net_interfaces = {}
            rx_speed = 0.0
            tx_speed = 0.0
        else:
            # 使用RealTimeNet提供的数据
            net_io = net_data.get('net_io', {})
            net_interfaces = net_data.get('net_interfaces', {})
            rx_speed = net_data.get('total_rx_speed', 0.0)
            tx_speed = net_data.get('total_tx_speed', 0.0)


        # 从全局广播获取磁盘数据
        disk_data = GlobalCall.real_time_disk_data
        if not disk_data:
            # 如果实时数据不可用，使用psutil作为后备
            disk_usage = []
            partitions = psutil.disk_partitions()
            for partition in partitions:
                try:
                    usage = psutil.disk_usage(partition.mountpoint)
                    disk_usage.append({
                        'device': partition.device,
                        'mountpoint': partition.mountpoint,
                        'fstype': partition.fstype,
                        'total': usage.total,
                        'used': usage.used,
                        'free': usage.free,
                        'percent': usage.percent,
                        'utilization': 0.0
                    })
                except Exception:
                    continue

            disk_io = psutil.disk_io_counters()
            disk_io_data = {
                'read_bytes': disk_io.read_bytes if disk_io else 0,
                'write_bytes': disk_io.write_bytes if disk_io else 0,
                'read_count': disk_io.read_count if disk_io else 0,
                'write_count': disk_io.write_count if disk_io else 0,
            }
            total_utilization = psutil.disk_io_counters(perdisk=True)
        else:
            # 使用RealTimeDisk提供的数据
            disk_usage = disk_data['disk_usage']
            disk_io_data = disk_data['disk_io']
            total_utilization = disk_data['total_utilization']


        """整合数据"""
        return jsonify({
            'cpu_usage': cpu_percent,
            'cpu_percent_per_core': cpu_percent_per_core,
            'cpu_model': cpu_name,
            'cpu_count': cpu_count,
            'cpu_frequency': cpu_freq,
            'cpu_details': {
                'usr': usr,
                'nice': nice,
                'sys': sys,
                'iowait': iowait,
                'irq': irq,
                'soft': soft,
                'steal': steal,
                'guest': guest,
                'gnice': gnice,
                'idle': idle
            },
            'logical_cpu_count': logical_cpu_count,
            'load_avg': load_avg,
            'top_processes': top_processes,
            'memory_usage': memory.percent,
            'memory_total': {  # 内存信息
                'memory_percent': memory.percent,
                'memory_used': memory.used,
                'memory_total': memory.total,
                'memory_free': memory.free,
                'memory_cached': memory.cached,
                'memory_buffers': memory.buffers,

                # 交换内存信息
                'swap_percent': swap.percent,
                'swap_used': swap.used,
                'swap_total': swap.total,
                'swap_free': swap.free
            },
            'disk_info': {
                'disk_usage': disk_usage,
                'disk_io': disk_io_data,
                'total_utilization': total_utilization
            },
            'net_interfaces': net_interfaces,
            'net_io': net_io,
            'rx_speed': rx_speed,
            'tx_speed': tx_speed,
            'current_time': datetime.now().strftime('%H:%M'),
            'current_date': datetime.now().strftime('%Y/%m/%d'),
            'day_of_week': datetime.now().strftime('%A')
        })
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/system-info-txt')
def get_system_info_txt():
    """从info.txt文件获取系统信息"""
    try:
        info_file = os.path.join(os.path.dirname(__file__), 'extuner', 'info.txt')
        
        if not os.path.exists(info_file):
            return jsonify({
                'error': 'info.txt文件不存在',
                'message': '请先运行extune数据采集生成info.txt文件'
            }), 404
        
        with open(info_file, 'r', encoding='utf-8') as f:
            content = f.read()
        
        # 解析txt内容为结构化数据
        info_data = parse_info_txt(content)
        
        return jsonify(info_data)
        
    except Exception as e:
        return jsonify({'error': str(e)}), 500

def parse_info_txt(content):
    """解析info.txt文件内容为结构化数据"""
    lines = content.split('\n')
    data = {
        'base_info': {},
        'cpu_info': {},
        'memory_info': {},
        'network_info': [],
        'disk_info': [],
        'time_info': {}
    }
    
    current_section = None
    current_network = {}
    current_disk = {}
    
    for line in lines:
        line = line.strip()
        if not line:
            continue
            
        if line.startswith('=== ') and line.endswith(' ==='):
            current_section = line.replace('===', '').strip()
            continue
            
        if line == '---':
            if current_section == '网络接口信息' and current_network:
                data['network_info'].append(current_network.copy())
                current_network = {}
            elif current_section == '磁盘信息' and current_disk:
                data['disk_info'].append(current_disk.copy())
                current_disk = {}
            continue
            
        if ':' in line:
            key, value = line.split(':', 1)
            key = key.strip()
            value = value.strip()
            
            if current_section == '系统基本信息':
                data['base_info'][key] = value
            elif current_section == 'CPU信息':
                data['cpu_info'][key] = value
            elif current_section == '内存信息':
                data['memory_info'][key] = value
            elif current_section == '网络接口信息':
                current_network[key] = value
            elif current_section == '磁盘信息':
                current_disk[key] = value
            elif current_section == '时间信息':
                data['time_info'][key] = value
    
    # 处理最后一个网络接口或磁盘
    if current_network:
        data['network_info'].append(current_network)
    if current_disk:
        data['disk_info'].append(current_disk)
    
    return data

@app.route('/api/system-info')
def get_system_info():
    """获取详细系统信息"""
    try:
        # 从extune数据文件获取基本信息
        extune_data = parse_extune_data()
        
        # 获取实时性能数据
        cpu_percent = psutil.cpu_percent(interval=1)
        cpu_freq = psutil.cpu_freq()
        memory = psutil.virtual_memory()
        swap = psutil.swap_memory()
        
        # 磁盘信息 - Windows环境适配
        try:
            if os.name == 'nt':  # Windows
                disk = psutil.disk_usage('C:')
            else:  # Linux/Unix
                disk = psutil.disk_usage('/')
        except:
            # 如果获取失败，使用默认值
            disk = type('obj', (object,), {'total': 0, 'used': 0, 'free': 0})()
        
        network_io = psutil.net_io_counters()
        
        # 运行时间
        boot_time = psutil.boot_time()
        uptime_seconds = int(time.time() - boot_time)
        
        return jsonify({
            # 基本系统信息
            'hostname': extune_data['hostname'],
            'system_name': extune_data['system_name'],
            'kernel_version': extune_data['kernel_version'],
            'os_version': extune_data['os_version'],
            
            # CPU信息
            'cpu_model': extune_data['cpu_model'],
            'cpu_architecture': extune_data['cpu_architecture'],
            'cpu_count': extune_data['cpu_count'],
            'cpu_usage': cpu_percent,
            'cpu_frequency': cpu_freq.current if cpu_freq else 0,

            # 内存信息
            'memory_total': extune_data['memory_total'],
            'memory_free': extune_data['memory_free'],
            'memory_total_bytes': memory.total,
            'memory_available': memory.available,
            'memory_used': memory.used,
            'memory_percent': memory.percent,
            
            # Swap内存信息
            'swap_total': swap.total,
            'swap_used': swap.used,
            'swap_free': swap.free,
            'swap_percent': swap.percent,
            
            # 磁盘信息
            'disk_total': extune_data['disk_total'],
            'disk_info': extune_data['disk_info'],
            'disk_total_bytes': disk.total,
            'disk_used': disk.used,
            'disk_free': disk.free,
            'disk_percent': (disk.used / disk.total) * 100 if disk.total > 0 else 0,
            
            # 网络信息
            'external_ip': extune_data['external_ip'],
            'internal_ip': extune_data['internal_ip'],
            'network_info': extune_data['network_info'],
            'network_bytes_sent': network_io.bytes_sent,
            'network_bytes_recv': network_io.bytes_recv,
            'network_packets_sent': network_io.packets_sent,
            'network_packets_recv': network_io.packets_recv,
            
            # 开发工具版本
            'gcc_version': extune_data['gcc_version'],
            'glibc_version': extune_data['glibc_version'],
            'jdk_version': extune_data['jdk_version'],
            
            # 运行时间信息
            'uptime_seconds': uptime_seconds,
            'uptime_formatted': format_uptime(uptime_seconds),
            'uptime_days': extune_data['uptime_days'],
            'last_update': extune_data['last_update'],
            'boot_time': datetime.fromtimestamp(boot_time).strftime('%Y-%m-%d %H:%M:%S')
        })
    except Exception as e:
        return jsonify({'error': str(e)}), 500


# 性能报警全局数据结构
performanceAlert = []  # 存储当前活动的报警
alert_history = {}  # 存储报警最后触发时间 {alert_code: timestamp}
alert_lock = threading.Lock()  # 线程安全锁

# 报警阈值配置
ALERT_THRESHOLDS = {
    "cpu-overload": 85.0,  # CPU使用率阈值(%)
    "memory-overload": 90.0,  # 内存使用率阈值(%)
    "disk-space-overload": 90.0,  # 磁盘空间使用率阈值(%)
    "disk-io-overload": 80.0,  # 磁盘IO利用率阈值(%)
    "network-overload": 80.0,  # 网络带宽利用率阈值(%)
    "high-process-load": 50.0,  # 单个进程CPU占用阈值(%)
}

# 报警清除时间(秒)
ALERT_CLEAR_TIME = 300  # 5分钟内无再次触发则清除


@app.route('/api/check-alert')
def check_alert():
    try:
        current_time = time.time()

        # 1. 清除过期的报警
        with alert_lock:
            # 移除超过清除时间的报警
            performanceAlert[:] = [alert for alert in performanceAlert
                                   if current_time - alert_history.get(alert["alert_code"], 0) <= ALERT_CLEAR_TIME]

            # 更新报警历史中过期的条目
            for code in list(alert_history.keys()):
                if current_time - alert_history[code] > ALERT_CLEAR_TIME:
                    del alert_history[code]

        # 2. 获取实时性能数据
        # 使用GlobalCall的实时数据（参考/api/performance-data的实现）
        try:
            # 获取CPU数据
            cpu_data = GlobalCall.real_time_cpu_data
            if not cpu_data:
                return jsonify(performanceAlert)

            # 获取内存数据
            memory_data = GlobalCall.real_time_mem_data
            if not memory_data:
                return jsonify(performanceAlert)

            # 获取磁盘数据
            disk_data = GlobalCall.real_time_disk_data
            if not disk_data:
                return jsonify(performanceAlert)

            # 获取网络数据
            net_data = GlobalCall.real_time_net_data
            if not net_data:
                return jsonify(performanceAlert)

        except Exception as e:
            print(f"获取性能数据失败: {e}")
            return jsonify(performanceAlert)

        # 3. 检查各项阈值
        with alert_lock:
            # 检查CPU负载
            if cpu_data['total_usage'] > ALERT_THRESHOLDS["cpu-overload"]:
                update_alert("cpu-overload",
                             f"CPU使用率过高: {cpu_data['total_usage']:.2f}%",
                             current_time)

            # 检查内存使用
            if memory_data['mem_percent'] > ALERT_THRESHOLDS["memory-overload"]:
                update_alert("memory-overload",
                             f"内存使用率过高: {memory_data['mem_percent']:.2f}%",
                             current_time)

            # 检查磁盘空间
            for partition in disk_data['disk_usage']:
                if partition['percent'] > ALERT_THRESHOLDS["disk-space-overload"]:
                    update_alert("disk-space-overload",
                                 f"磁盘 {partition['mountpoint']} 空间不足: {partition['percent']:.2f}%",
                                 current_time)

            # 检查磁盘IO
            max_io_util = 0.0
            for device, stats in disk_data['disk_io'].items():
                if 'utilization' in stats and stats['utilization'] > max_io_util:
                    max_io_util = stats['utilization']

            if max_io_util > ALERT_THRESHOLDS["disk-io-overload"]:
                update_alert("disk-io-overload",
                             f"磁盘IO负载过高: {max_io_util:.2f}%",
                             current_time)

            # 检查网络负载
            net_util = max(net_data.get('total_rx_speed', 0), net_data.get('total_tx_speed', 0))
            if net_util > ALERT_THRESHOLDS["network-overload"]:
                update_alert("network-overload",
                             f"网络负载过高: {(net_util / 1024 /1024):.2f} MB/s",
                             current_time)

            # 检查高负载进程
            for proc in cpu_data.get('top_processes', [])[:5]:  # 检查前5个高负载进程
                if proc.get('cpu_percent', 0) > ALERT_THRESHOLDS["high-process-load"]:
                    update_alert("high-process-load",
                                 f"进程 {proc.get('command', '未知')} 占用过高CPU: {proc['cpu_percent']}%",
                                 current_time)

        return jsonify(performanceAlert)

    except Exception as e:
        print(f"报警检查错误: {e}")
        return jsonify({"error": str(e)}), 500


def update_alert(alert_code, description, timestamp):
    """更新报警状态"""
    # 更新报警最后触发时间
    alert_history[alert_code] = timestamp

    # 检查是否已存在该报警
    existing_alert = next((a for a in performanceAlert if a["alert_code"] == alert_code), None)

    if existing_alert:
        # 更新现有报警
        existing_alert["description"] = description
        existing_alert["timestamp"] = timestamp
    else:
        # 创建新报警
        new_alert = {
            "alert_code": alert_code,
            "description": description,
            "timestamp": timestamp,
            "solution": ""  # 初始为空，由AI后续生成
        }
        performanceAlert.append(new_alert)


@app.route('/api/system-log')
def get_system_log():
    try:
        system_log = GlobalCall.real_time_sys_message_data
        recent_logs = system_log.get('recent_logs', [])
        logs_today = []

        # 使用锁确保线程安全
        with log_cache_lock:
            # 只处理新出现的日志
            new_logs = [log for log in recent_logs if log not in log_cache]

            # 更新缓存
            log_cache.extend(new_logs)

            logs_today = list(log_cache)

        error_logs = system_log['error_logs']
        return jsonify({'recent_logs': logs_today, 'error_logs': error_logs})
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/security-overview')
def get_security_overview():
    """获取安全概览数据 - 实时获取今日处理日志、今日异常和告警等级"""
    try:
        # 获取今日日期
        system_log = GlobalCall.real_time_sys_message_data

        # 初始化计数器
        today_logs_count = 0
        today_anomalies_count = 0
        risk_level = "正常"

        # 1. 统计今日处理的日志数量
        recent_logs = system_log.get('recent_logs', [])

        # 使用锁确保线程安全
        with log_cache_lock:
            # 只处理新出现的日志
            new_logs = [log for log in recent_logs if log not in log_cache]

            # 更新缓存
            log_cache.extend(new_logs)

        # 2. 统计今日异常数量
        for log_content in new_logs:
            if not log_content or not log_content.strip():
                continue

            lines = log_content.split('\n')
            for line in lines:
                line = line.strip()
                if not line:
                    continue

                # 更新统计计数
                log_level_stats['total'] += 1
                line_lower = line.lower()

                if any(keyword in line_lower for keyword in ['error', 'err', 'fail', 'critical', 'exception']):
                    log_level_stats['error'] += 1
                elif any(keyword in line_lower for keyword in ['warn', 'warning', 'caution']):
                    log_level_stats['warn'] += 1
                else:
                    log_level_stats['info'] += 1

        today_logs_count = log_level_stats['total']
        today_anomalies_count = log_level_stats['error'] + log_level_stats['warn']

        # 3. 确定风险等级
        if today_anomalies_count >= 10:
            risk_level = "高危"
        elif today_anomalies_count >= 5:
            risk_level = "中等"
        elif today_anomalies_count >= 1:
            risk_level = "低风险"
        else:
            risk_level = "正常"
        
        # 4. 获取监控状态
        monitor_status = "运行中"
        try:
            from security_scanner import scan_tasks
            active_scans = len([scanner for scanner in scan_tasks.values() if hasattr(scanner, 'status') and scanner.status == 'running'])
            if active_scans > 0:
                monitor_status = f"运行中 ({active_scans}个扫描任务)"
        except:
            pass
        
        overview_data = {
            'today_logs': today_logs_count,
            'today_anomalies': today_anomalies_count,
            'risk_level': risk_level,
            'monitor_status': monitor_status,
            'last_update': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
        }
        
        print(f"[DEBUG] 安全概览数据: {overview_data}")
        return jsonify(overview_data)
        
    except Exception as e:
        print(f"获取安全概览失败: {e}")
        try:
            import traceback
            traceback.print_exc()
        except:
            pass
        return jsonify({'error': str(e)}), 500

@app.route('/api/log-level-stats')
def get_log_level_stats():
    """获取日志级别统计数据 - 累积统计"""
    global log_cache, log_level_stats

    try:
        # 获取实时日志数据
        system_log = GlobalCall.real_time_sys_message_data
        recent_logs = system_log.get('recent_logs', [])

        # 合并所有日志
        all_logs = recent_logs

        # 使用锁确保线程安全
        with log_cache_lock:
            # 只处理新出现的日志
            new_logs = [log for log in all_logs if log not in log_cache]

            # 更新缓存
            log_cache.extend(new_logs)

            # 分析新日志的级别
            for log_content in new_logs:
                if not log_content or not log_content.strip():
                    continue

                lines = log_content.split('\n')
                for line in lines:
                    line = line.strip()
                    if not line:
                        continue

                    # 更新统计计数
                    log_level_stats['total'] += 1
                    line_lower = line.lower()

                    if any(keyword in line_lower for keyword in ['error', 'err', 'fail', 'critical', 'exception']):
                        log_level_stats['error'] += 1
                    elif any(keyword in line_lower for keyword in ['warn', 'warning', 'caution']):
                        log_level_stats['warn'] += 1
                    else:
                        log_level_stats['info'] += 1

        return jsonify({
            'info': log_level_stats['info'],
            'warn': log_level_stats['warn'],
            'error': log_level_stats['error'],
            'total': log_level_stats['total'],
            'last_update': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
        })

    except Exception as e:
        print(f"获取日志级别统计失败: {e}")
        try:
            import traceback
            traceback.print_exc()
        except:
            pass
        return jsonify({
            'info': log_level_stats.get('info', 0),
            'warn': log_level_stats.get('warn', 0),
            'error': log_level_stats.get('error', 0),
            'total': log_level_stats.get('total', 0)
        }), 500

@app.route('/api/anomaly-list')
def get_anomaly_list():
    """获取异常列表 - 从安全扫描器和实时日志流中获取异常"""
    try:
        scan_id = request.args.get('scan_id', 'default')
        print(f"[DEBUG] 获取异常列表，scan_id: {scan_id}")
        
        anomalies = []
        
        # 首先尝试从安全扫描器获取高级日志异常检测结果
        try:
            from security_scanner import scan_tasks, get_specified_scan_status
            print(f"[DEBUG] 当前扫描任务数量: {len(scan_tasks)}")
            print(f"[DEBUG] 扫描任务ID列表: {list(scan_tasks.keys())}")
            
            # 如果指定了scan_id，尝试获取该扫描的结果
            if scan_id != 'default' and scan_id in scan_tasks:
                scanner = scan_tasks[scan_id]
                print(f"[DEBUG] 找到扫描任务: {scan_id}, 状态: {scanner.status}")
                
                # 安全地获取log_anomalies
                if hasattr(scanner, 'results') and isinstance(scanner.results, dict):
                    log_anomalies = scanner.results.get('log_anomalies', [])
                else:
                    log_anomalies = []
                    
                print(f"[DEBUG] 该扫描的异常数量: {len(log_anomalies)}")
                
                # 转换格式以匹配前端期望
                for anomaly in log_anomalies:
                    if isinstance(anomaly, dict):
                        anomalies.append({
                            'type': anomaly.get('type', 'LOG_ANOMALY'),
                            'message': anomaly.get('message', ''),
                            'content': anomaly.get('reason', anomaly.get('message', '')),
                            'severity': anomaly.get('severity', 'medium'),
                            'timestamp': anomaly.get('timestamp', ''),
                            'source': anomaly.get('detection_method', 'Advanced Log Analysis'),
                            'confidence': anomaly.get('confidence', 0.0),
                            'count': anomaly.get('count', 1),
                            'suggestion': get_anomaly_suggestion(anomaly.get('type', ''))
                        })
            
            # 如果没有从扫描结果中获取到异常，或者是默认请求，获取全局异常
            if not anomalies:
                print(f"[DEBUG] 从所有扫描任务中获取异常")
                # 获取所有扫描结果中的日志异常
                for task_id, scanner in scan_tasks.items():
                    # 安全地获取log_anomalies
                    if hasattr(scanner, 'results') and isinstance(scanner.results, dict):
                        log_anomalies = scanner.results.get('log_anomalies', [])
                    else:
                        log_anomalies = []
                        
                    print(f"[DEBUG] 任务 {task_id} 的异常数量: {len(log_anomalies)}")
                    
                    for anomaly in log_anomalies:
                        if isinstance(anomaly, dict):
                            anomalies.append({
                                'type': anomaly.get('type', 'LOG_ANOMALY'),
                                'message': anomaly.get('message', ''),
                                'content': anomaly.get('reason', anomaly.get('message', '')),
                                'severity': anomaly.get('severity', 'medium'),
                                'timestamp': anomaly.get('timestamp', ''),
                                'source': anomaly.get('detection_method', 'Advanced Log Analysis'),
                                'confidence': anomaly.get('confidence', 0.0),
                                'count': anomaly.get('count', 1),
                                'suggestion': get_anomaly_suggestion(anomaly.get('type', ''))
                            })
        except Exception as e:
            print(f"[ERROR] Failed to get advanced log anomalies: {e}")
            import traceback
            traceback.print_exc()
            print(f"[DEBUG] Exception type: {type(e)}")
            print(f"[DEBUG] Exception args: {e.args}")
        
        # 如果没有高级异常检测结果，回退到传统方法
        if not anomalies:
            # 获取实时日志数据
            system_log = GlobalCall.real_time_sys_message_data
            error_logs = system_log.get('error_logs', [])
            recent_logs = system_log.get('recent_logs', [])
            
            # 处理错误日志
            for error_log in error_logs:
                if not error_log or not error_log.strip():
                    continue
                    
                lines = error_log.split('\n')
                for line in lines:
                    line = line.strip()
                    if not line or line.startswith('##'):
                        continue
                        
                    # 解析日志行
                    anomaly = parse_log_line_to_anomaly(line)
                    if anomaly:
                        anomalies.append(anomaly)
            
            # 如果错误日志为空，从最近日志中筛选问题日志
            if not anomalies:
                for recent_log in recent_logs:
                    if not recent_log or not recent_log.strip():
                        continue
                        
                    lines = recent_log.split('\n')
                    for line in lines:
                        line = line.strip()
                        if not line:
                            continue
                            
                        # 检查是否包含问题关键词
                        if any(keyword in line.lower() for keyword in ['error', 'fail', 'warning', 'critical', 'exception', 'timeout', 'denied']):
                            anomaly = parse_log_line_to_anomaly(line)
                            if anomaly:
                                anomalies.append(anomaly)
        
        # 如果仍然没有异常，生成一些模拟数据用于演示
        if not anomalies:
            now = datetime.now()
            
            sample_anomalies = [
                {
                    'type': 'SYSTEM_ERROR',
                    'message': '磁盘空间不足警告',
                    'content': '系统检测到 /var 分区使用率超过 85%',
                    'severity': 'high',
                    'timestamp': (now - timedelta(minutes=15)).strftime('%Y-%m-%d %H:%M:%S'),
                    'source': 'System Monitor',
                    'confidence': 0.95,
                    'count': 1,
                    'suggestion': '清理临时文件或扩展磁盘空间'
                },
                {
                    'type': 'NETWORK_WARNING',
                    'message': '网络连接异常',
                    'content': 'TCP连接超时，目标地址: 192.168.1.100:8080',
                    'severity': 'medium',
                    'timestamp': (now - timedelta(minutes=8)).strftime('%Y-%m-%d %H:%M:%S'),
                    'source': 'Network Monitor',
                    'confidence': 0.85,
                    'count': 3,
                    'suggestion': '检查网络连接和防火墙设置'
                },
                {
                    'type': 'SERVICE_ERROR',
                    'message': '服务启动失败',
                    'content': 'nginx 服务启动失败，端口 80 被占用',
                    'severity': 'high',
                    'timestamp': (now - timedelta(minutes=3)).strftime('%Y-%m-%d %H:%M:%S'),
                    'source': 'Service Manager',
                    'confidence': 0.98,
                    'count': 1,
                    'suggestion': '检查端口占用情况，重启相关服务'
                }
            ]
            anomalies.extend(sample_anomalies)
        
        # 按时间戳排序（最新的在前）
        anomalies.sort(key=lambda x: x.get('timestamp', ''), reverse=True)
        
        # 限制返回数量
        anomalies = anomalies[:50]
        
        return jsonify({
            'scan_id': scan_id,
            'anomalies': anomalies,
            'total_count': len(anomalies),
            'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
        })
        
    except Exception as e:
        print(f"[ERROR] Anomaly list API failed: {e}")
        import traceback
        traceback.print_exc()
        print(f"[DEBUG] Exception type: {type(e)}")
        print(f"[DEBUG] Exception args: {e.args}")
        return jsonify({'error': str(e), 'anomalies': []}), 500

def get_anomaly_suggestion(anomaly_type):
    """根据异常类型返回建议"""
    suggestions = {
        'AUTHENTICATION_FAILURE': '检查用户凭据，考虑启用多因素认证',
        'SUSPICIOUS_ACTIVITY': '审查用户行为，考虑临时限制访问',
        'SYSTEM_ERROR': '检查系统日志，重启相关服务',
        'NETWORK_ANOMALY': '检查网络连接和防火墙配置',
        'PERFORMANCE_DEGRADATION': '监控系统资源使用情况，优化性能',
        'SECURITY_VIOLATION': '立即审查安全策略，加强访问控制',
        'LOG_ANOMALY': '分析日志模式，检查系统配置',
        'SYSTEM_ANOMALY': '检查系统状态，考虑重启服务',
        'STORAGE_ANOMALY': '检查磁盘空间和存储设备状态',
        'MEMORY_ANOMALY': '监控内存使用情况，检查内存泄漏',
        'CPU_ANOMALY': '检查CPU使用率，优化进程调度',
        'SERVICE_ANOMALY': '检查服务状态，重启异常服务'
    }
    return suggestions.get(anomaly_type, '请联系系统管理员进行进一步分析')

def parse_log_line_to_anomaly(log_line):
    """解析日志行为异常对象"""
    try:
        import re
        from datetime import datetime
        
        # 尝试提取时间戳
        timestamp_patterns = [
            r'(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})',  # YYYY-MM-DD HH:MM:SS
            r'(\w{3} \d{1,2} \d{2}:\d{2}:\d{2})',      # Mon DD HH:MM:SS
            r'(\d{2}:\d{2}:\d{2})'                      # HH:MM:SS
        ]
        
        timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
        for pattern in timestamp_patterns:
            match = re.search(pattern, log_line)
            if match:
                timestamp = match.group(1)
                break
        
        # 确定严重程度
        severity = 'medium'
        if any(keyword in log_line.lower() for keyword in ['critical', 'fatal', 'panic']):
            severity = 'high'
        elif any(keyword in log_line.lower() for keyword in ['error', 'fail']):
            severity = 'high'
        elif any(keyword in log_line.lower() for keyword in ['warning', 'warn']):
            severity = 'medium'
        elif any(keyword in log_line.lower() for keyword in ['info', 'notice']):
            severity = 'low'
        
        # 确定异常类型
        anomaly_type = 'SYSTEM_ANOMALY'
        if 'network' in log_line.lower() or 'connection' in log_line.lower():
            anomaly_type = 'NETWORK_ANOMALY'
        elif 'disk' in log_line.lower() or 'storage' in log_line.lower():
            anomaly_type = 'STORAGE_ANOMALY'
        elif 'memory' in log_line.lower() or 'mem' in log_line.lower():
            anomaly_type = 'MEMORY_ANOMALY'
        elif 'cpu' in log_line.lower() or 'process' in log_line.lower():
            anomaly_type = 'CPU_ANOMALY'
        elif 'service' in log_line.lower() or 'daemon' in log_line.lower():
            anomaly_type = 'SERVICE_ANOMALY'
        elif 'security' in log_line.lower() or 'auth' in log_line.lower():
            anomaly_type = 'SECURITY_ANOMALY'
        
        # 提取消息内容（去除时间戳和主机名等前缀）
        message = log_line
        # 移除常见的日志前缀
        message = re.sub(r'^\w{3} \d{1,2} \d{2}:\d{2}:\d{2} \w+ ', '', message)
        message = re.sub(r'^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} ', '', message)
        message = re.sub(r'^\[\d+\.\d+\] ', '', message)
        
        # 限制消息长度
        if len(message) > 100:
            message = message[:97] + '...'
        
        return {
            'type': anomaly_type,
            'message': message,
            'content': log_line[:200],  # 完整内容，限制长度
            'severity': severity,
            'timestamp': timestamp,
            'source': 'System Log',
            'confidence': 0.7,  # 传统解析的置信度较低
            'count': 1,
            'suggestion': get_anomaly_suggestion(anomaly_type)
        }
        
    except Exception as e:
        # 如果解析失败，返回基本的异常对象
        return {
            'type': 'PARSE_ERROR',
            'message': log_line[:100] if log_line else 'Unknown error',
            'content': log_line[:200] if log_line else '',
            'severity': 'medium',
            'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
            'source': 'System Log',
            'confidence': 0.5,  # 解析错误的置信度最低
            'count': 1,
            'suggestion': '请联系系统管理员进行进一步分析'
        }

def get_log_anomaly_detection_status():
    """获取日志异常检测状态"""
    try:
        from log_anomaly_detector import log_anomaly_detector
        
        # 获取统计信息
        stats = log_anomaly_detector.get_statistics()
        
        return {
            'enabled': True,
            'model_trained': hasattr(log_anomaly_detector, 'anomaly_detector') and 
                           log_anomaly_detector.anomaly_detector is not None,
            'total_logs': stats.get('total_logs', 0),
            'anomaly_count': stats.get('anomaly_count', 0),
            'last_analysis': stats.get('last_analysis', 'Never'),
            'detection_accuracy': stats.get('detection_accuracy', 0.0),
            'template_count': stats.get('template_count', 0),
            'component_count': stats.get('component_count', 0)
        }
    except ImportError:
        return {
            'enabled': False,
            'model_trained': False,
            'total_logs': 0,
            'anomaly_count': 0,
            'last_analysis': 'Never',
            'detection_accuracy': 0.0,
            'template_count': 0,
            'component_count': 0
        }
    except Exception as e:
        print(f"Error getting log anomaly detection status: {e}")
        return {
            'enabled': False,
            'model_trained': False,
            'total_logs': 0,
            'anomaly_count': 0,
            'last_analysis': 'Error',
            'detection_accuracy': 0.0,
            'template_count': 0,
            'component_count': 0
        }


@app.route('/api/processes')
def get_processes():
    """获取进程列表"""
    try:
        processes = []
        for proc in psutil.process_iter(['pid', 'name', 'cpu_percent', 'memory_percent', 'status', 'create_time', 'username']):
            try:
                proc_info = proc.info
                proc_info['create_time'] = datetime.fromtimestamp(proc_info['create_time']).strftime('%H:%M:%S')
                processes.append(proc_info)
            except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
                pass
        
        # 按CPU使用率排序
        processes.sort(key=lambda x: x['cpu_percent'] or 0, reverse=True)
        return jsonify(processes)
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/files')
def list_files():
    """列出指定目录下的文件和文件夹"""
    try:
        # 获取路径参数
        path = request.args.get('path', '/')
        
        # URL解码和路径标准化
        import urllib.parse
        path = urllib.parse.unquote(path)
        path = os.path.normpath(path)
        
        # 安全检查：防止路径遍历
        if '..' in path or path.startswith('..'):
            path = '/'
        
        # 检查路径是否存在
        if not os.path.exists(path):
            # 尝试根目录
            path = '/'
            if not os.path.exists(path):
                return jsonify({'error': 'File system not accessible'}), 500
        
        # 确保是目录
        if not os.path.isdir(path):
            path = os.path.dirname(path)
            if not os.path.isdir(path):
                path = '/'
        
        # 尝试读取目录内容
        try:
            file_list = os.listdir(path)
        except PermissionError:
            path = '/'
            file_list = os.listdir(path)
        
        items = []
        for item_name in file_list:
            try:
                item_path = os.path.join(path, item_name)
                
                # 跳过隐藏文件
                if item_name.startswith('.'):
                    continue
                
                stat_info = os.stat(item_path)
                is_directory = os.path.isdir(item_path)
                
                item_data = {
                    'name': item_name,
                    'path': item_path,
                    'is_dir': is_directory,
                    'size': stat_info.st_size if not is_directory else 0,
                    'size_formatted': format_bytes(stat_info.st_size) if not is_directory else '',
                    'modified': datetime.fromtimestamp(stat_info.st_mtime).strftime('%Y-%m-%d %H:%M:%S'),
                    'permissions': oct(stat_info.st_mode)[-3:],
                    'owner': stat_info.st_uid,
                    'group': stat_info.st_gid
                }
                
                items.append(item_data)
                
            except (OSError, PermissionError):
                continue
        
        # 排序：文件夹在前，文件在后
        items.sort(key=lambda x: (not x['is_dir'], x['name'].lower()))
        
        response_data = {
            'current_path': path,
            'parent_path': os.path.dirname(path) if path != '/' else None,
            'items': items,
            'total_items': len(items)
        }
        
        return jsonify(response_data)
        
    except Exception as e:
        import traceback
        traceback.print_exc()
        return jsonify({'error': f'Server error: {str(e)}'}), 500

@app.route('/api/file-system-diagnosis')
def file_system_diagnosis():
    """文件系统诊断 - 检查文件系统访问状态"""
    try:
        diagnosis = {
            'accessible_directories': [],
            'permission_errors': [],
            'system_info': {},
            'recommendations': []
        }
        
        # 检查常见目录的访问权限
        test_directories = [
            '/',
            '/home',
            '/tmp',
            '/var',
            '/var/tmp',
            '/usr',
            '/etc',
            '/opt',
            '/mnt',
            '/media'
        ]
        
        # 添加用户主目录
        try:
            home_dir = os.path.expanduser('~')
            if home_dir not in test_directories:
                test_directories.append(home_dir)
        except:
            pass
        
        for directory in test_directories:
            try:
                if os.path.exists(directory) and os.path.isdir(directory):
                    # 测试读取权限
                    items = os.listdir(directory)
                    diagnosis['accessible_directories'].append({
                        'path': directory,
                        'items_count': len(items),
                        'readable': True,
                        'writable': os.access(directory, os.W_OK)
                    })
                else:
                    diagnosis['permission_errors'].append({
                        'path': directory,
                        'error': 'Directory does not exist'
                    })
            except PermissionError:
                diagnosis['permission_errors'].append({
                    'path': directory,
                    'error': 'Permission denied'
                })
            except Exception as e:
                diagnosis['permission_errors'].append({
                    'path': directory,
                    'error': str(e)
                })
        
        # 获取系统信息
        try:
            diagnosis['system_info'] = {
                'platform': platform.system(),
                'platform_release': platform.release(),
                'platform_version': platform.version(),
                'architecture': platform.architecture()[0],
                'processor': platform.processor(),
                'python_version': platform.python_version(),
                'current_user': os.getenv('USER') or os.getenv('USERNAME') or 'unknown',
                'current_working_directory': os.getcwd(),
                'home_directory': os.path.expanduser('~'),
                'effective_uid': os.geteuid() if hasattr(os, 'geteuid') else 'N/A',
                'effective_gid': os.getegid() if hasattr(os, 'getegid') else 'N/A'
            }
        except Exception as e:
            diagnosis['system_info']['error'] = str(e)
        
        # 生成建议
        if len(diagnosis['accessible_directories']) == 0:
            diagnosis['recommendations'].append('严重：没有可访问的目录，请检查文件系统权限')
        elif len(diagnosis['accessible_directories']) < 3:
            diagnosis['recommendations'].append('警告：可访问的目录较少，可能存在权限问题')
        
        if any('Permission denied' in error['error'] for error in diagnosis['permission_errors']):
            diagnosis['recommendations'].append('建议：检查用户权限，可能需要管理员权限')
        
        if diagnosis['system_info'].get('current_user') == 'root':
            diagnosis['recommendations'].append('注意：当前以root用户运行，请确保这是必要的')
        
        # 检查是否有可写目录
        writable_dirs = [d for d in diagnosis['accessible_directories'] if d.get('writable', False)]
        if len(writable_dirs) == 0:
            diagnosis['recommendations'].append('警告：没有可写目录，文件操作功能将受限')
        
        return jsonify(diagnosis)
        
    except Exception as e:
        return jsonify({'error': f'Diagnosis failed: {str(e)}'}), 500

@app.route('/api/network-connections')
def get_network_connections():
    """获取网络连接信息"""
    try:
        connections = []
        net_connections = psutil.net_connections(kind='inet')
        
        for conn in net_connections:
            try:
                connection_info = {
                    'laddr': conn.laddr.ip if conn.laddr else '',
                    'lport': conn.laddr.port if conn.laddr else 0,
                    'raddr': conn.raddr.ip if conn.raddr else '',
                    'rport': conn.raddr.port if conn.raddr else 0,
                    'status': conn.status,
                    'pid': conn.pid,
                    'type': 'TCP' if conn.type == socket.SOCK_STREAM else 'UDP'
                }
                connections.append(connection_info)
            except (AttributeError, psutil.AccessDenied):
                continue
        
        return jsonify(connections)
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/network-interfaces')
def get_network_interfaces():
    """获取网络接口信息"""
    try:
        interfaces = []
        net_if_addrs = psutil.net_if_addrs()
        net_if_stats = psutil.net_if_stats()
        
        for interface_name, addresses in net_if_addrs.items():
            interface_info = {
                'name': interface_name,
                'addresses': [],
                'is_up': net_if_stats[interface_name].isup if interface_name in net_if_stats else False,
                'speed': net_if_stats[interface_name].speed if interface_name in net_if_stats else 0
            }
            
            for addr in addresses:
                if addr.family == socket.AF_INET:
                    interface_info['addresses'].append({
                        'type': 'IPv4',
                        'address': addr.address,
                        'netmask': addr.netmask,
                        'broadcast': addr.broadcast
                    })
                elif addr.family == socket.AF_INET6:
                    interface_info['addresses'].append({
                        'type': 'IPv6',
                        'address': addr.address,
                        'netmask': addr.netmask
                    })
            
            interfaces.append(interface_info)
        
        return jsonify(interfaces)
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/network-stats')
def get_network_stats():
    """获取网络统计信息"""
    try:
        net_io = psutil.net_io_counters()
        net_connections = len(psutil.net_connections())
        
        return jsonify({
            'bytes_sent': net_io.bytes_sent,
            'bytes_recv': net_io.bytes_recv,
            'packets_sent': net_io.packets_sent,
            'packets_recv': net_io.packets_recv,
            'errin': net_io.errin,
            'errout': net_io.errout,
            'dropin': net_io.dropin,
            'dropout': net_io.dropout,
            'connections': net_connections
        })
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/performance-data')
def get_performance_data():
    """获取详细的性能监控数据"""
    try:
        # CPU详细信息 - 从全局广播获取CPU数据
        cpu_data = GlobalCall.real_time_cpu_data
        if not cpu_data:
            # 如果实时数据不可用，使用psutil作为后备
            cpu_percent = psutil.cpu_percent(interval=1)
            cpu_percent_per_core = [psutil.cpu_percent(interval=1, percpu=True)[i] for i in range(psutil.cpu_count())]
            cpu_count = psutil.cpu_count()
            cpu_name = f"Unknown CPU ({cpu_count} cores)"
            load_avg = psutil.getloadavg() if hasattr(psutil, 'getloadavg') else [0, 0, 0]
            cpu_freq = psutil.cpu_freq().current if hasattr(psutil, 'cpu_freq') else 0
            logical_cpu_count = psutil.cpu_count(logical=True)
            usr = 0
            nice = 0
            sys = 0
            iowait = 0
            irq = 0
            soft = 0
            steal = 0
            guest = 0
            gnice = 0
            idle = 0
            # 进程信息
            processes = []
            for proc in psutil.process_iter(['pid', 'name', 'cpu_percent', 'memory_percent']):
                try:
                    proc_info = proc.info
                    if proc_info['cpu_percent'] > 0 or proc_info['memory_percent'] > 0:
                        processes.append(proc_info)
                except (psutil.NoSuchProcess, psutil.AccessDenied):
                    continue

            # 按CPU使用率排序，取前10个
            top_processes = sorted(processes, key=lambda x: x['cpu_percent'] or 0, reverse=True)[:10]

        else:
            # 使用RealTimeCPU提供的数据
            cpu_percent = cpu_data['total_usage']
            cpu_percent_per_core = cpu_data['core_usage']
            cpu_count = cpu_data['cpu_count']
            cpu_name = cpu_data['model_name']
            load_avg = cpu_data['load_avg']
            cpu_freq = cpu_data['cpu_freq']
            logical_cpu_count = cpu_data['logical_cpu_count']
            top_processes = cpu_data['top_processes']
            usr = cpu_data['usr']
            nice = cpu_data['nice']
            sys = cpu_data['sys']
            iowait = cpu_data['iowait']
            irq = cpu_data['irq']
            soft = cpu_data['soft']
            steal = cpu_data['steal']
            guest = cpu_data['guest']
            gnice = cpu_data['gnice']
            idle = cpu_data['idle']

        # 构建CPU频率信息
        cpu_frequency_info = {
            'current': cpu_freq,
            'min': cpu_freq * 0.8,  # 假设最小值
            'max': cpu_freq * 1.2,   # 假设最大值
            'base': cpu_freq,
            'turbo_max': cpu_freq * 1.2,
            'boost': cpu_freq > (cpu_freq * 0.8 * 1.1),
            'cores': [cpu_freq] * logical_cpu_count
        }
        
        # 内存详细信息 - 从全局广播获取内存数据
        memory_data = GlobalCall.real_time_mem_data
        if not memory_data:
            # 如果实时内存数据不可用，使用psutil作为后备
            memory = psutil.virtual_memory()
            swap = psutil.swap_memory()
        else:
            # 使用RealTimeMemory提供的数据
            memory = type('obj', (object,), {
                'total': memory_data['mem_total'],
                'used': memory_data['mem_used'],
                'free': memory_data['mem_free'],
                'percent': memory_data['mem_percent'],
                'cached': memory_data['mem_cached'],
                'buffers': memory_data['mem_buffers']
            })()
            swap = type('obj', (object,), {
                'total': memory_data['swap_total'],
                'used': memory_data['swap_used'],
                'free': memory_data['swap_free'],
                'percent': memory_data['swap_percent']
            })()

        # 磁盘详细信息 - 从全局广播获取磁盘数据
        disk_data = GlobalCall.real_time_disk_data
        if not disk_data:
            # 如果实时数据不可用，使用psutil作为后备
            disk_usage = []
            partitions = psutil.disk_partitions()
            for partition in partitions:
                try:
                    usage = psutil.disk_usage(partition.mountpoint)
                    disk_usage.append({
                        'device': partition.device,
                        'mountpoint': partition.mountpoint,
                        'fstype': partition.fstype,
                        'total': usage.total,
                        'used': usage.used,
                        'free': usage.free,
                        'percent': usage.percent,
                        'utilization': 0.0
                    })
                except Exception:
                    continue

            disk_io = psutil.disk_io_counters()
            disk_io_data = {
                'read_bytes': disk_io.read_bytes if disk_io else 0,
                'write_bytes': disk_io.write_bytes if disk_io else 0,
                'read_count': disk_io.read_count if disk_io else 0,
                'write_count': disk_io.write_count if disk_io else 0,
            }
            total_utilization = psutil.disk_io_counters(perdisk=True) if hasattr(psutil, 'disk_io_counters') else {}
        else:
            # 使用RealTimeDisk提供的数据
            disk_usage = disk_data['disk_usage']
            disk_io_data = disk_data['disk_io']
            total_utilization = disk_data['total_utilization']



        # 网络详细信息 - 从全局广播获取网络数据
        net_data = GlobalCall.real_time_net_data
        if not net_data:
            # 如果实时网络数据不可用，使用psutil作为后备
            net_io = psutil.net_io_counters()
            net_interfaces = {}
            rx_speed = 0.0
            tx_speed = 0.0
        else:
            # 使用RealTimeNet提供的数据
            net_io = net_data.get('net_io', {})
            net_interfaces = net_data.get('net_interfaces', {})
            rx_speed = net_data.get('total_rx_speed', 0.0)
            tx_speed = net_data.get('total_tx_speed', 0.0)

            # 计算总的网络IO统计
            total_io = {
                'bytes_sent': 0,
                'bytes_recv': 0,
                'packets_sent': 0,
                'packets_recv': 0,
                'errin': 0,
                'errout': 0,
                'dropin': 0,
                'dropout': 0
            }

            for iface, stats in net_io.items():
                for key in total_io.keys():
                    total_io[key] += stats.get(key, 0)
        

        # 电池信息（如果是笔记本电脑）
        battery = None
        try:
            battery_info = psutil.sensors_battery()
            if battery_info:
                battery = {
                    'percent': battery_info.percent,
                    'secsleft': battery_info.secsleft,
                    'power_plugged': battery_info.power_plugged
                }
        except AttributeError:
            pass
        
        # # 获取CPU名称 - 从system_info.json文件中读取
        # cpu_name = "Unknown CPU"
        # try:
        #     system_info_path = os.path.join(os.path.dirname(__file__), 'system_info.json')
        #     if os.path.exists(system_info_path):
        #         with open(system_info_path, 'r', encoding='utf-8') as f:
        #             system_info_data = json.load(f)
        #             cpu_name = system_info_data.get('cpu_info', 'Unknown CPU')
        # except Exception as e:
        #     print(f"读取system_info.json失败: {e}")
        #     # 如果读取失败，使用platform.processor()作为备选
        #     cpu_name = platform.processor()
        #     if not cpu_name or cpu_name.strip() == '':
        #         cpu_name = f"Unknown CPU ({cpu_count} cores)"
        
        return jsonify({
            # CPU信息
            'cpu_percent': cpu_percent,
            'cpu_percent_per_core': cpu_percent_per_core,
            'cpu_average': cpu_percent,  # 直接使用总使用率
            'cpu_name': cpu_name,
            'cpu_frequency': cpu_frequency_info,
            'cpu_count_physical': cpu_count,
            'cpu_count_logical': logical_cpu_count,
            'load_avg': load_avg,
            'cpu_details': {
                'usr': usr,
                'nice': nice,
                'sys': sys,
                'iowait': iowait,
                'irq': irq,
                'soft': soft,
                'steal': steal,
                'guest': guest,
                'gnice': gnice,
                'idle': idle
            },

            # 内存信息
            'memory_percent': memory.percent,
            'memory_used': memory.used,
            'memory_total': memory.total,
            'memory_free': memory.free,
            'memory_cached': memory.cached,
            'memory_buffers': memory.buffers,

            # 交换内存信息
            'swap_percent': swap.percent,
            'swap_used': swap.used,
            'swap_total': swap.total,
            'swap_free': swap.free,
            
            # 磁盘信息
            'disk_usage': disk_usage,
            'disk_io': disk_io_data,
            'total_utilization': total_utilization,
            
            # 网络信息
            'network_io': total_io if net_data else {
                'bytes_sent': net_io.bytes_sent,
                'bytes_recv': net_io.bytes_recv,
                'packets_sent': net_io.packets_sent,
                'packets_recv': net_io.packets_recv,
                'errin': net_io.errin,
                'errout': net_io.errout,
                'dropin': net_io.dropin,
                'dropout': net_io.dropout,
            },
            'rx_speed': rx_speed,
            'tx_speed': tx_speed,
            'network_interfaces': net_interfaces,
            
            # 进程信息
            'top_processes': top_processes,
            'process_count': len(list(psutil.process_iter())),
            
            # 电池信息
            'battery': battery,
            
            # 系统信息
            'boot_time': psutil.boot_time(),
            'timestamp': time.time()
        })
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/security-status')
def get_security_status():
    """获取安全状态信息"""
    try:
        # 检查防火墙状态 (Windows)
        firewall_active = False
        try:
            if platform.system() == 'Windows':
                firewall_result = subprocess.run(['netsh', 'advfirewall', 'show', 'allprofiles', 'state'], 
                                               capture_output=True, text=True, shell=True)
                firewall_active = 'ON' in firewall_result.stdout
            else:
                firewall_result = subprocess.run(['ufw', 'status'], capture_output=True, text=True)
                firewall_active = 'Status: active' in firewall_result.stdout
        except:
            firewall_active = True  # 默认假设防火墙开启
        
        # 检查Windows Defender状态
        antivirus_active = False
        try:
            if platform.system() == 'Windows':
                defender_result = subprocess.run(['powershell', '-Command', 
                    'Get-MpComputerStatus | Select-Object -ExpandProperty RealTimeProtectionEnabled'], 
                    capture_output=True, text=True, shell=True)
                antivirus_active = 'True' in defender_result.stdout
            else:
                antivirus_active = True  # Linux系统默认假设有防护
        except:
            antivirus_active = True
        
        # 检查系统更新状态
        updates_available = 0
        try:
            if platform.system() == 'Windows':
                # Windows更新检查
                update_result = subprocess.run(['powershell', '-Command', 
                    'Get-WindowsUpdate -AcceptAll | Measure-Object | Select-Object -ExpandProperty Count'], 
                    capture_output=True, text=True, shell=True)
                try:
                    updates_available = int(update_result.stdout.strip())
                except:
                    updates_available = 3  # 模拟数据
            else:
                # Linux更新检查
                update_result = subprocess.run(['apt', 'list', '--upgradable'], capture_output=True, text=True)
                updates_available = len(update_result.stdout.split('\n')) - 2
        except:
            updates_available = 3  # 模拟数据
        
        # 检查登录失败次数
        failed_logins = 0
        try:
            if platform.system() == 'Windows':
                # Windows事件日志检查
                event_result = subprocess.run(['powershell', '-Command', 
                    'Get-EventLog -LogName Security -InstanceId 4625 -Newest 10 | Measure-Object | Select-Object -ExpandProperty Count'], 
                    capture_output=True, text=True, shell=True)
                try:
                    failed_logins = int(event_result.stdout.strip())
                except:
                    failed_logins = 0
            else:
                auth_log = subprocess.run(['grep', 'Failed password', '/var/log/auth.log'], capture_output=True, text=True)
                failed_logins = len(auth_log.stdout.split('\n')) - 1
        except:
            failed_logins = 0
        
        # 获取日志异常检测状态
        log_anomaly_status = get_log_anomaly_detection_status()
        
        # 计算总体安全评分
        security_score = 100
        if not firewall_active:
            security_score -= 30
        if not antivirus_active:
            security_score -= 40
        if updates_available > 0:
            security_score -= min(updates_available * 5, 20)
        if failed_logins > 5:
            security_score -= 10
        
        # 根据日志异常情况调整安全评分
        if log_anomaly_status['anomaly_count'] > 10:
            security_score -= 15
        elif log_anomaly_status['anomaly_count'] > 5:
            security_score -= 10
        elif log_anomaly_status['anomaly_count'] > 0:
            security_score -= 5
        
        security_level = "excellent" if security_score >= 90 else "good" if security_score >= 70 else "warning" if security_score >= 50 else "critical"
        
        return jsonify({
            'firewall_active': firewall_active,
            'antivirus_active': antivirus_active,
            'updates_available': updates_available,
            'failed_logins': failed_logins,
            'security_score': security_score,
            'security_level': security_level,
            'last_check': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
            'threats_blocked': log_anomaly_status['anomaly_count'],
            'permission_requests': 2,  # 模拟数据
            'last_scan': datetime.now().strftime('%Y-%m-%d'),
            'definitions_updated': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
            # 新增日志异常检测相关信息
            'log_anomaly_detection': {
                'enabled': log_anomaly_status['enabled'],
                'model_trained': log_anomaly_status['model_trained'],
                'total_logs_analyzed': log_anomaly_status['total_logs'],
                'anomalies_detected': log_anomaly_status['anomaly_count'],
                'detection_method': 'Jieba+Drain模板解析 + CSCFM异常检测模型',
                'last_analysis': log_anomaly_status['last_analysis']
            }
        })
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/security-scan', methods=['POST'])
def start_security_scan():
    """启动安全扫描"""
    try:
        data = request.get_json() or {}
        scan_type = data.get('type', 'quick')
        include_log_analysis = data.get('include_log_analysis', True)
        
        # 新增：支持指定日志文件扫描
        log_files = data.get('log_files', [])
        max_lines = data.get('max_lines', 10000)
        enable_auto_repair = data.get('enable_auto_repair', False)
        enable_real_time = data.get('enable_real_time', False)
        
        # 如果指定了日志文件，使用专门的日志分析扫描
        if log_files:
            scan_results = start_log_analysis_scan(
                log_files=log_files,
                max_lines=max_lines,
                enable_auto_repair=enable_auto_repair,
                enable_real_time=enable_real_time
            )
        else:
            # 启动常规安全扫描
            scan_results = start_new_scan(scan_type)
        
        # 如果启用了日志分析，添加日志异常检测信息
        if include_log_analysis:
            try:
                log_status = get_log_anomaly_detection_status()
                scan_results['log_anomaly_detection'] = {
                    'enabled': log_status['enabled'],
                    'model_trained': log_status['model_trained'],
                    'anomalies_detected': log_status['anomaly_count'],
                    'detection_method': 'Jieba+Drain模板解析 + CSCFM异常检测模型' if log_status['enabled'] else '基础规则匹配'
                }
            except Exception as e:
                print(f"获取日志异常检测状态失败: {e}")
                scan_results['log_anomaly_detection'] = {
                    'enabled': False,
                    'error': str(e)
                }
        
        return jsonify(scan_results)
    except Exception as e:
        return jsonify({'error': str(e)}), 500

def start_log_analysis_scan(log_files, max_lines=10000, enable_auto_repair=False, enable_real_time=False):
    """启动专门的日志分析扫描"""
    try:
        # 创建安全扫描器实例
        scanner = SecurityScanner()
        
        # 启动日志分析扫描
        scan_results = scanner.start_scan(
            scan_type='log_analysis',
            log_files=log_files,
            max_lines=max_lines,
            enable_auto_repair=enable_auto_repair,
            enable_real_time=enable_real_time
        )
        
        # 添加日志文件信息到结果中
        scan_results['log_files_info'] = {
            'specified_files': log_files,
            'max_lines_per_file': max_lines,
            'auto_repair_enabled': enable_auto_repair,
            'real_time_monitoring': enable_real_time,
            'scan_method': 'get_system_message.py集成扫描'
        }
        
        return scan_results
        
    except Exception as e:
        print(f"启动日志分析扫描失败: {e}")
        return {
            'error': str(e),
            'scan_type': 'log_analysis',
            'status': 'failed'
        }

@app.route('/api/security-scan/<scan_id>')
def get_scan_status(scan_id):
    """获取扫描状态"""
    try:
        scan_status = get_specified_scan_status(scan_id)
        
        # 检查是否有错误
        if 'error' in scan_status:
            return jsonify(scan_status), 404

        progress = scan_status.get('progress', 0)
        files_scanned = scan_status.get('files_scanned', 0)
        threats_found = scan_status.get('threats_found', 0)
        status = scan_status.get('status', 'running')

        # 直接返回从scanner获取的完整状态信息
        scan_status_dict = {
            'scan_id': scan_id,
            'status': status,
            'progress': progress,
            'files_scanned': files_scanned,
            'threats_found': threats_found,
            'lines_scanned': scan_status.get('lines_scanned', files_scanned),
            'anomalies_found': scan_status.get('anomalies_found', threats_found),
            'auto_repair_enabled': scan_status.get('auto_repair_enabled', False),
            'repair_actions_count': scan_status.get('repair_actions_count', 0),
            'estimated_time': max(0, 60 - (progress * 0.6)),
            'current_file': '正在扫描' if status == 'running' else '扫描完成'
        }

        # 如果扫描完成，添加结果摘要
        if progress >= 100 and 'result_summary' in scan_status:
            scan_status_dict['result_summary'] = scan_status['result_summary']
        
        # 添加日志异常检测详细信息
        try:
            log_status = get_log_anomaly_detection_status()
            scan_status_dict['log_anomaly_detection'] = {
                'enabled': log_status['enabled'],
                'model_trained': log_status['model_trained'],
                'total_logs_analyzed': log_status['total_logs'],
                'anomalies_detected': log_status['anomaly_count'],
                'detection_accuracy': log_status.get('detection_accuracy', 0.0),
                'template_count': log_status.get('template_count', 0),
                'component_count': log_status.get('component_count', 0),
                'last_analysis': log_status['last_analysis'],
                'detection_method': 'Jieba+Drain模板解析 + CSCFM异常检测模型' if log_status['enabled'] else '基础规则匹配'
            }
        except Exception as e:
            print(f"获取日志异常检测状态失败: {e}")
            scan_status_dict['log_anomaly_detection'] = {
                'enabled': False,
                'error': str(e)
            }
        
        return jsonify(scan_status_dict)
    except Exception as e:
        return jsonify({
            'scan_id': scan_id,
            'status': 'failed',
            'progress': 0,
            'files_scanned': 0,
            'threats_found': 0,
            'lines_scanned': 0,
            'anomalies_found': 0,
            'auto_repair_enabled': False,
            'repair_actions_count': 0,
            'error': str(e)
        }), 500

@app.route('/api/security-recommendations')
def get_security_recommendations():
    """获取安全建议"""
    try:
        recommendations = [
            {
                'id': 1,
                'type': 'warning',
                'title_key': 'security-center-enable-auto-update-title',
                'title': '启用自动更新',
                'description_key': 'security-center-enable-auto-update-desc',
                'description': '建议启用系统自动更新以获得最新的安全补丁',
                'priority': 'high',
                'action': 'enable_auto_update'
            },
            {
                'id': 2,
                'type': 'info',
                'title_key': 'security-center-backup-data-title',
                'title': '定期备份数据',
                'description_key': 'security-center-backup-data-desc',
                'description': '建议定期备份重要数据以防止数据丢失',
                'priority': 'medium',
                'action': 'setup_backup'
            },
            {
                'id': 3,
                'type': 'warning',
                'title_key': 'security-center-update-password-title',
                'title': '更新密码策略',
                'description_key': 'security-center-update-password-desc',
                'description': '建议使用更强的密码策略来提高账户安全性',
                'priority': 'medium',
                'action': 'update_password_policy'
            }
        ]
        
        return jsonify(recommendations)
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/today-logs-export')
def get_today_logs_export():
    """获取今日日志数据用于CSV导出"""
    try:
        logs_data = []
        
        # 首先尝试从实时日志流数据源获取
        try:
            system_log = GlobalCall.real_time_sys_message_data
            recent_logs = system_log.get('recent_logs', [])
            
            if recent_logs:
                # 解析实时日志数据
                import re
                for log_content in recent_logs:
                    if log_content:
                        lines = log_content.split('\n')
                        for line in lines:
                            line = line.strip()
                            if not line:
                                continue
                            
                            # 尝试解析日志格式: "月 日 时间 主机 进程: 消息"
                            match = re.match(r'^(\w{3})\s+(\d{1,2})\s+(\d{2}:\d{2}:\d{2})\s+\S+\s+(.+)$', line)
                            if match:
                                month, day, time_str, message = match.groups()
                                
                                # 构造完整时间戳
                                current_year = datetime.now().year
                                try:
                                    # 将月份缩写转换为数字
                                    month_map = {
                                        'Jan': 1, 'Feb': 2, 'Mar': 3, 'Apr': 4, 'May': 5, 'Jun': 6,
                                        'Jul': 7, 'Aug': 8, 'Sep': 9, 'Oct': 10, 'Nov': 11, 'Dec': 12
                                    }
                                    month_num = month_map.get(month, 1)
                                    timestamp = f"{current_year}-{month_num:02d}-{int(day):02d} {time_str}"
                                except:
                                    timestamp = f"{month} {day} {time_str}"
                                
                                # 检测日志级别
                                level = 'Info'
                                message_lower = message.lower()
                                if any(keyword in message_lower for keyword in ['error', 'fail', 'critical', 'fatal']):
                                    level = 'Error'
                                elif any(keyword in message_lower for keyword in ['warn', 'warning']):
                                    level = 'Warning'
                                elif any(keyword in message_lower for keyword in ['debug']):
                                    level = 'Debug'
                                
                                # 提取来源
                                source = 'System'
                                if ':' in message:
                                    parts = message.split(':', 1)
                                    if len(parts) > 1:
                                        source = parts[0].strip()
                                        message = parts[1].strip()
                                
                                logs_data.append({
                                    'timestamp': timestamp,
                                    'level': level,
                                    'source': source,
                                    'message': message[:200]  # 限制消息长度
                                })
                            else:
                                # 如果无法解析格式，直接作为消息处理
                                logs_data.append({
                                    'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                                    'level': 'Info',
                                    'source': 'System',
                                    'message': line[:200]
                                })
        except Exception as e:
            print(f"从实时日志流获取数据失败: {e}")
        
        # 如果实时日志流没有数据，尝试从系统命令获取
        if not logs_data:
            try:
                if platform.system() == 'Windows':
                    # Windows事件日志
                    log_result = subprocess.run(['powershell', '-Command', 
                        '''Get-EventLog -LogName System -After (Get-Date).Date | Select-Object TimeGenerated, EntryType, Source, Message | ConvertTo-Json'''], 
                        capture_output=True, text=True, shell=True, timeout=30)
                    
                    if log_result.returncode == 0 and log_result.stdout.strip():
                        try:
                            import json
                            events = json.loads(log_result.stdout)
                            if not isinstance(events, list):
                                events = [events] if events else []
                            
                            for event in events[:1000]:  # 限制最多1000条
                                logs_data.append({
                                    'timestamp': event.get('TimeGenerated', ''),
                                    'level': event.get('EntryType', 'Info'),
                                    'source': event.get('Source', ''),
                                    'message': event.get('Message', '')[:200]  # 限制消息长度
                                })
                        except json.JSONDecodeError:
                            pass
                else:
                    # Linux系统日志
                    today_str = datetime.now().strftime('%b %d')
                    log_result = subprocess.run(['grep', today_str, '/var/log/syslog'], 
                                              capture_output=True, text=True, timeout=30)
                    
                    if log_result.returncode == 0:
                        lines = log_result.stdout.split('\n')[:1000]  # 限制最多1000条
                        for line in lines:
                            if line.strip():
                                parts = line.split(' ', 5)
                                if len(parts) >= 6:
                                    timestamp = f"{parts[0]} {parts[1]} {parts[2]}"
                                    source = parts[3]
                                    message = parts[5] if len(parts) > 5 else ''
                                    
                                    # 检测日志级别
                                    level = 'Info'
                                    if 'error' in message.lower() or 'fail' in message.lower():
                                        level = 'Error'
                                    elif 'warn' in message.lower():
                                        level = 'Warning'
                                    
                                    logs_data.append({
                                        'timestamp': timestamp,
                                        'level': level,
                                        'source': source,
                                        'message': message[:200]  # 限制消息长度
                                    })
            except Exception as e:
                print(f"从系统命令获取日志失败: {e}")
        
        # 如果没有获取到真实日志，生成模拟数据
        if not logs_data:
            current_time = datetime.now()
            for i in range(50):
                time_offset = current_time - timedelta(minutes=i*10)
                level = ['Info', 'Warning', 'Error'][i % 3] if i % 7 == 0 else 'Info'
                logs_data.append({
                    'timestamp': time_offset.strftime('%Y-%m-%d %H:%M:%S'),
                    'level': level,
                    'source': f'System{i%5+1}',
                    'message': f'系统日志消息 {i+1} - 模拟数据用于演示'
                })
        
        return jsonify({
            'logs': logs_data,
            'total_count': len(logs_data),
            'export_time': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
        })
        
    except Exception as e:
        return jsonify({'error': str(e)}), 500



@app.route('/api/security-history')
def get_security_history():
    """获取安全历史记录"""
    try:
        period = request.args.get('period', 'today')
        
        # 模拟历史数据
        history_items = []
        
        if period == 'today':
            history_items = [
                {
                    'id': 1,
                    'type': 'success',
                    'title_key': 'security-center-scan-complete-title',
                    'title': '系统扫描完成',
                    'description_key': 'security-center-scan-complete-desc',
                    'description': '快速扫描未发现威胁',
                    'time_key': 'security-center-2-hours-ago',
                    'time': '2小时前',
                    'timestamp': (datetime.now() - timedelta(hours=2)).strftime('%Y-%m-%d %H:%M:%S')
                },
                {
                    'id': 2,
                    'type': 'warning',
                    'title_key': 'security-center-firewall-update-title',
                    'title': '防火墙规则更新',
                    'description_key': 'security-center-firewall-update-desc',
                    'description': '已更新防火墙规则以阻止可疑连接',
                    'time_key': 'security-center-4-hours-ago',
                    'time': '4小时前',
                    'timestamp': (datetime.now() - timedelta(hours=4)).strftime('%Y-%m-%d %H:%M:%S')
                }
            ]
        elif period == 'week':
            history_items = [
                {
                    'id': 3,
                    'type': 'success',
                    'title_key': 'security-center-virus-def-update-title',
                    'title': '病毒定义更新',
                    'description_key': 'security-center-virus-def-update-desc',
                    'description': '病毒定义已更新到最新版本',
                    'time_key': 'security-center-2-days-ago',
                    'time': '2天前',
                    'timestamp': (datetime.now() - timedelta(days=2)).strftime('%Y-%m-%d %H:%M:%S')
                },
                {
                    'id': 4,
                    'type': 'error',
                    'title_key': 'security-center-malware-detected-title',
                    'title': '检测到恶意软件',
                    'description_key': 'security-center-malware-detected-desc',
                    'description': '已检测并清除1个恶意软件',
                    'time_key': 'security-center-3-days-ago',
                    'time': '3天前',
                    'timestamp': (datetime.now() - timedelta(days=3)).strftime('%Y-%m-%d %H:%M:%S')
                }
            ]
        else:  # month
            history_items = [
                {
                    'id': 5,
                    'type': 'success',
                    'title_key': 'security-center-system-update-title',
                    'title': '系统更新安装',
                    'description_key': 'security-center-system-update-desc',
                    'description': '已安装5个安全更新',
                    'time_key': 'security-center-1-week-ago',
                    'time': '1周前',
                    'timestamp': (datetime.now() - timedelta(weeks=1)).strftime('%Y-%m-%d %H:%M:%S')
                },
                {
                    'id': 6,
                    'type': 'warning',
                    'title_key': 'security-center-login-anomaly-title',
                    'title': '登录异常检测',
                    'description_key': 'security-center-login-anomaly-desc',
                    'description': '检测到异常登录尝试，已自动阻止',
                    'time_key': 'security-center-2-weeks-ago',
                    'time': '2周前',
                    'timestamp': (datetime.now() - timedelta(weeks=2)).strftime('%Y-%m-%d %H:%M:%S')
                }
            ]
        
        return jsonify(history_items)
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/security-toggle', methods=['POST'])
def toggle_security_feature():
    """切换安全功能状态"""
    try:
        data = request.get_json()
        feature = data.get('feature')
        enabled = data.get('enabled', True)
        
        # 模拟切换功能
        success = True
        message = f"{'启用' if enabled else '禁用'}了{feature}"
        
        # 这里可以添加实际的功能切换逻辑
        if feature == 'firewall':
            # 防火墙切换逻辑
            pass
        elif feature == 'antivirus':
            # 防病毒切换逻辑
            pass
        
        return jsonify({
            'success': success,
            'message': message,
            'feature': feature,
            'enabled': enabled
        })
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/execute-command', methods=['POST'])
def execute_command():
    """执行终端命令"""
    try:
        data = request.get_json()
        command = data.get('command', '').strip()
        
        if not command:
            return jsonify({'error': 'No command provided'}), 400
        
        # 安全检查 - 禁止危险命令
        dangerous_commands = [
            'rm -rf', 'mkfs', 'dd if=', 'shutdown', 'reboot', 'halt',
            'format', 'fdisk', 'parted', 'wipefs', 'shred',
            'passwd', 'su -', 'sudo su', 'chmod 777', 'chown root'
        ]
        
        command_lower = command.lower()
        if any(dangerous in command_lower for dangerous in dangerous_commands):
            return jsonify({'error': 'Dangerous command not allowed for security reasons'}), 403
        
        # 限制某些系统目录的访问
        restricted_paths = ['/etc/passwd', '/etc/shadow', '/boot', '/sys', '/proc/sys']
        if any(path in command for path in restricted_paths):
            return jsonify({'error': 'Access to system files restricted'}), 403
        
        # 处理特殊命令
        if command_lower == 'clear' or command_lower == 'cls':
            return jsonify({
                'output': '',
                'error': '',
                'return_code': 0,
                'command': command,
                'special': 'clear'
            })
        
        # Windows系统命令映射
        if platform.system() == 'Windows':
            command_mappings = {
                'ls': 'dir',
                'ls -la': 'dir /a',
                'ls -l': 'dir',
                'cat': 'type',
                'grep': 'findstr',
                'ps': 'tasklist',
                'ps aux': 'tasklist /v',
                'kill': 'taskkill /PID',
                'which': 'where',
                'pwd': 'cd',
                'df -h': 'wmic logicaldisk get size,freespace,caption',
                'free -h': 'wmic OS get TotalVisibleMemorySize,FreePhysicalMemory /format:list',
                'top': 'tasklist /v',
                'netstat -tuln': 'netstat -an',
                'ifconfig': 'ipconfig',
                'uname -a': 'systeminfo | findstr /B /C:"OS Name" /C:"OS Version" /C:"System Type"'
            }
            
            # 检查是否需要映射命令
            for unix_cmd, windows_cmd in command_mappings.items():
                if command.startswith(unix_cmd):
                    command = command.replace(unix_cmd, windows_cmd, 1)
                    break
        
        # 执行命令
        try:
            if platform.system() == 'Windows':
                result = subprocess.run(
                    command,
                    shell=True,
                    capture_output=True,
                    text=True,
                    timeout=30,
                    encoding='utf-8',
                    errors='ignore'
                )
            else:
                result = subprocess.run(
                    command,
                    shell=True,
                    capture_output=True,
                    text=True,
                    timeout=30
                )
        except UnicodeDecodeError:
            # 处理编码问题
            result = subprocess.run(
                command,
                shell=True,
                capture_output=True,
                timeout=30
            )
            output = result.stdout.decode('utf-8', errors='ignore') if result.stdout else ''
            error = result.stderr.decode('utf-8', errors='ignore') if result.stderr else ''
            
            return jsonify({
                'output': output,
                'error': error,
                'return_code': result.returncode,
                'command': command
            })
        
        return jsonify({
            'output': result.stdout,
            'error': result.stderr,
            'return_code': result.returncode,
            'command': command
        })
        
    except subprocess.TimeoutExpired:
        return jsonify({'error': 'Command timeout (30 seconds limit)'}), 408
    except FileNotFoundError:
        return jsonify({'error': 'Command not found'}), 404
    except PermissionError:
        return jsonify({'error': 'Permission denied'}), 403
    except Exception as e:
        return jsonify({'error': f'Execution error: {str(e)}'}), 500

@app.route('/api/terminal-info')
def get_terminal_info():
    """获取终端相关信息"""
    try:
        import getpass
        
        # 获取当前用户
        try:
            current_user = getpass.getuser()
        except:
            current_user = 'user'
        
        # 获取主机名
        hostname = platform.node()
        
        # 获取当前工作目录
        try:
            current_dir = os.getcwd()
        except:
            current_dir = '~'
        
        # 获取系统信息
        system_info = {
            'system': platform.system(),
            'release': platform.release(),
            'version': platform.version(),
            'machine': platform.machine(),
            'processor': platform.processor()
        }
        
        return jsonify({
            'user': current_user,
            'hostname': hostname,
            'current_directory': current_dir,
            'system_info': system_info,
            'shell': os.environ.get('SHELL', 'cmd' if platform.system() == 'Windows' else 'bash')
        })
        
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/weather')
def weather():
    """模拟天气信息"""
    return jsonify({
        'temperature': '22°C',
        'condition': 'sunny',
        'location': '北京'
    })

@app.route('/api/settings', methods=['GET'])
def get_settings():
    """获取当前设置"""
    try:
        settings_file = 'settings.json'
        if os.path.exists(settings_file):
            with open(settings_file, 'r', encoding='utf-8') as f:
                settings = json.load(f)
        else:
            # 默认设置
            settings = {
                'theme': {
                    'background_type': 'gradient',
                    'background_color': '#1a1a2e',
                    'secondary_color': '#16213e',
                    'accent_color': '#0f3460',
                    'custom_background': '',
                    'opacity': 0.95
                },
                'interface': {
                    'animation_enabled': True,
                    'blur_enabled': True,
                    'transparency_enabled': True
                }
            }
        
        return jsonify(settings)
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/settings', methods=['POST'])
def save_settings():
    """保存设置"""
    try:
        data = request.get_json()
        settings_file = 'settings.json'
        
        with open(settings_file, 'w', encoding='utf-8') as f:
            json.dump(data, f, ensure_ascii=False, indent=2)
        
        return jsonify({'success': True, 'message': '设置已保存'})
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/settings/reset', methods=['POST'])
def reset_settings():
    """重置设置为默认值"""
    try:
        settings_file = 'settings.json'
        default_settings = {
            'theme': {
                'background_type': 'gradient',
                'background_color': '#1a1a2e',
                'secondary_color': '#16213e',
                'accent_color': '#0f3460',
                'custom_background': '',
                'opacity': 0.95
            },
            'interface': {
                'animation_enabled': True,
                'blur_enabled': True,
                'transparency_enabled': True
            }
        }
        
        with open(settings_file, 'w', encoding='utf-8') as f:
            json.dump(default_settings, f, ensure_ascii=False, indent=2)
        
        return jsonify({'success': True, 'message': '设置已重置为默认值'})
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/ai-chat', methods=['POST'])
def ai_chat_api():
    """AI对话API"""
    try:
        data = request.get_json()
        message = data.get('message', '').strip()
        conversation_id = data.get('conversation_id')
        stream = data.get('stream', False)
        
        if not message:
            return jsonify({'error': '消息不能为空'}), 400
        
        # 使用AI服务进行对话
        result = ai_service.chat_with_ai(message, conversation_id, stream)
        
        if 'error' in result:
            return jsonify(result), 500 if not result.get('loading') else 202
        
        if stream and 'stream' in result:
            # 流式响应
            def generate():
                try:
                    for chunk_data in result['stream']:
                        if isinstance(chunk_data, dict):
                            yield f"data: {json.dumps(chunk_data, ensure_ascii=False)}\n\n"
                        else:
                            # 如果是字符串，包装成标准格式
                            chunk_obj = {
                                'content': chunk_data,
                                'conversation_id': result.get('conversation_id')
                            }
                            yield f"data: {json.dumps(chunk_obj, ensure_ascii=False)}\n\n"
                    yield "data: [DONE]\n\n"
                except Exception as e:
                    error_obj = {'error': str(e)}
                    yield f"data: {json.dumps(error_obj, ensure_ascii=False)}\n\n"
                    yield "data: [DONE]\n\n"
            
            return Response(generate(), mimetype='text/event-stream', headers={
                'Cache-Control': 'no-cache',
                'Connection': 'keep-alive',
                'X-Accel-Buffering': 'no'
            })
        else:
            return jsonify(result)
        
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/ai-chat/clear', methods=['POST'])
def clear_chat_history():
    """清空聊天历史"""
    try:
        data = request.get_json() or {}
        conversation_id = data.get('conversation_id')

        if not conversation_id is None:
            ai_service.clear_conversation(conversation_id)
            return jsonify({
                'success': True,
                'message': '聊天历史已清空'
            })

        history_dir = os.path.join(os.path.dirname(__file__), 'LLM', 'history')

            # 列出所有JSON文件
        for filename in os.listdir(history_dir):
            if filename.endswith('.json'):
                conversation_id = filename[:-5]  # 去掉.json后缀
                ai_service.clear_conversation(conversation_id)
        return jsonify({
            'success': True,
            'message': '聊天历史已清空'
        })
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/ai-chat/status', methods=['GET'])
def ai_status():
    """获取AI服务状态"""
    try:
        status = ai_service.get_model_status()
        return jsonify(status)
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/ai-chat/init', methods=['POST'])
def init_ai_model():
    """初始化AI模型"""
    try:
        ai_service.initialize_model()
        return jsonify({
            'success': True,
            'message': '正在初始化AI模型...'
        })
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/ai-chat/model-info', methods=['GET'])
def get_ai_model_info():
    """获取AI模型信息"""
    try:
        info = ai_service.get_model_info()
        return jsonify(info)
    except Exception as e:
        return jsonify({'error': str(e)}), 500


# 对话列表
@app.route('/api/ai-chat/conversations')
def get_conversations():
    """获取所有对话列表"""
    history_dir = os.path.join(os.path.dirname(__file__), 'LLM', 'history')
    conversations = []

    try:
        # 列出所有JSON文件
        for filename in os.listdir(history_dir):
            if filename.endswith('.json'):
                conversation_id = filename[:-5]  # 去掉.json后缀
                file_path = os.path.join(history_dir, filename)
                try:
                    # 获取文件修改时间
                    mtime = os.path.getmtime(file_path)
                    # 尝试读取第一条消息作为标题
                    with open(file_path, 'r', encoding='utf-8') as f:
                        data = json.load(f)
                        title = "新对话"
                        if data and isinstance(data, list) and len(data) > 0:
                            first_msg = data[0]
                            if 'content' in first_msg:
                                title = first_msg['content'][:50]  # 截取前50个字符
                except:
                    title = "新对话"

                conversations.append({
                    "id": conversation_id,
                    "title": title,
                    "last_modified": datetime.fromtimestamp(mtime).strftime('%Y-%m-%d %H:%M:%S')
                })
    except Exception as e:
        print(f"获取对话列表失败: {e}")

    # 按修改时间倒序排序
    conversations.sort(key=lambda x: x["last_modified"], reverse=True)
    return jsonify(conversations)


@app.route('/api/ai-chat/history-messages', methods=['GET'])
def get_conversation_messages():
    """获取特定对话的消息历史"""
    conversation_id = request.args.get('conversation_id')
    if not conversation_id:
        return jsonify({"error": "缺少conversation_id参数"}), 400

    # 从AI服务获取历史消息
    messages = ai_service.get_conversation_history(conversation_id)
    return jsonify(messages)

@app.route('/api/file-preview')
def file_preview():
    """文件预览API - 获取文件内容用于预览"""
    try:
        file_path = request.args.get('path')
        if not file_path:
            return jsonify({'error': '文件路径不能为空'}), 400
        
        # URL解码和路径标准化
        import urllib.parse
        file_path = urllib.parse.unquote(file_path)
        file_path = os.path.normpath(file_path)
        
        # 安全检查：防止路径遍历
        if '..' in file_path or not os.path.isabs(file_path):
            return jsonify({'error': '无效的文件路径'}), 400
        
        # 检查文件是否存在
        if not os.path.exists(file_path):
            return jsonify({'error': '文件不存在'}), 404
        
        # 检查是否为文件
        if not os.path.isfile(file_path):
            return jsonify({'error': '指定路径不是文件'}), 400
        
        # 获取文件信息
        stat_info = os.stat(file_path)
        file_size = stat_info.st_size
        file_name = os.path.basename(file_path)
        file_ext = os.path.splitext(file_name)[1].lower()
        
        # 文件大小限制（10MB）
        max_size = 10 * 1024 * 1024
        if file_size > max_size:
            return jsonify({
                'error': f'文件过大（{format_bytes(file_size)}），无法预览',
                'file_info': {
                    'name': file_name,
                    'size': file_size,
                    'size_formatted': format_bytes(file_size),
                    'extension': file_ext
                }
            }), 413
        
        # 根据文件类型处理
        response_data = {
            'file_info': {
                'name': file_name,
                'path': file_path,
                'size': file_size,
                'size_formatted': format_bytes(file_size),
                'extension': file_ext,
                'modified': datetime.fromtimestamp(stat_info.st_mtime).strftime('%Y-%m-%d %H:%M:%S')
            }
        }
        
        # 文本文件类型
        text_extensions = {
            '.txt', '.log', '.md', '.py', '.js', '.html', '.css', '.json', '.xml', '.yml', '.yaml',
            '.conf', '.cfg', '.ini', '.sh', '.bat', '.ps1', '.sql', '.csv', '.tsv', '.properties',
            '.dockerfile', '.gitignore', '.gitattributes', '.env', '.htaccess', '.robots'
        }
        
        # 图像文件类型
        image_extensions = {
            '.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp', '.svg', '.ico', '.tiff', '.tif'
        }
        
        # PDF文件类型
        pdf_extensions = {'.pdf'}
        
        if file_ext in text_extensions or file_ext == '':
            # 尝试读取为文本文件
            try:
                # 尝试不同的编码
                encodings = ['utf-8', 'gbk', 'gb2312', 'latin-1', 'ascii']
                content = None
                used_encoding = None
                
                for encoding in encodings:
                    try:
                        with open(file_path, 'r', encoding=encoding) as f:
                            content = f.read()
                            used_encoding = encoding
                            break
                    except UnicodeDecodeError:
                        continue
                
                if content is not None:
                    # 限制预览内容长度
                    max_content_length = 50000  # 50KB
                    if len(content) > max_content_length:
                        content = content[:max_content_length] + '\n\n... (文件内容过长，已截断)'
                    
                    response_data.update({
                        'type': 'text',
                        'content': content,
                        'encoding': used_encoding,
                        'lines': len(content.split('\n'))
                    })
                else:
                    response_data.update({
                        'type': 'unsupported',
                        'message': '无法读取文件内容（编码不支持）'
                    })
                    
            except Exception as e:
                response_data.update({
                    'type': 'error',
                    'message': f'读取文件失败: {str(e)}'
                })
                
        elif file_ext in image_extensions:
            # 图像文件
            response_data.update({
                'type': 'image',
                'url': f'/api/file-download?path={urllib.parse.quote(file_path)}'
            })
            
        elif file_ext in pdf_extensions:
            # PDF文件 - 使用专门的PDF预览路由
            response_data.update({
                'type': 'pdf',
                'url': f'/api/pdf-viewer?path={urllib.parse.quote(file_path)}'
            })
            
        else:
            # 不支持的文件类型
            response_data.update({
                'type': 'unsupported',
                'message': f'不支持预览 {file_ext} 类型的文件'
            })
        
        return jsonify(response_data)
        
    except Exception as e:
        import traceback
        traceback.print_exc()
        return jsonify({'error': f'预览文件失败: {str(e)}'}), 500

@app.route('/api/pdf-viewer')
def pdf_viewer():
    """PDF查看器API - 专门用于PDF文件预览"""
    try:
        file_path = request.args.get('path')
        if not file_path:
            return jsonify({'error': '文件路径不能为空'}), 400
        
        # URL解码和路径标准化
        import urllib.parse
        file_path = urllib.parse.unquote(file_path)
        file_path = os.path.normpath(file_path)
        
        # 安全检查：防止路径遍历
        if '..' in file_path or not os.path.isabs(file_path):
            return jsonify({'error': '无效的文件路径'}), 400
        
        # 检查文件是否存在
        if not os.path.exists(file_path):
            return jsonify({'error': '文件不存在'}), 404
        
        # 检查是否为PDF文件
        if not file_path.lower().endswith('.pdf'):
            return jsonify({'error': '不是PDF文件'}), 400
        
        # 检查是否为文件
        if not os.path.isfile(file_path):
            return jsonify({'error': '指定路径不是文件'}), 400
        
        # 创建响应
        response = make_response(send_file(
            file_path,
            mimetype='application/pdf',
            as_attachment=False
        ))
        
        # 设置PDF预览的HTTP头部
        response.headers['Content-Type'] = 'application/pdf'
        response.headers['Content-Disposition'] = 'inline'
        response.headers['X-Frame-Options'] = 'SAMEORIGIN'
        response.headers['Content-Security-Policy'] = "frame-ancestors 'self'"
        response.headers['Cache-Control'] = 'no-cache, no-store, must-revalidate'
        response.headers['Pragma'] = 'no-cache'
        response.headers['Expires'] = '0'
        
        return response
        
    except Exception as e:
        import traceback
        traceback.print_exc()
        return jsonify({'error': f'PDF预览失败: {str(e)}'}), 500

@app.route('/api/file-download')
def file_download():
    """文件下载API"""
    try:
        file_path = request.args.get('path')
        if not file_path:
            return jsonify({'error': '文件路径不能为空'}), 400
        
        # URL解码和路径标准化
        import urllib.parse
        file_path = urllib.parse.unquote(file_path)
        file_path = os.path.normpath(file_path)
        
        # 安全检查：防止路径遍历
        if '..' in file_path or not os.path.isabs(file_path):
            return jsonify({'error': '无效的文件路径'}), 400
        
        # 检查文件是否存在
        if not os.path.exists(file_path):
            return jsonify({'error': '文件不存在'}), 404
        
        # 检查是否为文件
        if not os.path.isfile(file_path):
            return jsonify({'error': '指定路径不是文件'}), 400
        
        # 获取文件名和MIME类型
        file_name = os.path.basename(file_path)
        file_ext = os.path.splitext(file_name)[1].lower()
        
        # 设置MIME类型
        mime_types = {
            '.txt': 'text/plain',
            '.html': 'text/html',
            '.css': 'text/css',
            '.js': 'application/javascript',
            '.json': 'application/json',
            '.xml': 'application/xml',
            '.pdf': 'application/pdf',
            '.jpg': 'image/jpeg',
            '.jpeg': 'image/jpeg',
            '.png': 'image/png',
            '.gif': 'image/gif',
            '.bmp': 'image/bmp',
            '.webp': 'image/webp',
            '.svg': 'image/svg+xml',
            '.ico': 'image/x-icon',
            '.mp3': 'audio/mpeg',
            '.mp4': 'video/mp4',
            '.zip': 'application/zip',
            '.tar': 'application/x-tar',
            '.gz': 'application/gzip'
        }
        
        mimetype = mime_types.get(file_ext, 'application/octet-stream')
        
        # 检查是否为内联显示（图像和PDF）
        inline_types = {'.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp', '.svg', '.pdf'}
        as_attachment = file_ext not in inline_types
        
        # 为PDF文件添加特殊处理
        if file_ext == '.pdf':
            response = make_response(send_file(
                file_path,
                mimetype=mimetype,
                as_attachment=as_attachment,
                download_name=file_name
            ))
            # 添加允许iframe嵌入的头部
            response.headers['X-Frame-Options'] = 'SAMEORIGIN'
            response.headers['Content-Security-Policy'] = "frame-ancestors 'self'"
            return response
        else:
            return send_file(
                file_path,
                mimetype=mimetype,
                as_attachment=as_attachment,
                download_name=file_name
            )
        
    except Exception as e:
        import traceback
        traceback.print_exc()
        return jsonify({'error': f'下载文件失败: {str(e)}'}), 500

@app.route('/api/log-anomaly-detection/status')
def get_log_anomaly_status():
    """获取日志异常检测状态详情"""
    try:
        from log_anomaly_detector import detector
        status = detector.get_statistics()
        return jsonify(status)
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/log-anomaly-detection/analyze', methods=['POST'])
def analyze_log_anomaly():
    """分析日志异常"""
    try:
        data = request.get_json()
        if not data:
            return jsonify({'error': '请提供日志数据'}), 400
        
        log_content = data.get('log_content', '')
        if not log_content:
            return jsonify({'error': '日志内容不能为空'}), 400
        
        # 导入日志异常检测器
        try:
            from log_anomaly_detector import detector
            
            # 使用新的detector实例分析日志
            result = detector.analyze_logs(log_content)
            
            return jsonify(result)
            
        except ImportError:
            # 回退到简单的异常检测
            results = []
            log_lines = log_content.strip().split('\n')
            
            for line in log_lines:
                if line.strip():
                    anomaly = parse_log_line_to_anomaly(line)
                    if anomaly and anomaly.get('severity') in ['high', 'medium']:
                        results.append(anomaly)
            
            return jsonify({
                'success': True,
                'anomalies_detected': len(results),
                'anomalies': results,
                'statistics': {'total_logs': len(log_lines), 'anomaly_count': len(results)},
                'analysis_method': '基础规则匹配检测'
            })
            
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/log-anomaly-detection/train', methods=['POST'])
def train_log_anomaly_model():
    """训练日志异常检测模型"""
    try:
        data = request.get_json()
        training_data = data.get('training_data', []) if data else []
        
        # 导入日志异常检测器
        try:
            from log_anomaly_detector import detector
            
            # 使用新的detector实例训练模型
            result = detector.train_model(training_data if training_data else None)
            
            return jsonify(result)
            
        except ImportError:
            return jsonify({
                'success': False,
                'error': '日志异常检测模块未安装',
                'model_trained': False
            }), 500
            
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/log-anomaly-detection/templates')
def get_log_templates():
    """获取日志模板信息"""
    try:
        from log_anomaly_detector import detector
        
        # 使用新的detector实例获取模板信息
        result = detector.get_templates()
        
        return jsonify(result)
        
    except ImportError:
        return jsonify({
            'success': False,
            'error': '日志异常检测模块未安装',
            'templates': []
        }), 500
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/log-anomaly-detection/components')
def get_log_components():
    """获取日志组件信息"""
    try:
        from log_anomaly_detector import log_anomaly_detector
        
        # 获取组件统计信息
        stats = log_anomaly_detector.get_statistics()
        components = stats.get('components', {})
        
        component_list = []
        for component, info in components.items():
            component_list.append({
                'name': component,
                'log_count': info.get('count', 0),
                'anomaly_count': info.get('anomalies', 0),
                'last_seen': info.get('last_seen', 'Unknown')
            })
        
        return jsonify({
            'success': True,
            'components': component_list,
            'total_components': len(component_list)
        })
        
    except ImportError:
        return jsonify({
            'success': False,
            'error': '日志异常检测模块未安装',
            'components': []
        }), 500
    except Exception as e:
        return jsonify({'error': str(e)}), 500

if __name__ == '__main__':
    print("KY-ops 智能运维管家启动中...")
    print("可前往相关面板初始化LLM，以获得完整AI-OPS体验！")
    app.run(debug=True, host='0.0.0.0', port=5000)