def connect_simulated_scope():
    # Load a configuration for a Keysight DSOX1204G oscilloscope
    # 'simulate=True' tells AutoInstrument to use the simulation backend.
    scope_sim = AutoInstrument.from_config("keysight/DSOX1204G", simulate=True)
    
    # Connect to the backend (important step for instruments)
    scope_sim.connect_backend()
    
    print(f"Successfully connected to simulated: {scope_sim.id()}")
    return scope_sim


def main_sim():
    scope = connect_simulated_scope()
    # You can now interact with 'scope'
    scope.close()  # Close the connection when done


if __name__ == "__main__":
    main_sim()

# This is an example and will likely fail if you don't have this instrument at this address.
def connect_real_psu():
    try:
        # Example: Connecting to a Keysight E36313A Power Supply
        psu_real = AutoInstrument.from_config(
            "keysight/E36313A",
            address="TCPIP0::192.168.1.100::INSTR",
            simulate=False
        )
        psu_real.connect_backend()
        print(f"Successfully connected to: {psu_real.id()}")
        return psu_real
    except Exception as e:
        print(f"Failed to connect to real PSU: {e}")
        return None


def main_real_example():
    psu = connect_real_psu()
    if psu:
        # Interact with the PSU
        psu.close()

# if __name__ == "__main__":
#     main_real_example()

def psu_facade_example():
    # Using a simulated PSU for this example
    psu = AutoInstrument.from_config("keysight/E36311A", simulate=True)  # Example PSU config
    psu.connect_backend()
    print(f"PSU ID: {psu.id()}")

    try:
        # Using the PSUChannelFacade
        # Configure channel 1: set voltage to 3.3V, current limit to 0.5A, then turn it on.
        psu.channel(1).set(voltage=3.3, current_limit=0.5).on()
        print("PSU Channel 1: Voltage set to 3.3V, Current Limit to 0.5A, Output ON")

        # Read back the voltage (assuming the facade has get_voltage)
        # Note: The example PSUChannelFacade.set returns self, for get_voltage you'd call it separately.
        ch1_voltage = psu.channel(1).get_voltage()
        ch1_current = psu.channel(1).get_current()
        ch1_state = psu.channel(1).get_output_state()
        print(f"PSU Channel 1 Readback: Voltage={ch1_voltage}V, Current={ch1_current}A, State={'ON' if ch1_state else 'OFF'}")

        # Turn channel 1 off
        psu.channel(1).off()
        print("PSU Channel 1: Output OFF")
        ch1_state_after_off = psu.channel(1).get_output_state()
        print(f"PSU Channel 1 Readback after off: State={'ON' if ch1_state_after_off else 'OFF'}")

    except Exception as e:
        print(f"An error occurred with PSU facade: {e}")
    finally:
        psu.close()


# To run in Jupyter or script:
if __name__ == "__main__":
    psu_facade_example()

def wg_facade_example():
    wg = AutoInstrument.from_config("keysight/EDU33212A", simulate=True)  # Example WG config
    wg.connect_backend()
    print(f"Waveform Generator ID: {wg.id()}")

    try:
        # Configure channel 1 to output a sine wave
        wg.channel(1).setup_sine(frequency=1e3, amplitude=1.0, offset=0.0).enable()
        print("WG Channel 1: Sine wave, 1kHz, 1.0Vpp, 0V offset, Output ON")

        # Example: Get some configuration (actual methods depend on WGChannelFacade implementation)
        # current_func = wg.channel(1).get_function_type() # Assuming such a method exists
        # current_freq = wg.channel(1).get_frequency()     # Assuming such a method exists
        # print(f"WG Channel 1 Readback: Function={current_func}, Frequency={current_freq}Hz")
        
        # Disable output
        wg.channel(1).disable()
        print("WG Channel 1: Output OFF")

    except Exception as e:
        print(f"An error occurred with Waveform Generator facade: {e}")
    finally:
        wg.close()


# To run in Jupyter or script:
if __name__ == "__main__":
    wg_facade_example()

def dmm_measurement_example():
    dmm = AutoInstrument.from_config("keysight/EDU34450A", simulate=True)  # Example DMM config
    dmm.connect_backend()
    print(f"DMM ID: {dmm.id()}")

    measurement_result = None
    try:
        # Measure DC Voltage
        # The DMM 'measure' method takes a DMMFunction enum member.
        measurement_result = dmm.measure(DMMFunction.VOLTAGE_DC, range_val="AUTO", resolution="DEF")
        print(f"DMM Measurement: {measurement_result.measurement_type} = {measurement_result.values} {measurement_result.units}")
        
    except Exception as e:
        print(f"An error occurred during DMM measurement: {e}")
    finally:
        dmm.close()
    return measurement_result  # Return for database example


# To run in Jupyter or script:
if __name__ == "__main__":
    dmm_result_for_db = dmm_measurement_example()

def database_example(measurement_to_store):
    if not measurement_to_store:
        print("No measurement to store. Skipping database example.")
        # Create a dummy measurement if needed for the example to run
        measurement_to_store = MeasurementResult(
            values=1.234, 
            instrument="SimulatedDMM", 
            units="V", 
            measurement_type="DC Voltage (Dummy)"
        )
        print(f"Using dummy measurement: {measurement_to_store}")

    # Initialize the database (creates 'my_lab_data.db' if it doesn't exist)
    with MeasurementDatabase("my_lab_data") as db:
        print(f"Database initialized at: {db.db_path}")
        
        # Store the measurement result
        # store_measurement is synchronous
        try:
            measurement_codename = db.store_measurement(
                codename=None,  # Let the DB generate a codename
                measurement=measurement_to_store,
                notes="This is a test measurement from the 10-minute tour."
            )
            print(f"Measurement stored with codename: {measurement_codename}")

            # Retrieve the stored measurement
            retrieved_measurement = db.retrieve_measurement(measurement_codename)
            print(f"Retrieved Measurement ({retrieved_measurement.instrument}): {retrieved_measurement.values} {retrieved_measurement.units}")
            print(f"Timestamp: {datetime.fromtimestamp(retrieved_measurement.timestamp)}")

            # List recent measurements
            recent_measurements = db.list_measurements(limit=5)
            print(f"\nRecent measurement codenames: {recent_measurements}")

            # Search for measurements
            search_results = db.search_measurements(query="tour")
            print("\nSearch results for 'tour':")
            for res in search_results:
                print(f"  - {res['codename']}: {res['measurement_type']} from {res['instrument']}")
        except Exception as e:
            print(f"Database operation failed: {e}")

# if __name__ == "__main__":
    # This assumes dmm_result_for_db was populated by the previous cell
    # In a real script, you'd pass results directly.
    # For this notebook, we'll call it directly if the variable exists.
    # if 'dmm_result_for_db' in locals() and dmm_result_for_db:
    #     database_example(dmm_result_for_db)
    # else:
    #     print("DMM result not available for database example. Running with dummy data.")
    #     database_example(None) # Run with dummy data if DMM example didn't produce a result


# Simplified execution for notebook demonstration assuming previous cell ran
if __name__ == '__main__':
    # First, run the DMM example to get a result
    print("--- Running DMM Example First ---")
    dmm_res = dmm_measurement_example()
    print("--- DMM Example Finished ---\n")
    
    print("--- Running Database Example ---")
    database_example(dmm_res)
    print("--- Database Example Finished ---")