from flask import Flask, render_template, request, jsonify
from flask_cors import CORS
import os
import subprocess
import json
import threading
import time
import schedule
from urllib.parse import unquote
from datetime import datetime
import shutil
import psutil
from functools import wraps

# 基础配置
app = Flask(__name__)
CORS(app, resources=r"/*")

# 目录配置
BASE_DIR = os.getcwd()
TASKS_DIR = os.path.join(BASE_DIR, "tasks")
LOG_DIR = os.path.join(BASE_DIR, "logs")
CONFIG_FILE = os.path.join(BASE_DIR, "config.json")
PROCESSES_FILE = os.path.join(BASE_DIR, "processes.json")

# 常量配置
LOG_LINES = 200
MONITOR_INTERVAL = 10
SCHEDULER_INTERVAL = 1

# 全局变量
SCRIPT_CONFIGS = {}
running_processes = {}
script_outputs = {}
scheduled_jobs = {}
scheduler_running = True
monitor_running = True
manual_stopped_scripts = set()  # 记录手动停止的脚本


# 初始化函数
def init_dirs():
    for dir_path in [TASKS_DIR, LOG_DIR]:
        if not os.path.exists(dir_path):
            os.makedirs(dir_path, exist_ok=True)
            app.logger.info(f"创建目录：{dir_path}")


def is_script_running(script_name):
    """检查系统中是否已有该脚本的进程在运行"""
    script_path = get_script_path(script_name)
    if not os.path.exists(script_path):
        return False, None

    # 标准化路径（处理大小写和符号链接）
    normalized_path = os.path.normcase(os.path.realpath(script_path))

    # 遍历所有进程检查命令行
    for proc in psutil.process_iter(['pid', 'cmdline', 'name']):
        try:
            cmdline = proc.info['cmdline']
            if not cmdline:
                continue

            # 检查命令行中是否包含脚本路径
            cmd_str = ' '.join(cmdline).lower()
            if normalized_path.lower() in cmd_str:
                return True, proc.info['pid']
        except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
            continue
    return False, None


def load_configs():
    global SCRIPT_CONFIGS
    try:
        if os.path.exists(CONFIG_FILE):
            with open(CONFIG_FILE, "r", encoding="utf-8") as f:
                loaded_configs = json.load(f)
                # 标准化所有键的路径分隔符
                normalized_configs = {}
                for script_name, config in loaded_configs.items():
                    normalized_name = normalize_script_name(script_name)
                    normalized_configs[normalized_name] = config
                SCRIPT_CONFIGS = normalized_configs
                # 补全缺失的配置项
                for script_name, config in SCRIPT_CONFIGS.items():
                    if "mode" not in config:
                        config["mode"] = "long-running"
                    if config["mode"] == "interval" and ("interval" not in config or "unit" not in config):
                        config["interval"] = 1
                        config["unit"] = "hours"
        else:
            SCRIPT_CONFIGS = {}
            app.logger.info("配置文件不存在，初始化空配置")
    except Exception as e:
        SCRIPT_CONFIGS = {}
        app.logger.error(f"加载配置失败：{str(e)}，使用空配置")


def save_configs():
    try:
        with open(CONFIG_FILE, "w", encoding="utf-8") as f:
            json.dump(SCRIPT_CONFIGS, f, indent=2, ensure_ascii=False)
        app.logger.info("配置保存成功")
    except Exception as e:
        app.logger.error(f"保存配置失败：{str(e)}")
        raise


def load_processes():
    """只加载进程信息数据，不恢复进程对象"""
    try:
        if os.path.exists(PROCESSES_FILE):
            with open(PROCESSES_FILE, "r", encoding="utf-8") as f:
                processes_data = json.load(f)
                app.logger.info(f"加载了{len(processes_data)}条进程历史记录")
                return processes_data
    except Exception as e:
        app.logger.error(f"加载进程信息失败：{str(e)}")
    return {}


def save_processes():
    try:
        processes_data = {}
        for name, proc in running_processes.items():
            # 安全获取命令行参数
            cmd = getattr(proc, 'args', [])
            if isinstance(cmd, str):
                cmd = cmd.split()

            processes_data[name] = {
                "pid": proc.pid,
                "script_name": name,
                "start_time": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
                "cmd": cmd
            }
        with open(PROCESSES_FILE, "w", encoding="utf-8") as f:
            json.dump(processes_data, f, indent=2, ensure_ascii=False)
    except Exception as e:
        app.logger.error(f"保存进程信息失败：{str(e)}")


# 日志处理函数
def get_log_path(script_name):
    """获取日志文件路径，并确保父目录存在"""
    safe_script_name = script_name.replace('/', os.sep).replace('\\', os.sep)
    log_filename = f"{os.path.splitext(safe_script_name)[0]}.log"
    log_path = os.path.join(LOG_DIR, log_filename)

    log_dir = os.path.dirname(log_path)
    if not os.path.exists(log_dir):
        os.makedirs(log_dir, exist_ok=True)
        app.logger.info(f"创建日志目录：{log_dir}")

    return log_path


def normalize_script_name(script_name):
    """标准化脚本名称，统一路径分隔符为正斜杠"""
    return script_name.replace("\\", "/")


def load_script_log(script_name):
    log_path = get_log_path(script_name)
    logs = []
    if os.path.exists(log_path):
        try:
            with open(log_path, "r", encoding="utf-8", errors="ignore") as f:
                lines = f.readlines()[-LOG_LINES:]
                logs = [line.strip() for line in lines if line.strip()]
        except Exception as e:
            app.logger.error(f"加载{script_name}日志失败：{str(e)}")
            logs = [f"⚠️  加载历史日志失败：{str(e)}"]
    return logs


def write_script_log(script_name, content):
    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    log_line = f"[{timestamp}] {content}"

    if script_name not in script_outputs:
        script_outputs[script_name] = []
    script_outputs[script_name].append(log_line)
    script_outputs[script_name] = script_outputs[script_name][-LOG_LINES:]

    log_path = get_log_path(script_name)
    try:
        with open(log_path, "a", encoding="utf-8", errors="ignore") as f:
            f.write(log_line + "\n")
    except Exception as e:
        app.logger.error(f"写入{script_name}日志失败：{str(e)}")
        error_line = f"[{timestamp}] ⚠️  日志写入失败：{str(e)}"
        script_outputs[script_name].append(error_line)
        script_outputs[script_name] = script_outputs[script_name][-LOG_LINES:]


# 定时任务处理
def add_scheduled_task(script_name):
    global scheduled_jobs
    try:
        removed = remove_scheduled_task(script_name)
        app.logger.info(f"移除{script_name}旧任务：{'成功' if removed else '无旧任务'}")

        config = SCRIPT_CONFIGS.get(script_name)
        if not config or config["mode"] != "interval":
            app.logger.error(f"{script_name}配置无效，无法添加定时任务")
            return False

        interval = int(config.get("interval", 1))
        unit = config.get("unit", "hours")
        app.logger.info(f"准备添加定时任务：{script_name}（每{interval}{unit}）")

        def run_scheduled_script():
            write_script_log(script_name, f"⏰ 定时任务触发（当前时间：{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}）")
            script_path = get_script_path(script_name)
            write_script_log(script_name, f"📌 尝试执行脚本路径：{script_path}")

            if not os.path.exists(script_path):
                write_script_log(script_name, f"❌ 脚本路径不存在！（检查路径是否正确）")
                return

            if script_name.endswith(".bat"):
                cmd = ["cmd", "/c", script_path]
                write_script_log(script_name, f"📝 执行BAT命令：{cmd}")
            elif script_name.endswith(".py"):
                python_path = config.get("python_path", "python")
                cmd = [python_path, script_path]
                write_script_log(script_name, f"📝 执行Python命令：{cmd}（Python路径：{python_path}）")
            else:
                write_script_log(script_name, "❌ 不支持的脚本类型（仅支持.bat/.py）")
                return

            try:
                write_script_log(script_name, "▶️ 开始执行定时任务...")
                result = subprocess.run(
                    cmd,
                    stdout=subprocess.PIPE,
                    stderr=subprocess.STDOUT,
                    text=True,
                    encoding="utf-8",
                    cwd=TASKS_DIR,
                    timeout=60
                )
                write_script_log(script_name, f"📊 任务执行完成（返回码：{result.returncode}）")
                if result.stdout:
                    for line in result.stdout.splitlines():
                        write_script_log(script_name, f"📝 脚本输出：{line.strip()}")
                if result.returncode == 0:
                    write_script_log(script_name, "✅ 定时任务执行成功")
                else:
                    write_script_log(script_name, f"❌ 定时任务执行失败（返回码非0）")
            except subprocess.TimeoutExpired:
                write_script_log(script_name, "❌ 定时任务执行超时（超过60秒）")
            except Exception as e:
                write_script_log(script_name, f"❌ 任务执行异常：{str(e)}（检查脚本是否可手动运行）")

        job = None
        if unit == "minutes":
            job = schedule.every(interval).minutes.do(run_scheduled_script)
        elif unit == "hours":
            job = schedule.every(interval).hours.do(run_scheduled_script)
        elif unit == "days":
            job = schedule.every(interval).days.do(run_scheduled_script)
        else:
            write_script_log(script_name, f"❌ 不支持的时间单位：{unit}")
            return False

        job.ident = script_name
        scheduled_jobs[script_name] = job
        write_script_log(script_name, f"✅ 定时任务已添加（每{interval}{unit}执行一次）")
        return True
    except Exception as e:
        write_script_log(script_name, f"❌ 添加定时任务失败：{str(e)}")
        app.logger.error(f"{script_name}添加定时任务失败：{str(e)}")
        return False


def remove_scheduled_task(script_name):
    global scheduled_jobs
    if script_name in scheduled_jobs:
        schedule.cancel_job(scheduled_jobs[script_name])
        del scheduled_jobs[script_name]
        write_script_log(script_name, "⏹️  定时任务已移除")
        app.logger.info(f"{script_name}定时任务移除成功")
        return True
    return False


def run_scheduler():
    global scheduler_running
    app.logger.info("定时任务调度线程已启动")
    while scheduler_running:
        pending_jobs = len(schedule.get_jobs())
        app.logger.debug(f"调度器循环 - 待执行任务数: {pending_jobs}")
        schedule.run_pending()
        time.sleep(SCHEDULER_INTERVAL)
    app.logger.info("定时任务调度线程已停止")


# 长期运行脚本处理
def get_script_path(script_name):
    """获取脚本的完整路径"""
    safe_script_name = script_name.replace('/', os.sep).replace('\\', os.sep)
    script_path = os.path.join(TASKS_DIR, safe_script_name)
    app.logger.debug(f"解析脚本路径：{script_name} -> {script_path}（是否存在：{os.path.exists(script_path)}）")
    return script_path


def start_long_running_script(script_name):
    # 检查是否已在系统中运行
    is_running, pid = is_script_running(script_name)
    if is_running:
        write_script_log(script_name, f"⚠️  检测到脚本已在运行（PID: {pid}），无需重复启动")
        running_processes[script_name] = psutil.Process(pid)
        save_processes()
        return True

    script_path = get_script_path(script_name)
    if not os.path.exists(script_path):
        write_script_log(script_name, f"❌ 脚本不存在：{script_path}")
        return False

    config = SCRIPT_CONFIGS.get(script_name, {})

    if script_name.endswith(".bat"):
        cmd = ["cmd", "/c", "start", "/b", script_path]
    elif script_name.endswith(".py"):
        python_path = config.get("python_path", "python")
        cmd = [python_path, script_path]
    else:
        write_script_log(script_name, "❌ 不支持的脚本类型")
        return False

    def target():
        try:
            proc = subprocess.Popen(
                cmd,
                stdout=subprocess.PIPE,
                stderr=subprocess.STDOUT,
                stdin=subprocess.PIPE,
                text=True,
                encoding="utf-8",
                errors="ignore",
                cwd=TASKS_DIR
            )
            running_processes[script_name] = proc
            save_processes()
            write_script_log(script_name, "✅ 长期运行脚本已启动")

            while proc.poll() is None:
                line = proc.stdout.readline()
                if line:
                    write_script_log(script_name, line.strip())
                time.sleep(0.1)

            exit_code = proc.returncode
            if exit_code == 0:
                write_script_log(script_name, f"ℹ️  脚本正常退出（返回码：{exit_code}）")
            else:
                write_script_log(script_name, f"❌ 脚本异常退出（返回码：{exit_code}）")
        except Exception as e:
            write_script_log(script_name, f"❌ 脚本执行异常：{str(e)}")
        finally:
            running_processes.pop(script_name, None)
            save_processes()
            app.logger.info(f"{script_name}长期运行进程已退出")

    thread = threading.Thread(target=target, daemon=True)
    thread.start()
    return True


@app.route("/api/scheduled-jobs")
def api_scheduled_jobs():
    """查看当前所有定时任务"""
    jobs = []
    for job in schedule.get_jobs():
        jobs.append({
            "script_name": next((name for name, j in scheduled_jobs.items() if j == job), "未知"),
            "interval": str(job.interval),
            "next_run": job.next_run.strftime("%Y-%m-%d %H:%M:%S") if job.next_run else "立即执行"
        })
    return jsonify(jobs), 200


def monitor_long_running_scripts():
    global monitor_running
    app.logger.info("长期脚本监控线程已启动")
    while monitor_running:
        for script_name, config in SCRIPT_CONFIGS.items():
            if config.get("mode") == "long-running" and script_name not in manual_stopped_scripts:
                is_system_running, _ = is_script_running(script_name)
                is_memory_running = False
                if script_name in running_processes:
                    try:
                        proc = psutil.Process(running_processes[script_name].pid)
                        is_memory_running = proc.is_running()
                    except (psutil.NoSuchProcess, psutil.AccessDenied):
                        is_memory_running = False

                if not is_system_running and not is_memory_running:
                    app.logger.info(f"{script_name}长期脚本未运行，尝试重启")
                    write_script_log(script_name, "⚠️  脚本未运行，尝试重启...")
                    start_long_running_script(script_name)
        time.sleep(MONITOR_INTERVAL)


# 单次运行脚本处理
def start_single_run_script(script_name):
    # 检查是否已在运行
    if script_name in running_processes:
        proc = running_processes[script_name]
        if proc.poll() is None:
            write_script_log(script_name, "⚠️  单次任务已在运行中，无需重复启动")
            return False

    is_running, pid = is_script_running(script_name)
    if is_running:
        write_script_log(script_name, f"⚠️  检测到脚本已在运行（PID: {pid}），无需重复启动")
        return False

    script_path = get_script_path(script_name)
    if not os.path.exists(script_path):
        write_script_log(script_name, f"❌ 脚本不存在：{script_path}")
        return False

    config = SCRIPT_CONFIGS.get(script_name, {})

    if script_name.endswith(".bat"):
        cmd = ["cmd", "/c", script_path]
    elif script_name.endswith(".py"):
        python_path = config.get("python_path", "python")
        cmd = [python_path, script_path]
    else:
        write_script_log(script_name, "❌ 不支持的脚本类型")
        return False

    def target():
        try:
            write_script_log(script_name, "✅ 单次运行脚本已启动")
            proc = subprocess.Popen(
                cmd,
                stdout=subprocess.PIPE,
                stderr=subprocess.STDOUT,
                text=True,
                encoding="utf-8",
                errors="ignore",
                cwd=TASKS_DIR
            )
            running_processes[script_name] = proc
            save_processes()

            while proc.poll() is None:
                line = proc.stdout.readline()
                if line:
                    write_script_log(script_name, line.strip())
                time.sleep(0.1)

            exit_code = proc.returncode
            if exit_code == 0:
                write_script_log(script_name, f"✅ 单次运行脚本执行成功（返回码：{exit_code}）")
            else:
                write_script_log(script_name, f"❌ 单次运行脚本执行失败（返回码：{exit_code}）")
        except Exception as e:
            write_script_log(script_name, f"❌ 单次运行脚本异常：{str(e)}")
        finally:
            running_processes.pop(script_name, None)
            save_processes()

    thread = threading.Thread(target=target, daemon=True)
    thread.start()
    return True


# API接口
@app.route("/")
def index():
    return render_template("index.html")


@app.route("/api/scripts")
def api_get_scripts():
    try:
        # 扫描所有脚本
        scripts = []
        for root, dirs, files in os.walk(TASKS_DIR):
            for file in files:
                if file.endswith((".py", ".bat")):
                    # 计算相对路径作为脚本名
                    rel_path = os.path.relpath(os.path.join(root, file), TASKS_DIR)
                    script_name = normalize_script_name(rel_path)
                    # 获取修改时间
                    modify_time = os.path.getmtime(os.path.join(root, file))
                    scripts.append({
                        "name": script_name,
                        "modify_time": modify_time,
                        "modify_time_str": datetime.fromtimestamp(modify_time).strftime("%Y-%m-%d %H:%M")
                    })

        # 只保留有配置的脚本
        configured_scripts = [s for s in scripts if s["name"] in SCRIPT_CONFIGS]
        return jsonify(configured_scripts), 200
    except Exception as e:
        app.logger.error(f"获取脚本列表失败：{str(e)}")
        return jsonify({"error": str(e)}), 500


@app.route("/api/scripts/status")
def api_get_scripts_status():
    try:
        result = {}
        # 遍历所有有配置的脚本
        for script_name in SCRIPT_CONFIGS.keys():
            # 获取状态
            is_running, pid = is_script_running(script_name)
            status = "running" if is_running else "scheduled" if script_name in scheduled_jobs else "stopped"

            # 获取模式和调度信息
            mode = SCRIPT_CONFIGS[script_name].get("mode", "single-run")
            schedule_info = ""
            if mode == "interval" and script_name in scheduled_jobs:
                job = scheduled_jobs[script_name]
                schedule_info = f"下次执行: {job.next_run.strftime('%Y-%m-%d %H:%M')}"

            result[script_name] = {
                "status": status,
                "running": is_running,
                "scheduled": script_name in scheduled_jobs,
                "mode": mode,
                "schedule_info": schedule_info
            }
        return jsonify(result), 200
    except Exception as e:
        app.logger.error(f"批量获取脚本状态失败：{str(e)}")
        return jsonify({"error": str(e)}), 500


@app.route("/api/status/<path:script_name>")
def api_get_status(script_name):
    try:
        script_name = normalize_script_name(unquote(script_name))
        is_running, pid = is_script_running(script_name)
        is_scheduled = script_name in scheduled_jobs

        status = "stopped"
        if is_running:
            status = "running"
        elif is_scheduled:
            status = "scheduled"

        # 获取输出日志
        output = load_script_log(script_name)

        return jsonify({
            "status": status,
            "running": is_running,
            "scheduled": is_scheduled,
            "pid": pid,
            "output": output
        }), 200
    except Exception as e:
        app.logger.error(f"获取{script_name}状态失败：{str(e)}")
        return jsonify({"error": str(e)}), 500


@app.route("/api/start/<path:script_name>")
def api_start_script(script_name):
    try:
        script_name = normalize_script_name(unquote(script_name))
        if script_name not in SCRIPT_CONFIGS:
            return jsonify({"error": "脚本未配置"}), 400

        config = SCRIPT_CONFIGS[script_name]
        mode = config.get("mode", "single-run")

        # 清除手动停止标记
        manual_stopped_scripts.discard(script_name)

        if mode == "long-running":
            success = start_long_running_script(script_name)
            msg = "启动成功" if success else "启动失败"
        elif mode == "interval":
            success = add_scheduled_task(script_name)
            msg = "定时任务启动成功" if success else "定时任务启动失败"
        else:  # single-run
            success = start_single_run_script(script_name)
            msg = "启动成功" if success else "启动失败"

        return jsonify({"msg": msg, "success": success}), 200
    except Exception as e:
        app.logger.error(f"启动{script_name}失败：{str(e)}")
        return jsonify({"error": str(e)}), 500


@app.route("/api/stop/<path:script_name>")
def api_stop_script(script_name):
    try:
        script_name = normalize_script_name(unquote(script_name))
        if script_name not in SCRIPT_CONFIGS:
            return jsonify({"error": "脚本未配置"}), 400

        # 标记为手动停止
        manual_stopped_scripts.add(script_name)

        # 停止定时任务
        remove_scheduled_task(script_name)

        # 停止进程
        is_running, pid = is_script_running(script_name)
        if is_running and pid:
            try:
                proc = psutil.Process(pid)
                proc.terminate()
                time.sleep(1)
                if proc.is_running():
                    proc.kill()
                write_script_log(script_name, f"✅ 进程已终止（PID: {pid}）")
            except Exception as e:
                app.logger.error(f"终止{script_name}进程失败：{str(e)}")
                return jsonify({"error": f"终止进程失败：{str(e)}"}), 500

        # 清除内存记录
        running_processes.pop(script_name, None)
        save_processes()

        return jsonify({"msg": "已停止"}), 200
    except Exception as e:
        app.logger.error(f"停止{script_name}失败：{str(e)}")
        return jsonify({"error": str(e)}), 500


@app.route("/api/config", methods=["GET", "POST"])
def api_config():
    if request.method == "POST":
        try:
            new_configs = request.get_json()
            if not isinstance(new_configs, dict):
                return jsonify({"error": "配置格式错误"}), 400

            # 更新配置
            for script_name, config in new_configs.items():
                normalized_name = normalize_script_name(script_name)
                SCRIPT_CONFIGS[normalized_name] = config
                # 重新加载定时任务
                if config.get("mode") == "interval":
                    add_scheduled_task(normalized_name)
                else:
                    remove_scheduled_task(normalized_name)

            save_configs()
            return jsonify({"msg": "配置保存成功"}), 200
        except Exception as e:
            app.logger.error(f"保存配置失败：{str(e)}")
            return jsonify({"error": str(e)}), 500
    else:
        # 获取当前配置
        return jsonify(SCRIPT_CONFIGS), 200


@app.route("/api/directory")
def api_get_directory():
    try:
        path = request.args.get("path", "")
        full_path = os.path.join(TASKS_DIR, path.replace('/', os.sep))

        if not os.path.exists(full_path) or not os.path.isdir(full_path):
            return jsonify({"error": "目录不存在"}), 404

        directories = []
        files = []
        for item in os.listdir(full_path):
            item_path = os.path.join(full_path, item)
            rel_path = os.path.relpath(item_path, TASKS_DIR)
            normalized_path = normalize_script_name(rel_path)

            if os.path.isdir(item_path):
                directories.append({
                    "name": item,
                    "path": normalized_path
                })
            else:
                files.append({
                    "name": item,
                    "path": normalized_path
                })

        # 排序：目录在前，按名称排序
        directories.sort(key=lambda x: x["name"].lower())
        files.sort(key=lambda x: x["name"].lower())

        return jsonify({
            "directories": directories,
            "files": files
        }), 200
    except Exception as e:
        app.logger.error(f"获取目录内容失败：{str(e)}")
        return jsonify({"error": str(e)}), 500


# 启动与初始化
def main():
    init_dirs()
    load_configs()
    load_processes()

    # 启动调度器线程
    scheduler_thread = threading.Thread(target=run_scheduler, daemon=True)
    scheduler_thread.start()

    # 启动监控线程
    monitor_thread = threading.Thread(target=monitor_long_running_scripts, daemon=True)
    monitor_thread.start()

    # 启动定时任务
    for script_name, config in SCRIPT_CONFIGS.items():
        if config.get("mode") == "interval":
            add_scheduled_task(script_name)
        elif config.get("mode") == "long-running":
            # 启动长期运行脚本
            start_long_running_script(script_name)

    app.run(host="0.0.0.0", port=5078, debug=False)


if __name__ == "__main__":
    main()