#!/usr/bin/env python3
"""Migrate Baidu-only controllers to AbstractRecognizeController pattern."""

import os
import re
from pathlib import Path

ROOT = Path(__file__).resolve().parents[1]
CTRL_ROOT = ROOT / "api-web/api-interface/src/main/java/com/heyu/api/controller"
HANDLE_ROOT = ROOT / "api-third/src/main/java/com/heyu/api/baidu/handle"

SKIP = {
    "BaseController.java",
    "AbstractRecognizeController.java",
    "TestController.java",
}

BIZ_NAMES = {
    "bus_ticket": "汽车票识别",
    "invoice": "通用机打发票识别",
    "seal": "印章识别",
    "idcard": "身份证识别",
    "medical_outpatient": "门诊病历识别",
}

def load_handles():
    handles = {}
    for path in HANDLE_ROOT.rglob("*Handle.java"):
        text = path.read_text(encoding="utf-8", errors="ignore")
        m = re.search(
            r"class\s+(\w+)\s+extends\s+BaiduBaseHandle<([^,>]+),\s*([^>]+)>",
            text,
        )
        if not m:
            m = re.search(
                r"class\s+(\w+)\s+extends\s+(?:BEducationJsonHandle|BaiduFormRawHandle|BaiduMultipartRawHandle)<([^>]+)>",
                text,
            )
            if m:
                entry = {
                    "request": m.group(2).strip(),
                    "response": "java.util.Map",
                    "uri": None,
                    "json_body": True,
                }
                uri_m = re.search(r'getUri\(\)\s*\{[^}]*return\s+"([^"]+)"', text, re.S)
                if uri_m:
                    entry["uri"] = uri_m.group(1)
                handles[m.group(1)] = entry
                continue
        if not m:
            m = re.search(
                r"class\s+(\w+)\s+extends\s+BEducationJsonHandle<([^>]+)>",
                text,
            )
            if m:
                handles[m.group(1)] = {
                    "request": m.group(2).strip(),
                    "response": "java.util.Map",
                    "uri": None,
                    "json_body": True,
                }
                uri_m = re.search(r'getUri\(\)\s*\{[^}]*return\s+"([^"]+)"', text, re.S)
                if uri_m:
                    handles[m.group(1)]["uri"] = uri_m.group(1)
                continue
        uri_m = re.search(r'getUri\(\)\s*\{[^}]*return\s+"([^"]+)"', text, re.S)
        if m and uri_m:
            handles[m.group(1)] = {
                "request": m.group(2).strip(),
                "response": m.group(3).strip(),
                "uri": uri_m.group(1),
                "json_body": False,
            }
    return handles


def is_simple_method(body: str) -> bool:
    if "for (" in body or "for(" in body:
        return False
    if "BaiduOcrResult.raw" in body:
        return True
    if ".handle(" in body and "return R.error" in body and "new ArrayList" not in body:
        return True
    if ".handle(" in body and "if (bR.isSuccess())" in body and body.count("return") <= 3:
        return True
    return False


def infer_biz_label(class_name, uri):
    base = class_name.replace("Controller", "")
    if base.startswith("Recognize"):
        base = base[len("Recognize") :]
    mapping = {
        "BusTicket": "汽车票识别",
        "Invoice": "通用机打发票识别",
        "Seal": "印章识别",
        "TaxiReceipt": "出租车票识别",
        "AirTicket": "飞机行程单识别",
        "BankReceiptNew": "银行回单识别",
        "BankReceiptNewPro": "银行回单识别（专业版）",
        "FerryTicket": "船票识别",
        "ShoppingReceipt": "购物小票识别",
        "TollInvoice": "过路过桥费发票识别",
        "QuotaInvoice": "定额发票识别",
        "MultipleInvoice": "混贴发票识别",
        "OnlineTaxiItinerary": "网约车行程单识别",
        "VatInvoiceVerification": "增值税发票核验",
        "RecognizeVATInvoice": "增值税发票识别",
        "RecognizeVINCode": "VIN码识别",
        "RecognizeQrCode": "二维码识别",
        "LicensePlate": "车牌识别",
        "IdCard": "身份证识别",
        "IdCardMulti": "身份证混贴识别",
        "ForgeryDetection": "图片篡改检测",
    }
    if base in mapping:
        return mapping[base]
    # camel to words rough
    words = re.sub(r"([a-z])([A-Z])", r"\1\2", base)
    return words + "识别"


def infer_biz_key(uri, class_name):
    if uri:
        tail = uri.rstrip("/").split("/")[-1]
        if tail:
            return tail
    return class_name.replace("Controller", "").lower()


def parse_controller(path: Path):
    text = path.read_text(encoding="utf-8")
    if "extends AbstractRecognizeController" in text:
        return None
    if "com.heyu.api.baidu" not in text:
        return None
    if "com.heyu.api.alibaba" in text:
        return None

  # skip manual complex for now
    if path.name in ("MedicalOutpatientController.java",):
        return "MANUAL"

    pkg_m = re.search(r"package\s+([\w.]+);", text)
    pkg = pkg_m.group(1) if pkg_m else ""

    mapping_m = re.search(r"@RequestMapping\((\{[^}]+\}|\"[^\"]+\")", text)
    if mapping_m:
        base_mapping = mapping_m.group(1).strip().strip('"')
        if base_mapping.startswith("{"):
            # 取第一个路径作为类级 @RequestMapping
            inner = re.search(r'"(/[^"]+)"', base_mapping)
            base_mapping = inner.group(1) if inner else base_mapping
    else:
        base_mapping = ""

    class_m = re.search(r"public class (\w+)", text)
    class_name = class_m.group(1)

    annotations = []
    if "@NotIntercept" in text:
        annotations.append("@NotIntercept")
    if "@Slf4j" in text:
        has_slf4j = True
    else:
        has_slf4j = False

    methods = []
    for m in re.finditer(
        r"(@\w+(?:\([^)]*\))?\s+)*@(?P<mapAnn>RequestMapping|PostMapping)\((?P<mapping_raw>\{[^}]+\}|\"[^\"]+\")\)\s+"
        r"((?:@\w+(?:\([^)]*\))?\s+)*)"
        r"public\s+R(?:<[^>]+>)?\s+(?P<method_name>\w+)\((?P<params>[^)]*)\)\s*\{",
        text,
        re.S,
    ):
        mapping_raw = m.group("mapping_raw")
        map_ann = m.group("mapAnn")
        method_name = m.group("method_name")
        params = m.group("params").strip()
        start = m.end()
        brace = 1
        i = start
        while i < len(text) and brace:
            if text[i] == "{":
                brace += 1
            elif text[i] == "}":
                brace -= 1
            i += 1
        body = text[start : i - 1]
        if not is_simple_method(body):
            return "COMPLEX"
        methods.append(
            {
                "mapping_raw": mapping_raw,
                "map_ann": map_ann,
                "method_name": method_name,
                "params": params,
                "body": body,
            }
        )

    handle_injects = re.findall(
        r"private\s+(\w+Handle)\s+(\w+);", text
    )
    return {
        "path": path,
        "pkg": pkg,
        "class_name": class_name,
        "base_mapping": base_mapping,
        "annotations": annotations,
        "has_slf4j": has_slf4j,
        "methods": methods,
        "handles": handle_injects,
        "text": text,
    }


def extract_handle_from_body(body, handles_meta):
    m = re.search(r"([A-Z]\w*Handle)\.handle\(", body)
    if m:
        return m.group(1)
    m = re.search(r"([A-Z]\w*Handle)\.(?:check|getContent)\(", body)
    if m:
        return m.group(1)
    m = re.search(r"(\w+)\.handle\(", body)
    if m:
        field = m.group(1)
        for handle_name in handles_meta:
            bean = handle_name[0].lower() + handle_name[1:]
            if bean == field:
                return handle_name
    return None


def generate_method(method, handle_name, field_name, handles_meta, class_name, biz_label, biz_key):
    handle = handles_meta.get(handle_name)
    if not handle:
        return None

    resp_type = handle["response"]
    use_map = resp_type in ("Map", "JSONObject", "java.util.Map")
    resp_type_java = "java.util.Map" if use_map else resp_type
    if not use_map and resp_type_java.startswith("com."):
        pass
    elif not use_map and not resp_type_java[0].isupper():
        return None

    req_type = handle["request"]
    params = method["params"]
    param_name = params.split()[-1].replace(",", "").strip() if params else "request"
    if not param_name or param_name == "void":
        param_name = "request"

    uri = handle["uri"]
    side_key = biz_key

    # detect request conversion in body
    pre_code = ""
    actual_param = param_name
    body = method["body"]
    if "new B" in body and "setImageUrl" in body:
        # IdCard style mapping - keep original body setup
        setup = []
        for line in body.splitlines():
            line = line.strip()
            if line.startswith("B") and "Request" in line and "= new" in line:
                setup.append(line)
            elif line.startswith("b") and ".set" in line:
                setup.append(line)
            if "handle(" in line:
                break
        if setup:
            b_req_var = setup[0].split()[0]
            pre_code = "\n        ".join(setup)
            actual_param = b_req_var
            req_type = b_req_var.split()[0] if "=" in setup[0] else req_type

    if "new B" in body and "setVerifyNum" in body:
        setup = []
        for line in body.splitlines():
            line = line.strip()
            if ("Request" in line and "= new" in line) or (
                line.startswith("bRequest.set") or line.startswith("bRequest.")
            ):
                if "handle(" in line:
                    break
                setup.append(line)
        if setup:
            pre_code = "\n        ".join(setup)
            actual_param = setup[0].split()[0]

    method_mapping = method["mapping_raw"]
    cache = "@CacheResult\n    " if "@CacheResult" in body or True else ""
    eb_auth = ""
    if "@EbAuthentication" in body:
        eb_auth = "@EbAuthentication(tencent = ApiConstants.TENCENT_AUTH)\n    "

    post_mapping = method_mapping.strip()
    if post_mapping.startswith("{"):
        post_mapping = post_mapping
    else:
        post_mapping = f'"{post_mapping.strip("\"")}"'

    pre_block = f"{pre_code}\n        " if pre_code else ""

    map_ann = method.get("map_ann", "RequestMapping")
    if map_ann == "PostMapping":
        imports_post = True
    return f"""    @{map_ann}({post_mapping})
    {cache}public R {method['method_name']}({params}) {{
        {pre_block}return executeLegacyBaiduRecognize(LegacyBaiduRecognizeSpec.<{resp_type_java}>builder()
                .bizLabel("{biz_label}")
                .bizKey("{side_key}")
                .uri("{uri}")
                .sideKey("{side_key}")
                .targetLabel("{biz_label.replace('识别', '')}")
                .inputLog(buildInputLog({actual_param}))
                .respClass({resp_type_java}.class)
                .paramCheck(() -> {field_name}.check({actual_param}))
                .requestContent(() -> {field_name}.getContent({actual_param}))
                .build());
    }}"""


def generate_controller(info, handles_meta):
    class_name = info["class_name"]
    uri = ""
    if info["handles"]:
        h0 = info["handles"][0][0]
        if h0 in handles_meta:
            uri = handles_meta[h0]["uri"]
    biz_label = infer_biz_label(class_name, uri)
    biz_key = infer_biz_key(uri, class_name)

    imports = set()
    imports.add("com.heyu.api.controller.AbstractRecognizeController")
    imports.add("com.heyu.api.data.utils.R")
    imports.add("org.springframework.web.bind.annotation.RequestMapping")
    imports.add("org.springframework.web.bind.annotation.RestController")
    imports.add("org.springframework.beans.factory.annotation.Autowired")
    imports.add("com.heyu.api.data.annotation.CacheResult")

    if info["has_slf4j"]:
        imports.add("lombok.extern.slf4j.Slf4j")

    handle_fields = []
    handle_names = []
    for handle_type, field_name in info["handles"]:
        handle_names.append((handle_type, field_name))

    if not handle_names:
        return None

    resp_meta = handles_meta[handle_names[0][0]]["response"]
    use_map = resp_meta in ("Map", "JSONObject", "java.util.Map")
    resp_type = "java.util.Map" if use_map else resp_meta
    if not use_map and resp_type in ("Map", "JSONObject"):
        return None

    for handle_type, field_name in handle_names:
        imports.add(f"com.heyu.api.baidu.handle.{package_for_handle(handle_type)}")
        meta = handles_meta.get(handle_type, {})
        if meta.get("request"):
            imports.add(request_import(meta["request"]))
        if meta.get("response") and not use_map:
            imports.add(response_import(meta["response"]))

    # extra imports from original
    if "ApiIdentityCardRequest" in info["text"]:
        imports.add("com.heyu.api.request.certificate.ApiIdentityCardRequest")
    if "BusinesslicenseVerificationDetailedReq" in info["text"]:
        imports.add("com.heyu.api.request.certificate.BusinesslicenseVerificationDetailedReq")
    if use_map:
        imports.add("java.util.Map")
    if "@NotIntercept" in info["text"]:
        imports.add("com.heyu.api.data.annotation.NotIntercept")
    if "@EbAuthentication" in info["text"]:
        imports.add("com.heyu.api.data.annotation.EbAuthentication")
        imports.add("com.heyu.api.data.constants.ApiConstants")

    if any(m.get("map_ann") == "PostMapping" for m in info["methods"]):
        imports.add("org.springframework.web.bind.annotation.PostMapping")

    methods_code = []
    for method in info["methods"]:
        if len(handle_names) == 1:
            handle, field_name = handle_names[0]
        else:
            idx = len(methods_code)
            if idx >= len(handle_names):
                return None
            handle, field_name = handle_names[idx]
        if not handle or not field_name:
            return None
        mc = generate_method(method, handle, field_name, handles_meta, class_name, biz_label, biz_key)
        if not mc:
            return None
        methods_code.append(mc)

    slf4j = "@Slf4j\n" if info["has_slf4j"] else ""
    not_intercept = "@NotIntercept\n" if "@NotIntercept" in info["text"] else ""
    ann = info["annotations"]

    lines = [
        f"package {info['pkg']};",
        "",
    ]
    for imp in sorted(imports):
        lines.append(f"import {imp};")
    lines.extend(
        [
            "",
            slf4j.rstrip(),
            "@RestController",
            f'@RequestMapping("{info["base_mapping"]}")',
            not_intercept.rstrip(),
            f"public class {class_name} extends AbstractRecognizeController {{",
            "",
            f'    private static final String SIDE_KEY = "{biz_key}";',
            "",
        ]
    )
    for handle_type, field_name in handle_names:
        lines.append("    @Autowired")
        lines.append(f"    private {handle_type} {field_name};")
        lines.append("")

    lines.extend(methods_code)
    lines.extend(
        [
            "",
            "    @Override",
            "    protected Object defaultEmptyResp(String side) {",
            f"        return {'new java.util.HashMap<>()' if use_map else 'new ' + resp_type + '()'};",
            "    }",
            "",
            f"    private String buildInputLog(Object request) {{",
            '        if (request == null) {',
            '            return "未收到请求体";',
            "        }",
            '        return "已收到请求体，具体字段见业务入参";',
            "    }",
            "}",
            "",
        ]
    )
    return "\n".join(line for line in lines if line is not None)


def package_for_handle(handle_type: str) -> str:
    rel = None
    for path in HANDLE_ROOT.rglob(f"{handle_type}.java"):
        rel = path.relative_to(HANDLE_ROOT).parent
        break
    if rel:
        return ".".join(rel.parts) + f".{handle_type}"
    return handle_type


def request_import(req: str) -> str:
    for path in (ROOT / "api-third").rglob(f"{req}.java"):
        rel = path.relative_to(ROOT / "api-third/src/main/java")
        return ".".join(rel.with_suffix("").parts)
    return f"com.heyu.api.baidu.request.{req}"


def response_import(resp: str) -> str:
    for path in (ROOT / "api-third").rglob(f"{resp}.java"):
        rel = path.relative_to(ROOT / "api-third/src/main/java")
        return ".".join(rel.with_suffix("").parts)
    return f"com.heyu.api.baidu.response.{resp}"


def main():
    handles_meta = load_handles()
    migrated = []
    skipped = []
    manual = []
    for path in sorted(CTRL_ROOT.rglob("*Controller.java")):
        if path.name in SKIP:
            continue
        info = parse_controller(path)
        if info == "MANUAL" or info == "COMPLEX":
            manual.append(str(path))
            continue
        if not info:
            continue
        code = generate_controller(info, handles_meta)
        if not code:
            skipped.append(str(path))
            continue
        path.write_text(code, encoding="utf-8")
        migrated.append(str(path))

    print(f"migrated: {len(migrated)}")
    for p in migrated:
        print("  OK", p.replace(str(ROOT) + "/", ""))
    print(f"skipped: {len(skipped)}")
    for p in skipped:
        print("  SKIP", p.replace(str(ROOT) + "/", ""))
    print(f"manual: {len(manual)}")
    for p in manual:
        print("  MANUAL", p.replace(str(ROOT) + "/", ""))


if __name__ == "__main__":
    main()