# Use the existing connected PyFluent variable solver.
import json

task_directory = r"C:\Users\13977\AppData\Local\FluentAGI\data\runs\20261019-140836-a95f99"
case_directory = task_directory
end_time = 2.2
time_step = 0.005


def checked(stage, result):
    print(stage)
    print(result)
    value = result
    if isinstance(value, str):
        try:
            value = json.loads(value)
        except ValueError:
            raise RuntimeError("Adapter feedback is not structured; inspect output before continuing.")

    def inspect(item):
        if isinstance(item, dict):
            status = str(item.get("status", "")).strip().lower()
            if status in (
                "needs_review", "error", "failed", "failure",
                "timeout", "interrupted", "aborted"
            ):
                raise RuntimeError("Stopped at " + stage + ": " + status)
            if item.get("needs_review") is True:
                raise RuntimeError("Native feedback requires review at " + stage)
            if item.get("success") is False or item.get("ok") is False:
                raise RuntimeError("Adapter reported failure at " + stage)
            for key, child in item.items():
                if key in ("error", "errors") and child:
                    raise RuntimeError("Adapter reported errors at " + stage)
                if isinstance(child, (dict, list, tuple)):
                    inspect(child)
        elif isinstance(item, (list, tuple)):
            for child in item:
                inspect(child)

    if not isinstance(value, (dict, list, tuple)):
        raise RuntimeError("Missing structured feedback at " + stage)
    inspect(value)
    return value


def reported_time(state):
    if isinstance(state, dict):
        for key in ("flow_time", "final_time"):
            value = state.get(key)
            if isinstance(value, (int, float)) and not isinstance(value, bool):
                return float(value)
    return None


prepared = checked(
    "PREPARE_MOVING_CIRCLE",
    fluentagi.prepare_moving_circle(
        directory=case_directory,
        include_target=False,
        body_diameter=0.06,
        target_diameter=0.04,
        speed=0.1,
        ramp_time=0.4,
        end_time=end_time,
        time_step=time_step,
        size=0.012
    )
)

checked(
    "INSPECT_NATIVE_DYNAMIC_MESH",
    fluentagi.inspect_dynamic_mesh(directory=case_directory)
)

checked(
    "INITIALIZE_NEW_CASE_ONCE",
    fluentagi.initialize_moving_body(directory=case_directory)
)

state = checked(
    "READ_INITIAL_NATIVE_STATE",
    fluentagi.read_moving_body(directory=case_directory)
)

for chunk in range(9):
    previous_time = reported_time(state)
    if previous_time is not None and previous_time >= end_time - 1e-9:
        break

    checked(
        "ADVANCE_CHUNK_" + str(chunk + 1),
        fluentagi.advance_moving_body(
            directory=case_directory,
            steps=50,
            until_time=end_time,
            max_iter_per_step=100
        )
    )

    state = checked(
        "READ_NATIVE_STATE_" + str(chunk + 1),
        fluentagi.read_moving_body(directory=case_directory)
    )
    current_time = reported_time(state)

    if previous_time is not None and current_time is not None:
        if current_time <= previous_time and current_time < end_time - 1e-9:
            raise RuntimeError("No verified time advancement; inspect native state before continuing.")
    if current_time is not None and current_time >= end_time - 1e-9:
        break

final_time = reported_time(state)
print("FINAL_NATIVE_STATE")
print(state)
if final_time is not None and final_time < end_time - 1e-9:
    raise RuntimeError("Target time was not reached; preserve the current solution and inspect feedback.")

checked(
    "FINAL_NATIVE_DYNAMIC_MESH",
    fluentagi.inspect_dynamic_mesh(directory=case_directory)
)

checked(
    "EXPORT_FINAL_FIELDS",
    fluentagi.export_results(
        directory=case_directory,
        fields=["pressure", "velocity-magnitude"]
    )
)