from __future__ import annotations

from dataclasses import dataclass

from pathlib import Path

from .diagnostics import GenerationError, invalid_extension, invalid_request

from .extensions import GeneratorExtensions

from .loader import load_openapi, load_openapi_json

from .model import NormalizedSpec

from .normalize import normalize_openapi

from .render import render_package, rendered_type_definition_count

from .write import write_artifacts

@dataclass(frozen=True)

class GenerationRequest:

output_dir: Path

spec_source: str | None = None

package_name: str = "my_client"

overwrite: bool = False

verify_ssl: bool = True

protocol_only: bool = False

generate_routes: bool = True

generate_requests: bool = True

generate_responses: bool = True

extensions: GeneratorExtensions | None = None

spec_json: str | None = None

@dataclass(frozen=True)

class GenerationResult:

success: bool

written_files: tuple[Path, ...] = ()

operations: int = 0

type_definitions: int = 0

diagnostics: tuple[str, ...] = ()

def generate_client(request: GenerationRequest) -> GenerationResult:

if bool(request.spec_source) == bool(request.spec_json):

raise invalid_request("Exactly one of spec_source or spec_json is required")

if not request.package_name:

raise invalid_request("package_name is required")

if request.spec_json is not None:

document = load_openapi_json(request.spec_json)

else:

document = load_openapi(

request.spec_source or "", verify_ssl=request.verify_ssl

)

normalized = normalize_openapi(document, request.package_name)

if request.extensions:

for hook in request.extensions.normalize_hooks:

candidate = hook(normalized)

if not isinstance(candidate, NormalizedSpec):

raise invalid_extension("normalize hook must return NormalizedSpec")

normalized = candidate

artifacts = render_package(

normalized,

request.extensions,

protocol_only=request.protocol_only,

generate_routes=request.generate_routes,

generate_requests=request.generate_requests,

generate_responses=request.generate_responses,

)

written = write_artifacts(

output_dir=request.output_dir, artifacts=artifacts, overwrite=request.overwrite

)

return GenerationResult(

success=True,

written_files=tuple(written),

operations=len(normalized.operations),

type_definitions=rendered_type_definition_count(

normalized,

generate_routes=request.generate_routes,

generate_requests=request.generate_requests,

generate_responses=request.generate_responses,

),

diagnostics=(),

)

def try_generate_client(request: GenerationRequest) -> GenerationResult:

try:

return generate_client(request)

except GenerationError as exc:

return GenerationResult(success=False, diagnostics=(str(exc),))