import argparse
import re
from copy import deepcopy

def to_camel(name):
    parts = name.split("_")
    return parts[0] + "".join(p.capitalize() for p in parts[1:])

def to_m_camel(name):
    return "".join(p.capitalize() for p in name.split("_"))

def to_class(name):
    return "".join(p.capitalize() for p in name.split("_"))

def lower_first(s: str) -> str:
    if not s:
        return s
    return s[0].lower() + s[1:]

def to_path(name):
    parts = name.split(".")
    if len(parts) < 2:  # 如果没有"."，parts长度就是1
        return ""
    return parts[0] + "/" + "/".join(p for p in parts[1:])


def get_first_part(name, default=""):
    delimiter="_"
    if delimiter not in name:
        return default

    parts = name.split(delimiter)
    if not parts or not parts[0]:
        return default

    return parts[0].capitalize()

def parse_args():
    parser = argparse.ArgumentParser(description="Java Code Generator")

    parser.add_argument(
        "--tab",
        default="",
        help="表名，多个用逗号分隔，例如:  tab,tab2"
    )

    parser.add_argument(
        "--model",
        default="",
        help="可选模块 xxlJob,minio,saToken,swagger"
    )

    parser.add_argument(
        "--re",
        action="store_true",
        help="是否覆盖已存在文件（默认不覆盖）"
    )

    parser.add_argument(
        "--conf",
        required=True,
        default="",
        help="配置文件路径"
    )

    return parser.parse_args()


VAR_PATTERN = re.compile(r"\$\{([^}]+)\}")
def get_by_path(data: dict, path: str):
    """
    从 dict 中通过 a.b.c 取值
    """
    cur = data
    for key in path.split("."):
        if not isinstance(cur, dict) or key not in cur:
            return None
        cur = cur[key]
    return cur

def resolve_string(value: str, data: dict) -> str:
    def replacer(match):
        expr = match.group(1)
        v = get_by_path(data, expr)
        return str(v) if v is not None else match.group(0)

    return VAR_PATTERN.sub(replacer, value)

def resolve_config(config: dict, max_rounds=5) -> dict:
    """
    递归解析配置中的 ${xxx}
    """
    result = deepcopy(config)

    for _ in range(max_rounds):
        changed = False

        def walk(obj):
            nonlocal changed
            if isinstance(obj, dict):
                for k, v in obj.items():
                    obj[k] = walk(v)
            elif isinstance(obj, list):
                return [walk(i) for i in obj]
            elif isinstance(obj, str):
                new = resolve_string(obj, result)
                if new != obj:
                    changed = True
                return new
            return obj

        walk(result)

        if not changed:
            break

    return result


def mysql_to_java(mysql_type):
    mapping = {
        "bigint": "Long",
        "int": "Integer",
        "tinyint": "Integer",
        "varchar": "String",
        "mediumtext": "String",
        "datetime": "Date",
        "date": "Date",
        "decimal": "BigDecimal"
    }
    return mapping.get(mysql_type, "String")