# Planned integration example
import clr
import os
from optixlog import Optixlog

# Add Zemax DLL references
clr.AddReference(r"C:\Program Files\Zemax OpticStudio\ZOS-API\Libraries\ZOSAPI.dll")
clr.AddReference(r"C:\Program Files\Zemax OpticStudio\ZOS-API\Libraries\ZOSAPI_Interfaces.dll")

import ZOSAPI

# Initialize OptixLog
client = Optixlog(api_key=os.getenv("OPTIX_API_KEY"))
project = client.project(name="Zemax_Designs", create_if_not_exists=True)

# Create run
run = project.run(
    name="camera_lens_optimization_v5",
    config={
        "tool": "Zemax OpticStudio",
        "design_type": "Double Gauss",
        "focal_length_mm": 50,
        "f_number": 1.4,
        "wavelengths": [486.1, 587.6, 656.3],  # F, d, C lines
        "field_angles_deg": [0, 10, 20]
    }
)

# Connect to OpticStudio
zos = ZOSAPI.ZOSAPI()
app = zos.CreateNewApplication()
system = app.PrimarySystem

# Load design
system.LoadFile("double_gauss_v5.zmx", False)

# Run optimization
optimizer = system.Tools.OpenLocalOptimization()
optimizer.Algorithm = ZOSAPI.Tools.Optimization.OptimizationAlgorithm.DampedLeastSquares
optimizer.Cycles = ZOSAPI.Tools.Optimization.OptimizationCycles.Automatic
optimizer.RunAndWaitForCompletion()

# Extract merit function value
mf_value = system.MFE.CalculateMeritFunction()

# Log results
run.log(step=0,
        merit_function=float(mf_value),
        effective_focal_length=float(system.SystemData.Aperture.EFL),
        total_track=float(calculate_total_track(system)))

# Extract and log aberration data
run.log(step=1,
        spherical_aberration=get_seidel(system, "SA"),
        coma=get_seidel(system, "COMA"),
        astigmatism=get_seidel(system, "ASTIG"),
        field_curvature=get_seidel(system, "FC"),
        distortion_percent=get_distortion(system))

# Log spot diagrams
for field_idx, field_angle in enumerate(run.config["field_angles_deg"]):
    spot_data = generate_spot_diagram(system, field_idx)
    run.log_matplotlib(f"spot_field_{field_angle}deg", spot_data)

# Track optimization progress
run = project.run(
    name="telephoto_optimization",
    config={
        "design": "telephoto_600mm",
        "optimization_target": "MTF",
        "variables": ["radii", "thicknesses", "glasses"]
    }
)

# Log each optimization cycle
for cycle in range(num_cycles):
    optimizer.RunOneCycle()
    
    run.log(step=cycle,
            merit_function=float(system.MFE.CalculateMeritFunction()),
            mtf_30lp=get_mtf(system, 30),
            mtf_50lp=get_mtf(system, 50))

run = project.run(
    name="tolerance_analysis_production",
    config={
        "design": "smartphone_camera_v2",
        "monte_carlo_samples": 1000,
        "yield_target": 0.95
    }
)

# Run Monte Carlo tolerance analysis
tolerance_tool = system.Tools.OpenTolerancing()
tolerance_tool.RunAndWaitForCompletion()

# Log sensitivity results
for surface in range(system.LDE.NumberOfSurfaces):
    sensitivity = get_surface_sensitivity(tolerance_tool, surface)
    run.log(step=surface,
            surface=surface,
            radius_sensitivity=sensitivity["radius"],
            thickness_sensitivity=sensitivity["thickness"],
            decenter_sensitivity=sensitivity["decenter"])

# Log yield prediction
run.log(step=system.LDE.NumberOfSurfaces,
        predicted_yield=float(tolerance_tool.YieldEstimate),
        worst_offender=get_worst_toleranced_surface(tolerance_tool))

run = project.run(
    name="zoom_lens_24_70mm",
    config={
        "type": "zoom",
        "focal_lengths_mm": [24, 35, 50, 70],
        "aperture": "f/2.8 constant"
    }
)

# Log performance at each zoom position
for config_idx, focal_length in enumerate(run.config["focal_lengths_mm"]):
    system.MCE.SetCurrentConfiguration(config_idx + 1)
    
    run.log(step=config_idx,
            focal_length_mm=focal_length,
            efl_actual=float(system.SystemData.Aperture.EFL),
            mtf_center=get_mtf(system, 30, field=0),
            mtf_edge=get_mtf(system, 30, field=max_field),
            distortion_percent=get_distortion(system))

run = project.run(
    name="stray_light_analysis",
    config={
        "system": "space_telescope",
        "analysis_type": "ghost_analysis",
        "ray_count": 10_000_000
    }
)

# Run ray trace
nsc_trace = system.Tools.OpenNSCRayTrace()
nsc_trace.NumberOfRays = 10_000_000
nsc_trace.RunAndWaitForCompletion()

# Log detector results
detector_data = get_detector_data(system, "image_plane")
run.log(step=0,
        ghost_intensity_ratio=float(detector_data["ghost_max"] / detector_data["signal_max"]),
        total_scattered_flux=float(detector_data["scattered"]),
        signal_to_ghost_dB=float(10 * np.log10(detector_data["signal_max"] / detector_data["ghost_max"])))

run.log_matplotlib("detector_image", plot_detector(detector_data))