Nts Business Registration

from __future__ import annotations

import argparse
import datetime as dt
import json
import os
import re
import sys
import urllib.error
import urllib.request
from typing import Any

PROXY_BASE_URL_ENV_VAR = "KSKILL_PROXY_BASE_URL"
DEFAULT_PROXY_BASE_URL = "https://k-skill-proxy.nomadamas.org"
BATCH_LIMIT = 100
VALIDATE_TEXT_FIELD_LIMITS = {
    "p_nm": 30,
    "p_nm2": 30,
    "b_nm": 200,
    "b_sector": 100,
    "b_type": 100,
    "b_adr": 500,
}


class ApiError(RuntimeError):
    def __init__(self, message: str, *, status_code: int | None = None, url: str | None = None):
        super().__init__(message)
        self.status_code = status_code
        self.url = url


def _text_or_none(value: Any) -> str | None:
    if value is None:
        return None
    text = str(value).strip()
    return text or None


def resolve_proxy_base_url(explicit_base_url: str | None = None, env: dict[str, str] | None = None) -> str:
    env = os.environ if env is None else env
    candidate = _text_or_none(explicit_base_url or env.get(PROXY_BASE_URL_ENV_VAR))
    if candidate and candidate.casefold() in {"off", "false", "0", "disable", "disabled", "none"}:
        raise ValueError("KSKILL_PROXY_BASE_URL 가 비활성화되어 있습니다.")
    if candidate and candidate != "replace-me":
        return candidate.rstrip("/")
    return DEFAULT_PROXY_BASE_URL


def normalize_business_number(value: Any) -> str:
    raw = _text_or_none(value)
    if not raw:
        raise ValueError("사업자등록번호(b_no)를 입력하세요.")
    normalized = re.sub(r"\D", "", raw)
    if not re.fullmatch(r"\d{10}", normalized):
        raise ValueError("사업자등록번호는 숫자 10자리여야 합니다.")
    return normalized


def normalize_start_date(value: Any) -> str:
    raw = _text_or_none(value)
    if not raw:
        raise ValueError("개업일자(start_dt)를 YYYYMMDD 형식으로 입력하세요.")
    normalized = re.sub(r"\D", "", raw)
    if not re.fullmatch(r"\d{8}", normalized):
        raise ValueError("개업일자는 YYYYMMDD 형식이어야 합니다.")
    try:
        dt.date(int(normalized[:4]), int(normalized[4:6]), int(normalized[6:8]))
    except ValueError as error:
        raise ValueError("개업일자는 유효한 날짜여야 합니다.") from error
    return normalized


def normalize_validate_text(value: Any, field_name: str, *, required: bool = False) -> str | None:
    text = _text_or_none(value)
    if not text:
        if required:
            raise ValueError(f"{field_name}을(를) 입력하세요.")
        return None
    max_length = VALIDATE_TEXT_FIELD_LIMITS.get(field_name)
    if max_length and len(text) > max_length:
        raise ValueError(f"{field_name}은(는) {max_length}자 이하여야 합니다.")
    return text


def normalize_corp_no(value: Any) -> str | None:
    raw = _text_or_none(value)
    if not raw:
        return None
    normalized = re.sub(r"\D", "", raw)
    if not re.fullmatch(r"\d{13}", normalized):
        raise ValueError("corp_no는 숫자 13자리여야 합니다.")
    return normalized


def build_status_payload(business_numbers: list[Any]) -> dict[str, list[str]]:
    numbers = [normalize_business_number(value) for value in business_numbers]
    numbers = list(dict.fromkeys(numbers))
    if not numbers:
        raise ValueError("사업자등록번호를 1개 이상 입력하세요.")
    if len(numbers) > BATCH_LIMIT:
        raise ValueError("한 번에 조회할 수 있는 사업자등록번호는 100개까지입니다.")
    return {"b_no": numbers}


def build_validate_business(**kwargs: Any) -> dict[str, str]:
    p_nm = normalize_validate_text(kwargs.get("p_nm"), "p_nm", required=True)

    business = {
        "b_no": normalize_business_number(kwargs.get("b_no")),
        "start_dt": normalize_start_date(kwargs.get("start_dt")),
        "p_nm": p_nm,
    }

    for key in ("p_nm2", "b_nm", "b_sector", "b_type", "b_adr"):
        value = normalize_validate_text(kwargs.get(key), key)
        if value:
            business[key] = value

    corp_no = normalize_corp_no(kwargs.get("corp_no"))
    if corp_no:
        business["corp_no"] = corp_no
    return business


def build_validate_payload(businesses: list[dict[str, Any]]) -> dict[str, list[dict[str, str]]