import streamlit as st
from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator
import io
import sys

# Title for the Streamlit app
st.title("Quantum Circuit Simulator with Examples")
st.write("Select a quantum circuit example to load and simulate.")

# Define 20 quantum circuit examples (easy to complicated)
examples = {
    "1. Empty Circuit": """
from qiskit import QuantumCircuit
qc = QuantumCircuit(1)
print("Empty circuit created.")
""",
    "2. Single Qubit Hadamard": """
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator

qc = QuantumCircuit(1, 1)
qc.h(0)
qc.measure(0, 0)

simulator = AerSimulator()
compiled_circuit = transpile(qc, simulator)
result = simulator.run(compiled_circuit, shots=1024).result()
counts = result.get_counts()
print(counts)
""",
    "3. Bell State": """
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator

qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])

simulator = AerSimulator()
compiled_circuit = transpile(qc, simulator)
result = simulator.run(compiled_circuit, shots=1024).result()
counts = result.get_counts()
print(counts)
""",
    "4. GHZ State": """
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator

qc = QuantumCircuit(3, 3)
qc.h(0)
qc.cx(0, 1)
qc.cx(1, 2)
qc.measure([0, 1, 2], [0, 1, 2])

simulator = AerSimulator()
compiled_circuit = transpile(qc, simulator)
result = simulator.run(compiled_circuit, shots=1024).result()
counts = result.get_counts()
print(counts)
""",
    "5. Deutsch Algorithm": """
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator

qc = QuantumCircuit(2, 1)
qc.h([0, 1])
qc.cx(0, 1)
qc.h(0)
qc.measure(0, 0)

simulator = AerSimulator()
compiled_circuit = transpile(qc, simulator)
result = simulator.run(compiled_circuit, shots=1024).result()
counts = result.get_counts()
print(counts)
""",
    "6. Quantum Teleportation": """
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator

qc = QuantumCircuit(3, 3)
qc.h(1)
qc.cx(1, 2)
qc.cx(0, 1)
qc.h(0)
qc.measure([0, 1], [0, 1])
qc.cx(1, 2)
qc.cz(0, 2)
qc.measure(2, 2)

simulator = AerSimulator()
compiled_circuit = transpile(qc, simulator)
result = simulator.run(compiled_circuit, shots=1024).result()
counts = result.get_counts()
print(counts)
""",
    "7. DNA Base Pair Encoding": """
from qiskit import QuantumCircuit
qc = QuantumCircuit(2, 2)

# DNA Base Pair Encoding: A -> 00, T -> 01, G -> 10, C -> 11
qc.x(0)  # Example encoding for T (01)
qc.measure([0, 1], [0, 1])

simulator = AerSimulator()
compiled_circuit = transpile(qc, simulator)
result = simulator.run(compiled_circuit, shots=1024).result()
counts = result.get_counts()
print(counts)
""",
    "8. DNA Sequence Matching with Grover's Algorithm": """
from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator
from qiskit.circuit.library import GroverOperator
from qiskit.algorithms import AmplificationProblem

# Define a 2-qubit oracle that marks the state |01> as a solution
def oracle(circuit):
    circuit.cz(0, 1)  # Apply a controlled-Z gate for the |01> state

# Initialize a 2-qubit quantum circuit
qc = QuantumCircuit(2)

# Apply the oracle
oracle(qc)

# Use GroverOperator to amplify the marked solution
problem = AmplificationProblem(oracle_circuit=qc)
grover_circuit = GroverOperator(problem)

# Use AerSimulator as the backend
simulator = AerSimulator()

# Transpile and execute the circuit
compiled_circuit = transpile(grover_circuit, simulator)
result = simulator.run(compiled_circuit, shots=1024).result()

# Retrieve and print the counts
counts = result.get_counts()
print(counts)
""",
    "9. Genetic Variant Interaction": """
from qiskit import QuantumCircuit, Aer
from qiskit_aer import AerSimulator

# Genetic variants as entangled qubits
qc = QuantumCircuit(2, 2)
qc.h(0)  # Variant 1 in superposition
qc.cx(0, 1)  # Entangle with Variant 2
qc.measure([0, 1], [0, 1])

simulator = AerSimulator()
compiled_circuit = transpile(qc, simulator)
result = simulator.run(compiled_circuit, shots=1024).result()
counts = result.get_counts()
print(counts)
""",
    "10. DNA Alignment Scoring": """
from qiskit import QuantumCircuit, Aer
from qiskit_aer import AerSimulator

# Create a Quantum Circuit for DNA alignment
qc = QuantumCircuit(3, 3)

# Simulate possible alignments with superposition
qc.h([0, 1, 2])  # 3 alignments in parallel
qc.measure([0, 1, 2], [0, 1, 2])

simulator = AerSimulator()
compiled_circuit = transpile(qc, simulator)
result = simulator.run(compiled_circuit, shots=1024).result()
counts = result.get_counts()
print(counts)
""",
    "11. Protein Folding Simulation with QAOA": """
from qiskit import Aer, QuantumCircuit
from qiskit.algorithms.optimizers import COBYLA
from qiskit_aer import AerSimulator
from qiskit.algorithms.minimum_eigensolvers import QAOA
from qiskit.circuit.library import TwoLocal

# Build a QAOA circuit for protein folding
p = 1
ansatz = TwoLocal(2, "ry", "cz", reps=p)
qaoa = QAOA(ansatz=ansatz, optimizer=COBYLA())

# Simulate energy minimization
simulator = AerSimulator()
qaoa_result = qaoa.compute_minimum_eigenvalue(operator=None)
print(qaoa_result)
"""
}

# Selection menu for examples
selected_example = st.selectbox("Select a Quantum Circuit Example", list(examples.keys()))

# Display selected example code
st.subheader("Selected Quantum Circuit Code")
st.text_area("Code", examples[selected_example], height=300)

# Run button
if st.button("Run"):
    try:
        # Redirect stdout to capture print output
        old_stdout = sys.stdout
        redirected_output = io.StringIO()
        sys.stdout = redirected_output

        # Execute the selected example
        exec(examples[selected_example])

        # Retrieve and display output
        output = redirected_output.getvalue()
        st.success("Execution successful!")
        st.text_area("Output", output, height=200)
    except Exception as e:
        st.error(f"An error occurred: {e}")
    finally:
        # Reset stdout
        sys.stdout = old_stdout