main.py

"""
AutoSolver-Evolve 主入口。

支持三种运行模式：
  python main.py run                    # 运行完整演化流程
  python main.py run --config configs/full_run.yaml
  python main.py solve <case.json>      # 单次求解
  python main.py solve <case.json> --solver seed_solvers.local_search
  python main.py gen-cases              # 生成边界用例
"""

from __future__ import annotations

import argparse
import json
import sys

from autosolver.evaluator import evaluate
from autosolver.io import solution_to_json
from autosolver.models import Solution
from autosolver.parser import parse_instance
from autosolver.validator import validate


def _solution_from_dict(data: dict) -> Solution:
    assignments: dict[str, list[str]] = {}
    for item in data.get("assignments", []):
        assignments[item["order_id"]] = list(item["rider_ids"])
    return Solution(assignments=assignments)


def cmd_solve(args: argparse.Namespace) -> int:
    """单次求解命令。"""
    import importlib

    with open(args.input, encoding="utf-8") as f:
        raw_instance: dict = json.load(f)

    instance = parse_instance(raw_instance)
    module = importlib.import_module(args.solver)
    raw_solution: dict = module.solve(raw_instance, time_limit=args.time_limit)

    solution = _solution_from_dict(raw_solution)
    errors = validate(instance, solution)
    if errors:
        for error in errors:
            print(f"Invalid solution: {error}", file=sys.stderr)
        return 2

    evaluation = evaluate(instance, solution)
    print(solution_to_json(solution, evaluation))
    return 0


def cmd_run(args: argparse.Namespace) -> int:
    """演化主循环命令。"""
    from evolve.controller import run

    result = run(config_path=args.config)
    if "error" in result:
        print(f"错误: {result['error']}", file=sys.stderr)
        return 1
    return 0


def cmd_gen_cases(args: argparse.Namespace) -> int:
    """生成边界用例命令。"""
    from case_generator.edge_case import (
        empty_instance,
        fully_connected,
        high_score_variance,
        sparse_graph,
        unbalanced_capacity,
    )
    from case_generator.random_case import generate_to_file
    from pathlib import Path

    target_dir = Path(args.output_dir)
    target_dir.mkdir(parents=True, exist_ok=True)

    cases = [
        ("edge_empty.json", empty_instance()),
        ("edge_fully_connected.json", fully_connected(5, 3)),
        ("edge_sparse.json", sparse_graph(10, 5)),
        ("edge_unbalanced.json", unbalanced_capacity(8, 4)),
        ("edge_high_variance.json", high_score_variance(6, 4)),
    ]

    for filename, data in cases:
        path = target_dir / filename
        with open(path, "w", encoding="utf-8") as f:
            json.dump(data, f, ensure_ascii=False, indent=2)
        print(f"  已生成: {path}")

    # 随机用例
    for i in range(3):
        path = target_dir / f"random_{i + 1:02d}.json"
        generate_to_file(path, num_orders=8 + i * 2, num_riders=4, seed=100 + i)
        print(f"  已生成: {path}")

    return 0


def build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(description="AutoSolver-Evolve")
    sub = parser.add_subparsers(dest="command", required=True)

    # solve
    p_solve = sub.add_parser("solve", help="单次求解")
    p_solve.add_argument("input", help="JSON 用例文件路径")
    p_solve.add_argument("--solver", default="seed_solvers.greedy_single",
                         help="求解器模块名，默认: seed_solvers.greedy_single")
    p_solve.add_argument("--time-limit", type=float, default=5.0,
                         help="求解时间限制（秒），默认: 5.0")
    p_solve.set_defaults(func=cmd_solve)

    # run
    p_run = sub.add_parser("run", help="运行演化流程")
    p_run.add_argument("--config", default=None,
                       help="YAML 配置文件路径，默认: configs/debug.yaml")
    p_run.set_defaults(func=cmd_run)

    # gen-cases
    p_gen = sub.add_parser("gen-cases", help="生成边界用例")
    p_gen.add_argument("--output-dir", default="eval_cases/generated",
                       help="输出目录，默认: eval_cases/generated")
    p_gen.set_defaults(func=cmd_gen_cases)

    return parser


def main(argv: list[str] | None = None) -> int:
    parser = build_parser()
    args = parser.parse_args(argv)
    return args.func(args)


if __name__ == "__main__":
    raise SystemExit(main())