from model import TransformerModel
from optimizer import TransformerOptimizer

# Example: E55/28/21 N27 transformer with one primary tap and simple secondary

primary_taps = [0, 75, 75]
secondary_taps = [0, 100, 150, 150, 150]

# Resistance per turn for each segment (example values in ohms/turn)
# These would be calculated based on wire gauge, length per turn, etc.
primary_Rp_per_turn = [
    0.01,
    0.01,
]

secondary_Rs_per_turn = [
    0.004,  
    0.024,  
    0.024,  
    0.024,
]

tf = TransformerModel(
    Ae_mm2=354.0,
    Np_total=150,
    Ns_total=550,
    primary_taps=primary_taps,
    secondary_taps=secondary_taps,
    primary_Rp_per_turn=primary_Rp_per_turn,
    secondary_Rs_per_turn=secondary_Rs_per_turn,
)


# (Optional) set copper resistance per turn when you know it
# For example, from earlier rough calc:
#   Rp_total ~ 0.9 Ω for 151 turns -> ~0.9/151 per turn
#   Rs_total ~ 10.8 Ω for 567 turns -> ~10.8/567 per turn
# tf.Rp_per_turn = 0.9 / 151
# tf.Rs_per_turn = 10.8 / 567


print("=" * 70)
print("MANUAL SIMULATION EXAMPLE")
print("=" * 70)

# Use tap 1 for primary (taps[0] to taps[1] => 0 to 128 turns)
# Use tap 1 for secondary (taps[0] to taps[1] => 0 to 567 turns)
primary_tap = 2
secondary_tap = 1

# Say you apply 12 Vrms at 2 kHz into the primary,
# and you choose a load such that power is drawn from the secondary.
result_manual = tf.simulate(
    primary_tap=primary_tap,
    secondary_tap=secondary_tap,
    Vp_rms=18,
    freq_hz=256.0,
    load_ohms=6.0,
    core_loss_W=0.3,  # example; refine later with measurements
)

print(f"Manual configuration:")
print(f"  Primary tap: {primary_tap} ({result_manual['Np_eff']} turns)")
print(f"  Secondary tap: {secondary_tap} ({result_manual['Ns_eff']} turns)")
print(f"  Input voltage: {result_manual['Vp_rms']:.1f} V")
print(f"  Turns ratio: {result_manual['turns_ratio']:.2f}")
print(f"  Output power: {result_manual['P_out_W']:.2f} W")
print(f"  Efficiency: {result_manual['efficiency']*100:.2f}%")
print(f"  Flux density: {result_manual['B_peak_T']:.3f} T")
print(f"  Input current: {result_manual['Ip_rms']:.3f} A")
print(f"  Output voltage: {result_manual['Vs_rms']:.1f} V")
print(f"  Output current: {result_manual['Is_rms']:.3f} A")
print(f"  Copper loss (total): {result_manual['P_cu_W']:.2f} W")
print(f"    Primary: {result_manual['P_cu_primary_W']:.2f} W")
print(f"    Secondary: {result_manual['P_cu_secondary_W']:.2f} W")
print(f"  Core loss: {result_manual['P_core_W']:.2f} W")
print()


print("=" * 70)
print("OPTIMIZER EXAMPLE")
print("=" * 70)

# Create optimizer
opt = TransformerOptimizer(tf)

# Find optimal configuration for delivering 10W to a 1000 ohm load at 2 kHz
result_opt = opt.optimize(
    load_ohms=1500.0,
    target_power_W=10.0,
    freq_hz=45000.0,
    Vp_min=1.0,
    Vp_max=36.0,
    Vp_step=0.5,
    B_max_T=0.4,  # maximum flux density constraint
    Vs_max=130.0,  # maximum secondary voltage constraint
    core_loss_W=0.3,
    power_tolerance_percent=2.0,  # accept ±2% power delivery error
)

if result_opt:
    target_power = 10.0
    if result_opt.power_error_percent > 2.0:
        print(f"NOTE: Target {target_power}W not achievable. Showing max power configuration.")
    print(f"Optimal configuration found:")
    print(f"  Primary tap: {result_opt.primary_tap} ({result_opt.Np_eff} turns)")
    print(f"  Secondary tap: {result_opt.secondary_tap} ({result_opt.Ns_eff} turns)")
    print(f"  Input voltage: {result_opt.Vp_rms:.1f} V")
    print(f"  Turns ratio: {result_opt.turns_ratio:.2f}")
    print(f"  Output power: {result_opt.P_out_W:.2f} W (error: {result_opt.power_error_percent:.2f}%)")
    print(f"  Efficiency: {result_opt.efficiency*100:.2f}%")
    print(f"  Flux density: {result_opt.B_peak_T:.3f} T")
    print(f"  Input current: {result_opt.Ip_rms:.3f} A")
    print(f"  Output voltage: {result_opt.Vs_rms:.1f} V")
    print(f"  Output current: {result_opt.Is_rms:.3f} A")
    print(f"  Copper loss (total): {result_opt.P_cu_W:.2f} W")
    print(f"    Primary: {result_opt.P_cu_primary_W:.2f} W")
    print(f"    Secondary: {result_opt.P_cu_secondary_W:.2f} W")
    print(f"  Core loss: {result_opt.P_core_W:.2f} W")
else:
    print("No valid configuration found within constraints!")