"""JCL Parser — Phase 2. Parses JCL scripts into structured Job objects."""
import re
from dataclasses import dataclass, field
from typing import Optional


@dataclass
class DDEntry:
    dd_name: str
    dsn: Optional[str] = None
    disp: Optional[str] = None
    sysout: Optional[str] = None
    inline_data: list[str] = field(default_factory=list)


@dataclass
class CondParam:
    code: int
    operator: str   # EQ, NE, GT, GE, LT, LE
    step_name: Optional[str] = None


@dataclass
class JobStep:
    step_name: str
    program: str
    dd_entries: list[DDEntry] = field(default_factory=list)
    cond: Optional[CondParam] = None
    parm: Optional[str] = None


@dataclass
class Job:
    job_name: str
    steps: list[JobStep] = field(default_factory=list)


COND_OPS = {
    "EQ": lambda rc, code: rc == code, "NE": lambda rc, code: rc != code,
    "GT": lambda rc, code: rc > code,  "GE": lambda rc, code: rc >= code,
    "LT": lambda rc, code: rc < code,  "LE": lambda rc, code: rc <= code,
}


def parse_jcl(filepath: str) -> Optional[Job]:
    """Parse a JCL file into a Job object."""
    with open(filepath, "r", encoding="utf-8") as f:
        lines = _merge_continuations(f.readlines())

    job = None
    current_step: Optional[JobStep] = None
    in_sysin = False
    sysin_lines: list[str] = []

    for line in lines:
        stripped = line.strip()
        if stripped.startswith("//*") or not stripped:
            continue

        if in_sysin:
            if stripped == "/*":
                if current_step and current_step.dd_entries:
                    current_step.dd_entries[-1].inline_data = sysin_lines
                sysin_lines = []; in_sysin = False
            else:
                sysin_lines.append(stripped)
            continue

        if not stripped.startswith("//"):
            continue

        content = stripped[2:].strip()

        # JOB
        if re.search(r"\bJOB\b", content, re.IGNORECASE):
            job = Job(job_name=content.split()[0])
            continue

        # EXEC
        m = re.match(r"(\w+)\s+EXEC\s+(?:PGM=)?(\w+)", content, re.IGNORECASE)
        if m:
            step_name, program = m.group(1), m.group(2)
            cond = None
            cm = re.search(r"COND=\s*\(\s*(\d+)\s*,\s*(\w+)", content, re.IGNORECASE)
            if cm:
                cond = CondParam(code=int(cm.group(1)), operator=cm.group(2).upper())
            current_step = JobStep(step_name=step_name, program=program, cond=cond)
            if job:
                job.steps.append(current_step)
            continue

        # DD
        m = re.match(r"(\w+)\s+DD\s*(.*)", content, re.IGNORECASE)
        if m and current_step is not None:
            dd = DDEntry(dd_name=m.group(1))
            params = m.group(2)
            dm = re.search(r"DSN=\s*([^\s,]+)", params, re.IGNORECASE)
            if dm:
                dd.dsn = dm.group(1)
            if dd.dd_name.upper() == "SYSIN" and "*" in params:
                in_sysin = True
            current_step.dd_entries.append(dd)
            continue

    return job


def _merge_continuations(lines: list[str]) -> list[str]:
    merged, buf = [], ""
    for line in lines:
        s = line.rstrip("\n\r")
        buf = (buf + s) if buf else s
        if s.rstrip().endswith(",") and not s.strip().startswith("//*"):
            continue
        merged.append(buf); buf = ""
    if buf:
        merged.append(buf)
    return merged